ripple-lib

  • Version 1.10.0
  • Published
  • 4.98 MB
  • 11 dependencies
  • ISC license

Install

npm i ripple-lib
yarn add ripple-lib
pnpm add ripple-lib

Overview

A TypeScript/JavaScript API for interacting with the XRP Ledger in Node.js and the browser

Index

Functions

Classes

Interfaces

Type Aliases

Functions

function computeAccountLedgerObjectID

computeAccountLedgerObjectID: (address: string) => string;

    function computeBinaryTransactionHash

    computeBinaryTransactionHash: (txBlobHex: string) => string;

      function computeBinaryTransactionSigningHash

      computeBinaryTransactionSigningHash: (txBlobHex: string) => string;

        function computeEscrowHash

        computeEscrowHash: (address: any, sequence: any) => string;

          function computeLedgerHash

          computeLedgerHash: (ledgerHeader: any) => string;

            function computeLedgerHeaderHash

            computeLedgerHeaderHash: (
            ledger: any,
            options?: ComputeLedgerHeaderHashOptions
            ) => string;

              function computeOrderID

              computeOrderID: (address: string, sequence: number) => string;

                function computePaymentChannelHash

                computePaymentChannelHash: (
                address: any,
                dstAddress: any,
                sequence: any
                ) => string;

                  function computeSignerListLedgerObjectID

                  computeSignerListLedgerObjectID: (address: string) => string;

                    function computeStateTreeHash

                    computeStateTreeHash: (entries: any[]) => string;

                      function computeTransactionHash

                      computeTransactionHash: (txJSON: any) => string;

                        function computeTransactionTreeHash

                        computeTransactionTreeHash: (transactions: any[]) => string;

                          function computeTrustlineHash

                          computeTrustlineHash: (
                          address1: string,
                          address2: string,
                          currency: string
                          ) => string;

                            function convertKeysFromSnakeCaseToCamelCase

                            convertKeysFromSnakeCaseToCamelCase: (obj: any) => any;

                              function deriveXAddress

                              deriveXAddress: (options: {
                              publicKey: string;
                              tag: number | false;
                              test: boolean;
                              }) => string;

                                function dropsToXrp

                                dropsToXrp: (drops: any) => string;

                                  function generateAddress

                                  generateAddress: (options?: GenerateAddressOptions) => GeneratedAddress;

                                    function generateXAddress

                                    generateXAddress: (options?: GenerateAddressOptions) => GeneratedAddress;

                                      function iso8601ToRippleTime

                                      iso8601ToRippleTime: (iso8601: string) => number;

                                        function isValidSecret

                                        isValidSecret: (secret: string) => boolean;

                                          function removeUndefined

                                          removeUndefined: <T extends object>(obj: T) => T;

                                            function rippleTimeToISO8601

                                            rippleTimeToISO8601: (rippleTime: number) => string;

                                              function signPaymentChannelClaim

                                              signPaymentChannelClaim: (
                                              channel: string,
                                              amount: string,
                                              privateKey: string
                                              ) => string;

                                                function toRippledAmount

                                                toRippledAmount: (amount: RippledAmount) => RippledAmount;

                                                  function verifyPaymentChannelClaim

                                                  verifyPaymentChannelClaim: (
                                                  channel: string,
                                                  amount: string,
                                                  signature: string,
                                                  publicKey: string
                                                  ) => boolean;

                                                    function xrpToDrops

                                                    xrpToDrops: (xrp: any) => string;

                                                      Classes

                                                      class RippleAPI

                                                      class RippleAPI extends EventEmitter {}

                                                        constructor

                                                        constructor(options?: APIOptions);

                                                          property accountSetFlags

                                                          static accountSetFlags: {
                                                          requireDestinationTag: number;
                                                          requireAuthorization: number;
                                                          depositAuth: number;
                                                          disallowIncomingXRP: number;
                                                          disableMasterKey: number;
                                                          enableTransactionIDTracking: number;
                                                          noFreeze: number;
                                                          globalFreeze: number;
                                                          defaultRipple: number;
                                                          };

                                                            property classicAddressToXAddress

                                                            static classicAddressToXAddress: any;

                                                              property combine

                                                              combine: (signedTransactions: string[]) => object;

                                                                property computeAccountLedgerObjectID

                                                                static computeAccountLedgerObjectID: (address: string) => string;

                                                                  property computeBinaryTransactionHash

                                                                  static computeBinaryTransactionHash: (txBlobHex: string) => string;

                                                                    property computeBinaryTransactionSigningHash

                                                                    static computeBinaryTransactionSigningHash: (txBlobHex: string) => string;

                                                                      property computeEscrowHash

                                                                      static computeEscrowHash: (address: any, sequence: any) => string;

                                                                        property computeLedgerHash

                                                                        static computeLedgerHash: (
                                                                        ledger: any,
                                                                        options?: ComputeLedgerHeaderHashOptions
                                                                        ) => string;

                                                                          property computeLedgerHash

                                                                          computeLedgerHash: (
                                                                          ledger: any,
                                                                          options?: ComputeLedgerHeaderHashOptions
                                                                          ) => string;

                                                                            property computeOrderID

                                                                            static computeOrderID: (address: string, sequence: number) => string;

                                                                              property computePaymentChannelHash

                                                                              static computePaymentChannelHash: (
                                                                              address: any,
                                                                              dstAddress: any,
                                                                              sequence: any
                                                                              ) => string;

                                                                                property computeSignerListLedgerObjectID

                                                                                static computeSignerListLedgerObjectID: (address: string) => string;

                                                                                  property computeStateTreeHash

                                                                                  static computeStateTreeHash: (entries: any[]) => string;

                                                                                    property computeTransactionHash

                                                                                    static computeTransactionHash: (txJSON: any) => string;

                                                                                      property computeTransactionTreeHash

                                                                                      static computeTransactionTreeHash: (transactions: any[]) => string;

                                                                                        property computeTrustlineHash

                                                                                        static computeTrustlineHash: (
                                                                                        address1: string,
                                                                                        address2: string,
                                                                                        currency: string
                                                                                        ) => string;

                                                                                          property connect

                                                                                          connect: (this: RippleAPI) => Promise<void>;

                                                                                            property connection

                                                                                            connection: Connection;

                                                                                              property decodeAccountID

                                                                                              static decodeAccountID: any;

                                                                                                property decodeAccountPublic

                                                                                                static decodeAccountPublic: any;

                                                                                                  property decodeNodePublic

                                                                                                  static decodeNodePublic: any;

                                                                                                    property decodeSeed

                                                                                                    static decodeSeed: any;

                                                                                                      property decodeXAddress

                                                                                                      static decodeXAddress: any;

                                                                                                        property deriveAddress

                                                                                                        deriveAddress: (publicKey: any) => string;

                                                                                                          property deriveClassicAddress

                                                                                                          static deriveClassicAddress: (publicKey: any) => string;

                                                                                                            property deriveKeypair

                                                                                                            deriveKeypair: (
                                                                                                            seed: string,
                                                                                                            options?: object
                                                                                                            ) => { publicKey: string; privateKey: string };

                                                                                                              property deriveXAddress

                                                                                                              static deriveXAddress: (options: {
                                                                                                              publicKey: string;
                                                                                                              tag: number | false;
                                                                                                              test: boolean;
                                                                                                              }) => string;

                                                                                                                property disconnect

                                                                                                                disconnect: (this: RippleAPI) => Promise<void>;

                                                                                                                  property dropsToXrp

                                                                                                                  dropsToXrp: (drops: any) => string;

                                                                                                                    property encodeAccountID

                                                                                                                    static encodeAccountID: any;

                                                                                                                      property encodeAccountPublic

                                                                                                                      static encodeAccountPublic: any;

                                                                                                                        property encodeNodePublic

                                                                                                                        static encodeNodePublic: any;

                                                                                                                          property encodeSeed

                                                                                                                          static encodeSeed: any;

                                                                                                                            property encodeXAddress

                                                                                                                            static encodeXAddress: any;

                                                                                                                              property errors

                                                                                                                              errors: typeof errors;

                                                                                                                                property formatBidsAndAsks

                                                                                                                                static formatBidsAndAsks: (
                                                                                                                                orderbook: OrderbookInfo,
                                                                                                                                offers: BookOffer[]
                                                                                                                                ) => { bids: FormattedOrderbookOrder[]; asks: FormattedOrderbookOrder[] };

                                                                                                                                  property generateAddress

                                                                                                                                  generateAddress: (
                                                                                                                                  options?: import('./offline/generate-address').GenerateAddressOptions
                                                                                                                                  ) => import('./offline/generate-address').GeneratedAddress;

                                                                                                                                    property generateFaucetWallet

                                                                                                                                    generateFaucetWallet: (
                                                                                                                                    this: RippleAPI,
                                                                                                                                    address?: string
                                                                                                                                    ) => Promise<void | FaucetWallet>;

                                                                                                                                      property generateXAddress

                                                                                                                                      generateXAddress: (options?: GenerateAddressOptions) => GeneratedAddress;

                                                                                                                                        property getAccountInfo

                                                                                                                                        getAccountInfo: (
                                                                                                                                        this: RippleAPI,
                                                                                                                                        address: string,
                                                                                                                                        options?: GetAccountInfoOptions
                                                                                                                                        ) => Promise<FormattedGetAccountInfoResponse>;

                                                                                                                                          property getAccountObjects

                                                                                                                                          getAccountObjects: (
                                                                                                                                          this: RippleAPI,
                                                                                                                                          address: string,
                                                                                                                                          options?: GetAccountObjectsOptions
                                                                                                                                          ) => Promise<AccountObjectsResponse>;

                                                                                                                                            property getBalances

                                                                                                                                            getBalances: (
                                                                                                                                            this: RippleAPI,
                                                                                                                                            address: string,
                                                                                                                                            options?: GetTrustlinesOptions
                                                                                                                                            ) => Promise<GetBalances>;

                                                                                                                                              property getBalanceSheet

                                                                                                                                              getBalanceSheet: (
                                                                                                                                              this: RippleAPI,
                                                                                                                                              address: string,
                                                                                                                                              options?: BalanceSheetOptions
                                                                                                                                              ) => Promise<GetBalanceSheet>;

                                                                                                                                                property getFee

                                                                                                                                                getFee: (this: RippleAPI, cushion?: number) => Promise<string>;

                                                                                                                                                  property getLedger

                                                                                                                                                  getLedger: (
                                                                                                                                                  this: RippleAPI,
                                                                                                                                                  options?: GetLedgerOptions
                                                                                                                                                  ) => Promise<FormattedLedger>;

                                                                                                                                                    property getLedgerVersion

                                                                                                                                                    getLedgerVersion: (this: RippleAPI) => Promise<number>;

                                                                                                                                                      property getOrderbook

                                                                                                                                                      getOrderbook: (
                                                                                                                                                      this: RippleAPI,
                                                                                                                                                      address: string,
                                                                                                                                                      orderbook: OrderbookInfo,
                                                                                                                                                      options?: GetOrderbookOptions
                                                                                                                                                      ) => Promise<FormattedOrderbook>;

                                                                                                                                                        property getOrders

                                                                                                                                                        getOrders: (
                                                                                                                                                        this: RippleAPI,
                                                                                                                                                        address: string,
                                                                                                                                                        options?: GetOrdersOptions
                                                                                                                                                        ) => Promise<FormattedAccountOrder[]>;

                                                                                                                                                          property getPaths

                                                                                                                                                          getPaths: (this: RippleAPI, pathfind: PathFind) => Promise<GetPaths>;

                                                                                                                                                            property getPaymentChannel

                                                                                                                                                            getPaymentChannel: (
                                                                                                                                                            this: RippleAPI,
                                                                                                                                                            id: string
                                                                                                                                                            ) => Promise<FormattedPaymentChannel>;

                                                                                                                                                              property getServerInfo

                                                                                                                                                              getServerInfo: (
                                                                                                                                                              this: RippleAPI
                                                                                                                                                              ) => Promise<ledgerUtils.common.serverInfo.GetServerInfoResponse>;

                                                                                                                                                                property getSettings

                                                                                                                                                                getSettings: (
                                                                                                                                                                this: RippleAPI,
                                                                                                                                                                address: string,
                                                                                                                                                                options?: SettingsOptions
                                                                                                                                                                ) => Promise<FormattedSettings>;

                                                                                                                                                                  property getTransaction

                                                                                                                                                                  getTransaction: (
                                                                                                                                                                  this: RippleAPI,
                                                                                                                                                                  id: string,
                                                                                                                                                                  options?: TransactionOptions
                                                                                                                                                                  ) => Promise<FormattedTransactionType>;

                                                                                                                                                                    property getTransactions

                                                                                                                                                                    getTransactions: (
                                                                                                                                                                    this: RippleAPI,
                                                                                                                                                                    address: string,
                                                                                                                                                                    options?: TransactionsOptions
                                                                                                                                                                    ) => Promise<GetTransactionsResponse>;

                                                                                                                                                                      property getTrustlines

                                                                                                                                                                      getTrustlines: (
                                                                                                                                                                      this: RippleAPI,
                                                                                                                                                                      address: string,
                                                                                                                                                                      options?: GetTrustlinesOptions
                                                                                                                                                                      ) => Promise<FormattedTrustline[]>;

                                                                                                                                                                        property isConnected

                                                                                                                                                                        isConnected: (this: RippleAPI) => boolean;

                                                                                                                                                                          property iso8601ToRippleTime

                                                                                                                                                                          iso8601ToRippleTime: (iso8601: string) => number;

                                                                                                                                                                            property isValidAddress

                                                                                                                                                                            isValidAddress: (address: string) => boolean;

                                                                                                                                                                              property isValidClassicAddress

                                                                                                                                                                              static isValidClassicAddress: any;

                                                                                                                                                                                property isValidSecret

                                                                                                                                                                                isValidSecret: (secret: string) => boolean;

                                                                                                                                                                                  property isValidXAddress

                                                                                                                                                                                  static isValidXAddress: any;

                                                                                                                                                                                    property parseAccountFlags

                                                                                                                                                                                    parseAccountFlags: (
                                                                                                                                                                                    value: number,
                                                                                                                                                                                    options?: { excludeFalse?: boolean }
                                                                                                                                                                                    ) => ledgerUtils.common.constants.Settings;

                                                                                                                                                                                      property prepareCheckCancel

                                                                                                                                                                                      prepareCheckCancel: (
                                                                                                                                                                                      this: RippleAPI,
                                                                                                                                                                                      address: string,
                                                                                                                                                                                      checkCancel: CheckCancelParameters,
                                                                                                                                                                                      instructions?: Instructions
                                                                                                                                                                                      ) => Promise<Prepare>;

                                                                                                                                                                                        property prepareCheckCash

                                                                                                                                                                                        prepareCheckCash: (
                                                                                                                                                                                        this: RippleAPI,
                                                                                                                                                                                        address: string,
                                                                                                                                                                                        checkCash: CheckCashParameters,
                                                                                                                                                                                        instructions?: Instructions
                                                                                                                                                                                        ) => Promise<Prepare>;

                                                                                                                                                                                          property prepareCheckCreate

                                                                                                                                                                                          prepareCheckCreate: (
                                                                                                                                                                                          this: RippleAPI,
                                                                                                                                                                                          address: string,
                                                                                                                                                                                          checkCreate: CheckCreateParameters,
                                                                                                                                                                                          instructions?: Instructions
                                                                                                                                                                                          ) => Promise<Prepare>;

                                                                                                                                                                                            property prepareEscrowCancellation

                                                                                                                                                                                            prepareEscrowCancellation: (
                                                                                                                                                                                            this: RippleAPI,
                                                                                                                                                                                            address: string,
                                                                                                                                                                                            escrowCancellation: EscrowCancellation,
                                                                                                                                                                                            instructions?: Instructions
                                                                                                                                                                                            ) => Promise<Prepare>;

                                                                                                                                                                                              property prepareEscrowCreation

                                                                                                                                                                                              prepareEscrowCreation: (
                                                                                                                                                                                              this: RippleAPI,
                                                                                                                                                                                              address: string,
                                                                                                                                                                                              escrowCreation: EscrowCreation,
                                                                                                                                                                                              instructions?: Instructions
                                                                                                                                                                                              ) => Promise<Prepare>;

                                                                                                                                                                                                property prepareEscrowExecution

                                                                                                                                                                                                prepareEscrowExecution: (
                                                                                                                                                                                                this: RippleAPI,
                                                                                                                                                                                                address: string,
                                                                                                                                                                                                escrowExecution: EscrowExecution,
                                                                                                                                                                                                instructions?: Instructions
                                                                                                                                                                                                ) => Promise<Prepare>;

                                                                                                                                                                                                  property prepareOrder

                                                                                                                                                                                                  prepareOrder: (
                                                                                                                                                                                                  this: RippleAPI,
                                                                                                                                                                                                  address: string,
                                                                                                                                                                                                  order: FormattedOrderSpecification,
                                                                                                                                                                                                  instructions?: Instructions
                                                                                                                                                                                                  ) => Promise<Prepare>;

                                                                                                                                                                                                    property prepareOrderCancellation

                                                                                                                                                                                                    prepareOrderCancellation: (
                                                                                                                                                                                                    this: RippleAPI,
                                                                                                                                                                                                    address: string,
                                                                                                                                                                                                    orderCancellation: object,
                                                                                                                                                                                                    instructions?: Instructions
                                                                                                                                                                                                    ) => Promise<Prepare>;

                                                                                                                                                                                                      property preparePayment

                                                                                                                                                                                                      preparePayment: (
                                                                                                                                                                                                      this: RippleAPI,
                                                                                                                                                                                                      address: string,
                                                                                                                                                                                                      payment: Payment,
                                                                                                                                                                                                      instructions?: Instructions
                                                                                                                                                                                                      ) => Promise<Prepare>;

                                                                                                                                                                                                        property preparePaymentChannelClaim

                                                                                                                                                                                                        preparePaymentChannelClaim: (
                                                                                                                                                                                                        this: RippleAPI,
                                                                                                                                                                                                        address: string,
                                                                                                                                                                                                        paymentChannelClaim: PaymentChannelClaim,
                                                                                                                                                                                                        instructions?: Instructions
                                                                                                                                                                                                        ) => Promise<Prepare>;

                                                                                                                                                                                                          property preparePaymentChannelCreate

                                                                                                                                                                                                          preparePaymentChannelCreate: (
                                                                                                                                                                                                          this: RippleAPI,
                                                                                                                                                                                                          address: string,
                                                                                                                                                                                                          paymentChannelCreate: PaymentChannelCreate,
                                                                                                                                                                                                          instructions?: Instructions
                                                                                                                                                                                                          ) => Promise<Prepare>;

                                                                                                                                                                                                            property preparePaymentChannelFund

                                                                                                                                                                                                            preparePaymentChannelFund: (
                                                                                                                                                                                                            this: RippleAPI,
                                                                                                                                                                                                            address: string,
                                                                                                                                                                                                            paymentChannelFund: PaymentChannelFund,
                                                                                                                                                                                                            instructions?: Instructions
                                                                                                                                                                                                            ) => Promise<Prepare>;

                                                                                                                                                                                                              property prepareSettings

                                                                                                                                                                                                              prepareSettings: (
                                                                                                                                                                                                              this: RippleAPI,
                                                                                                                                                                                                              address: string,
                                                                                                                                                                                                              settings: FormattedSettings,
                                                                                                                                                                                                              instructions?: Instructions
                                                                                                                                                                                                              ) => Promise<Prepare>;

                                                                                                                                                                                                                property prepareTicketCreate

                                                                                                                                                                                                                prepareTicketCreate: (
                                                                                                                                                                                                                this: RippleAPI,
                                                                                                                                                                                                                address: string,
                                                                                                                                                                                                                ticketCount: number,
                                                                                                                                                                                                                instructions?: Instructions
                                                                                                                                                                                                                ) => Promise<Prepare>;

                                                                                                                                                                                                                  property prepareTrustline

                                                                                                                                                                                                                  prepareTrustline: (
                                                                                                                                                                                                                  this: RippleAPI,
                                                                                                                                                                                                                  address: string,
                                                                                                                                                                                                                  trustline: FormattedTrustlineSpecification,
                                                                                                                                                                                                                  instructions?: Instructions
                                                                                                                                                                                                                  ) => Promise<Prepare>;

                                                                                                                                                                                                                    property renameCounterpartyToIssuer

                                                                                                                                                                                                                    static renameCounterpartyToIssuer: <T>(
                                                                                                                                                                                                                    obj: T & { counterparty?: string; issuer?: string }
                                                                                                                                                                                                                    ) => T & { issuer?: string };

                                                                                                                                                                                                                      property rippleTimeToISO8601

                                                                                                                                                                                                                      rippleTimeToISO8601: (rippleTime: number) => string;

                                                                                                                                                                                                                        property sign

                                                                                                                                                                                                                        sign: (
                                                                                                                                                                                                                        this: RippleAPI,
                                                                                                                                                                                                                        txJSON: string,
                                                                                                                                                                                                                        secret?: any,
                                                                                                                                                                                                                        options?: SignOptions,
                                                                                                                                                                                                                        keypair?: KeyPair
                                                                                                                                                                                                                        ) => { signedTransaction: string; id: string };

                                                                                                                                                                                                                          property signPaymentChannelClaim

                                                                                                                                                                                                                          signPaymentChannelClaim: (
                                                                                                                                                                                                                          channel: string,
                                                                                                                                                                                                                          amount: string,
                                                                                                                                                                                                                          privateKey: string
                                                                                                                                                                                                                          ) => string;

                                                                                                                                                                                                                            property submit

                                                                                                                                                                                                                            submit: (
                                                                                                                                                                                                                            this: RippleAPI,
                                                                                                                                                                                                                            signedTransaction: string,
                                                                                                                                                                                                                            failHard?: boolean
                                                                                                                                                                                                                            ) => Promise<FormattedSubmitResponse>;

                                                                                                                                                                                                                              property txFlags

                                                                                                                                                                                                                              txFlags: {
                                                                                                                                                                                                                              Universal: { FullyCanonicalSig: number };
                                                                                                                                                                                                                              AccountSet: {
                                                                                                                                                                                                                              RequireDestTag: number;
                                                                                                                                                                                                                              OptionalDestTag: number;
                                                                                                                                                                                                                              RequireAuth: number;
                                                                                                                                                                                                                              OptionalAuth: number;
                                                                                                                                                                                                                              DisallowXRP: number;
                                                                                                                                                                                                                              AllowXRP: number;
                                                                                                                                                                                                                              };
                                                                                                                                                                                                                              TrustSet: {
                                                                                                                                                                                                                              SetAuth: number;
                                                                                                                                                                                                                              NoRipple: number;
                                                                                                                                                                                                                              SetNoRipple: number;
                                                                                                                                                                                                                              ClearNoRipple: number;
                                                                                                                                                                                                                              SetFreeze: number;
                                                                                                                                                                                                                              ClearFreeze: number;
                                                                                                                                                                                                                              };
                                                                                                                                                                                                                              OfferCreate: {
                                                                                                                                                                                                                              Passive: number;
                                                                                                                                                                                                                              ImmediateOrCancel: number;
                                                                                                                                                                                                                              FillOrKill: number;
                                                                                                                                                                                                                              Sell: number;
                                                                                                                                                                                                                              };
                                                                                                                                                                                                                              Payment: {
                                                                                                                                                                                                                              NoRippleDirect: number;
                                                                                                                                                                                                                              PartialPayment: number;
                                                                                                                                                                                                                              LimitQuality: number;
                                                                                                                                                                                                                              };
                                                                                                                                                                                                                              PaymentChannelClaim: { Renew: number; Close: number };
                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                property verifyPaymentChannelClaim

                                                                                                                                                                                                                                verifyPaymentChannelClaim: (
                                                                                                                                                                                                                                channel: string,
                                                                                                                                                                                                                                amount: string,
                                                                                                                                                                                                                                signature: string,
                                                                                                                                                                                                                                publicKey: string
                                                                                                                                                                                                                                ) => boolean;

                                                                                                                                                                                                                                  property xAddressToClassicAddress

                                                                                                                                                                                                                                  static xAddressToClassicAddress: any;

                                                                                                                                                                                                                                    property xrpToDrops

                                                                                                                                                                                                                                    xrpToDrops: (xrp: any) => string;

                                                                                                                                                                                                                                      method convertStringToHex

                                                                                                                                                                                                                                      convertStringToHex: (string: string) => string;

                                                                                                                                                                                                                                        method hasNextPage

                                                                                                                                                                                                                                        hasNextPage: <T extends { marker?: string }>(currentResponse: T) => boolean;

                                                                                                                                                                                                                                          method prepareTransaction

                                                                                                                                                                                                                                          prepareTransaction: (
                                                                                                                                                                                                                                          txJSON: TransactionJSON,
                                                                                                                                                                                                                                          instructions?: Instructions
                                                                                                                                                                                                                                          ) => Promise<Prepare>;

                                                                                                                                                                                                                                            method request

                                                                                                                                                                                                                                            request: {
                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                            command: 'account_info',
                                                                                                                                                                                                                                            params: AccountInfoRequest
                                                                                                                                                                                                                                            ): Promise<AccountInfoResponse>;
                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                            command: 'account_lines',
                                                                                                                                                                                                                                            params: AccountLinesRequest
                                                                                                                                                                                                                                            ): Promise<AccountLinesResponse>;
                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                            command: 'account_objects',
                                                                                                                                                                                                                                            params: AccountObjectsRequest
                                                                                                                                                                                                                                            ): Promise<AccountObjectsResponse>;
                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                            command: 'account_offers',
                                                                                                                                                                                                                                            params: AccountOffersRequest
                                                                                                                                                                                                                                            ): Promise<AccountOffersResponse>;
                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                            command: 'book_offers',
                                                                                                                                                                                                                                            params: BookOffersRequest
                                                                                                                                                                                                                                            ): Promise<BookOffersResponse>;
                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                            command: 'gateway_balances',
                                                                                                                                                                                                                                            params: GatewayBalancesRequest
                                                                                                                                                                                                                                            ): Promise<GatewayBalancesResponse>;
                                                                                                                                                                                                                                            (command: 'ledger', params: LedgerRequest): Promise<LedgerResponse>;
                                                                                                                                                                                                                                            (command: 'ledger_data', params?: LedgerDataRequest): Promise<LedgerData>;
                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                            command: 'ledger_entry',
                                                                                                                                                                                                                                            params: LedgerEntryRequest
                                                                                                                                                                                                                                            ): Promise<LedgerEntryResponse>;
                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                            command: 'server_info',
                                                                                                                                                                                                                                            params?: ServerInfoRequest
                                                                                                                                                                                                                                            ): Promise<ServerInfoResponse>;
                                                                                                                                                                                                                                            (command: string, params: any): Promise<any>;
                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                              method requestNextPage

                                                                                                                                                                                                                                              requestNextPage: <T extends { marker?: string }>(
                                                                                                                                                                                                                                              command: string,
                                                                                                                                                                                                                                              params: object,
                                                                                                                                                                                                                                              currentResponse: T
                                                                                                                                                                                                                                              ) => Promise<T>;

                                                                                                                                                                                                                                                class RippleAPIBroadcast

                                                                                                                                                                                                                                                class RippleAPIBroadcast extends RippleAPI {}

                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                  constructor(servers: any, options?: APIOptions);

                                                                                                                                                                                                                                                    property ledgerVersion

                                                                                                                                                                                                                                                    ledgerVersion: number;

                                                                                                                                                                                                                                                      method getMethodNames

                                                                                                                                                                                                                                                      getMethodNames: () => string[];

                                                                                                                                                                                                                                                        method onLedgerEvent

                                                                                                                                                                                                                                                        onLedgerEvent: (ledger: any) => void;

                                                                                                                                                                                                                                                          Interfaces

                                                                                                                                                                                                                                                          interface AccountInfoRequest

                                                                                                                                                                                                                                                          interface AccountInfoRequest {}

                                                                                                                                                                                                                                                            property account

                                                                                                                                                                                                                                                            account: string;

                                                                                                                                                                                                                                                              property ledger_hash

                                                                                                                                                                                                                                                              ledger_hash?: string;

                                                                                                                                                                                                                                                                property ledger_index

                                                                                                                                                                                                                                                                ledger_index?: number | ('validated' | 'closed' | 'current');

                                                                                                                                                                                                                                                                  property queue

                                                                                                                                                                                                                                                                  queue?: boolean;

                                                                                                                                                                                                                                                                    property signer_lists

                                                                                                                                                                                                                                                                    signer_lists?: boolean;

                                                                                                                                                                                                                                                                      property strict

                                                                                                                                                                                                                                                                      strict?: boolean;

                                                                                                                                                                                                                                                                        interface AccountInfoResponse

                                                                                                                                                                                                                                                                        interface AccountInfoResponse {}

                                                                                                                                                                                                                                                                          property account_data

                                                                                                                                                                                                                                                                          account_data: AccountRootLedgerEntry;

                                                                                                                                                                                                                                                                            property ledger_current_index

                                                                                                                                                                                                                                                                            ledger_current_index?: number;

                                                                                                                                                                                                                                                                              property ledger_index

                                                                                                                                                                                                                                                                              ledger_index?: number;

                                                                                                                                                                                                                                                                                property queue_data

                                                                                                                                                                                                                                                                                queue_data?: QueueData;

                                                                                                                                                                                                                                                                                  property signer_lists

                                                                                                                                                                                                                                                                                  signer_lists?: SignerListLedgerEntry[];

                                                                                                                                                                                                                                                                                    property validated

                                                                                                                                                                                                                                                                                    validated?: boolean;

                                                                                                                                                                                                                                                                                      interface AccountLinesRequest

                                                                                                                                                                                                                                                                                      interface AccountLinesRequest {}

                                                                                                                                                                                                                                                                                        property account

                                                                                                                                                                                                                                                                                        account: string;

                                                                                                                                                                                                                                                                                          property ledger_hash

                                                                                                                                                                                                                                                                                          ledger_hash?: string;

                                                                                                                                                                                                                                                                                            property ledger_index

                                                                                                                                                                                                                                                                                            ledger_index?: number | ('validated' | 'closed' | 'current');

                                                                                                                                                                                                                                                                                              property limit

                                                                                                                                                                                                                                                                                              limit?: number;

                                                                                                                                                                                                                                                                                                property marker

                                                                                                                                                                                                                                                                                                marker?: any;

                                                                                                                                                                                                                                                                                                  property peer

                                                                                                                                                                                                                                                                                                  peer?: string;

                                                                                                                                                                                                                                                                                                    interface AccountLinesResponse

                                                                                                                                                                                                                                                                                                    interface AccountLinesResponse {}

                                                                                                                                                                                                                                                                                                      property account

                                                                                                                                                                                                                                                                                                      account: string;

                                                                                                                                                                                                                                                                                                        property ledger_current_index

                                                                                                                                                                                                                                                                                                        ledger_current_index?: number;

                                                                                                                                                                                                                                                                                                          property ledger_hash

                                                                                                                                                                                                                                                                                                          ledger_hash?: string;

                                                                                                                                                                                                                                                                                                            property ledger_index

                                                                                                                                                                                                                                                                                                            ledger_index?: number;

                                                                                                                                                                                                                                                                                                              property lines

                                                                                                                                                                                                                                                                                                              lines: Trustline[];

                                                                                                                                                                                                                                                                                                                property marker

                                                                                                                                                                                                                                                                                                                marker?: any;

                                                                                                                                                                                                                                                                                                                  interface AccountObjectsRequest

                                                                                                                                                                                                                                                                                                                  interface AccountObjectsRequest {}

                                                                                                                                                                                                                                                                                                                    property account

                                                                                                                                                                                                                                                                                                                    account: string;

                                                                                                                                                                                                                                                                                                                      property ledger_hash

                                                                                                                                                                                                                                                                                                                      ledger_hash?: string;

                                                                                                                                                                                                                                                                                                                        property ledger_index

                                                                                                                                                                                                                                                                                                                        ledger_index?: number | ('validated' | 'closed' | 'current');

                                                                                                                                                                                                                                                                                                                          property limit

                                                                                                                                                                                                                                                                                                                          limit?: number;

                                                                                                                                                                                                                                                                                                                            property marker

                                                                                                                                                                                                                                                                                                                            marker?: string;

                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                              type?:
                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                              | (
                                                                                                                                                                                                                                                                                                                              | 'check'
                                                                                                                                                                                                                                                                                                                              | 'escrow'
                                                                                                                                                                                                                                                                                                                              | 'offer'
                                                                                                                                                                                                                                                                                                                              | 'payment_channel'
                                                                                                                                                                                                                                                                                                                              | 'signer_list'
                                                                                                                                                                                                                                                                                                                              | 'state'
                                                                                                                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                                                                                                                interface AccountObjectsResponse

                                                                                                                                                                                                                                                                                                                                interface AccountObjectsResponse {}

                                                                                                                                                                                                                                                                                                                                  property account

                                                                                                                                                                                                                                                                                                                                  account: string;

                                                                                                                                                                                                                                                                                                                                    property account_objects

                                                                                                                                                                                                                                                                                                                                    account_objects: Array<
                                                                                                                                                                                                                                                                                                                                    | CheckLedgerEntry
                                                                                                                                                                                                                                                                                                                                    | RippleStateLedgerEntry
                                                                                                                                                                                                                                                                                                                                    | OfferLedgerEntry
                                                                                                                                                                                                                                                                                                                                    | SignerListLedgerEntry
                                                                                                                                                                                                                                                                                                                                    | EscrowLedgerEntry
                                                                                                                                                                                                                                                                                                                                    | PayChannelLedgerEntry
                                                                                                                                                                                                                                                                                                                                    | DepositPreauthLedgerEntry
                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                      property ledger_current_index

                                                                                                                                                                                                                                                                                                                                      ledger_current_index?: number;

                                                                                                                                                                                                                                                                                                                                        property ledger_hash

                                                                                                                                                                                                                                                                                                                                        ledger_hash?: string;

                                                                                                                                                                                                                                                                                                                                          property ledger_index

                                                                                                                                                                                                                                                                                                                                          ledger_index?: number;

                                                                                                                                                                                                                                                                                                                                            property limit

                                                                                                                                                                                                                                                                                                                                            limit?: number;

                                                                                                                                                                                                                                                                                                                                              property marker

                                                                                                                                                                                                                                                                                                                                              marker?: string;

                                                                                                                                                                                                                                                                                                                                                property validated

                                                                                                                                                                                                                                                                                                                                                validated?: boolean;

                                                                                                                                                                                                                                                                                                                                                  interface AccountOffersRequest

                                                                                                                                                                                                                                                                                                                                                  interface AccountOffersRequest {}

                                                                                                                                                                                                                                                                                                                                                    property account

                                                                                                                                                                                                                                                                                                                                                    account: string;

                                                                                                                                                                                                                                                                                                                                                      property ledger_hash

                                                                                                                                                                                                                                                                                                                                                      ledger_hash?: string;

                                                                                                                                                                                                                                                                                                                                                        property ledger_index

                                                                                                                                                                                                                                                                                                                                                        ledger_index?: number | ('validated' | 'closed' | 'current');

                                                                                                                                                                                                                                                                                                                                                          property limit

                                                                                                                                                                                                                                                                                                                                                          limit?: number;

                                                                                                                                                                                                                                                                                                                                                            property marker

                                                                                                                                                                                                                                                                                                                                                            marker?: any;

                                                                                                                                                                                                                                                                                                                                                              interface AccountOffersResponse

                                                                                                                                                                                                                                                                                                                                                              interface AccountOffersResponse {}

                                                                                                                                                                                                                                                                                                                                                                property account

                                                                                                                                                                                                                                                                                                                                                                account: string;

                                                                                                                                                                                                                                                                                                                                                                  property ledger_current_index

                                                                                                                                                                                                                                                                                                                                                                  ledger_current_index?: number;

                                                                                                                                                                                                                                                                                                                                                                    property ledger_hash

                                                                                                                                                                                                                                                                                                                                                                    ledger_hash?: string;

                                                                                                                                                                                                                                                                                                                                                                      property ledger_index

                                                                                                                                                                                                                                                                                                                                                                      ledger_index?: number;

                                                                                                                                                                                                                                                                                                                                                                        property marker

                                                                                                                                                                                                                                                                                                                                                                        marker?: any;

                                                                                                                                                                                                                                                                                                                                                                          property offers

                                                                                                                                                                                                                                                                                                                                                                          offers?: AccountOffer[];

                                                                                                                                                                                                                                                                                                                                                                            interface APIOptions

                                                                                                                                                                                                                                                                                                                                                                            interface APIOptions extends ConnectionUserOptions {}

                                                                                                                                                                                                                                                                                                                                                                              property feeCushion

                                                                                                                                                                                                                                                                                                                                                                              feeCushion?: number;

                                                                                                                                                                                                                                                                                                                                                                                property maxFeeXRP

                                                                                                                                                                                                                                                                                                                                                                                maxFeeXRP?: string;

                                                                                                                                                                                                                                                                                                                                                                                  property proxy

                                                                                                                                                                                                                                                                                                                                                                                  proxy?: string;

                                                                                                                                                                                                                                                                                                                                                                                    property server

                                                                                                                                                                                                                                                                                                                                                                                    server?: string;

                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;

                                                                                                                                                                                                                                                                                                                                                                                        interface BookOffersRequest

                                                                                                                                                                                                                                                                                                                                                                                        interface BookOffersRequest {}

                                                                                                                                                                                                                                                                                                                                                                                          property ledger_hash

                                                                                                                                                                                                                                                                                                                                                                                          ledger_hash?: string;

                                                                                                                                                                                                                                                                                                                                                                                            property ledger_index

                                                                                                                                                                                                                                                                                                                                                                                            ledger_index?: number | ('validated' | 'closed' | 'current');

                                                                                                                                                                                                                                                                                                                                                                                              property limit

                                                                                                                                                                                                                                                                                                                                                                                              limit?: number;

                                                                                                                                                                                                                                                                                                                                                                                                property marker

                                                                                                                                                                                                                                                                                                                                                                                                marker?: any;

                                                                                                                                                                                                                                                                                                                                                                                                  property taker

                                                                                                                                                                                                                                                                                                                                                                                                  taker?: string;

                                                                                                                                                                                                                                                                                                                                                                                                    property taker_gets

                                                                                                                                                                                                                                                                                                                                                                                                    taker_gets: TakerRequestAmount;

                                                                                                                                                                                                                                                                                                                                                                                                      property taker_pays

                                                                                                                                                                                                                                                                                                                                                                                                      taker_pays: TakerRequestAmount;

                                                                                                                                                                                                                                                                                                                                                                                                        interface BookOffersResponse

                                                                                                                                                                                                                                                                                                                                                                                                        interface BookOffersResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                          property ledger_current_index

                                                                                                                                                                                                                                                                                                                                                                                                          ledger_current_index?: number;

                                                                                                                                                                                                                                                                                                                                                                                                            property ledger_hash

                                                                                                                                                                                                                                                                                                                                                                                                            ledger_hash?: string;

                                                                                                                                                                                                                                                                                                                                                                                                              property ledger_index

                                                                                                                                                                                                                                                                                                                                                                                                              ledger_index?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                property marker

                                                                                                                                                                                                                                                                                                                                                                                                                marker?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                  property offers

                                                                                                                                                                                                                                                                                                                                                                                                                  offers: BookOffer[];

                                                                                                                                                                                                                                                                                                                                                                                                                    interface GatewayBalancesRequest

                                                                                                                                                                                                                                                                                                                                                                                                                    interface GatewayBalancesRequest {}

                                                                                                                                                                                                                                                                                                                                                                                                                      property account

                                                                                                                                                                                                                                                                                                                                                                                                                      account: string;

                                                                                                                                                                                                                                                                                                                                                                                                                        property hotwallet

                                                                                                                                                                                                                                                                                                                                                                                                                        hotwallet: string | Array<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                          property ledger_hash

                                                                                                                                                                                                                                                                                                                                                                                                                          ledger_hash?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                            property ledger_index

                                                                                                                                                                                                                                                                                                                                                                                                                            ledger_index?: number | ('validated' | 'closed' | 'current');

                                                                                                                                                                                                                                                                                                                                                                                                                              property strict

                                                                                                                                                                                                                                                                                                                                                                                                                              strict?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                interface GatewayBalancesResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                interface GatewayBalancesResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                  property account

                                                                                                                                                                                                                                                                                                                                                                                                                                  account: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property assets

                                                                                                                                                                                                                                                                                                                                                                                                                                    assets?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                    [address: string]: Amount[];
                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                      property balances

                                                                                                                                                                                                                                                                                                                                                                                                                                      balances?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                      [address: string]: Amount[];
                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                        property ledger_current_index

                                                                                                                                                                                                                                                                                                                                                                                                                                        ledger_current_index?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property ledger_hash

                                                                                                                                                                                                                                                                                                                                                                                                                                          ledger_hash?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property ledger_index

                                                                                                                                                                                                                                                                                                                                                                                                                                            ledger_index?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property obligations

                                                                                                                                                                                                                                                                                                                                                                                                                                              obligations?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                              [currency: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Ledger

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Ledger {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property account_hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                  account_hash: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property accountState

                                                                                                                                                                                                                                                                                                                                                                                                                                                    accountState?: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property close_flags

                                                                                                                                                                                                                                                                                                                                                                                                                                                      close_flags?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property close_time

                                                                                                                                                                                                                                                                                                                                                                                                                                                        close_time: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property close_time_human

                                                                                                                                                                                                                                                                                                                                                                                                                                                          close_time_human: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property close_time_resolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                            close_time_resolution: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property closed

                                                                                                                                                                                                                                                                                                                                                                                                                                                              closed: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ledger_hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                ledger_hash: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ledger_index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ledger_index: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property parent_close_time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parent_close_time?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property parent_hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      parent_hash: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property total_coins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        total_coins: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property transaction_hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          transaction_hash: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property transactions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            transactions: string[] | object[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property validated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              validated?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface LedgerDataRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface LedgerDataRequest {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property binary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  binary?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ledger_hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ledger_hash?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ledger_index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ledger_index?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property limit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          limit?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property marker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            marker?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LedgerEntryRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LedgerEntryRequest {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property account_root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                account_root?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property binary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  binary?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property directory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    directory?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sub_index?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dir_root: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sub_index?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    owner: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ledger_hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ledger_hash?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ledger_index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ledger_index?: number | ('validated' | 'closed' | 'current');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property offer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            offer?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            account: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            seq: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ripple_state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ripple_state?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              accounts: [string, string];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              currency: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface LedgerEntryResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface LedgerEntryResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ledger_index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ledger_index: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node?: LedgerEntry;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property node_binary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node_binary?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface LedgerRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface LedgerRequest {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property accounts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            accounts?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property binary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              binary?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property expand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                expand?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property full

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  full?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ledger_hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ledger_hash?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ledger_index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ledger_index?: number | ('validated' | 'closed' | 'current');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property owner_funds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        owner_funds?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property queue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          queue?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property transactions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            transactions?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LedgerResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LedgerResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ledger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ledger: Ledger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ledger_hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ledger_hash: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ledger_index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ledger_index: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property queue_data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      queue_data?: QueueData;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface OfferCreateTransaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface OfferCreateTransaction extends TransactionJSON {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Account

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Account: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Expiration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Expiration?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Fee

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Fee: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Flags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Flags: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property LastLedgerSequence

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  LastLedgerSequence: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Memos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Memos?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Memo: ApiMemo;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property OfferSequence

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      OfferSequence?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Sequence

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sequence: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property TakerGets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TakerGets: RippledAmount;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property TakerPays

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TakerPays: RippledAmount;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property TransactionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TransactionType: 'OfferCreate';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ServerInfoRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ServerInfoRequest {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  id?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ServerInfoResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ServerInfoResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property info

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      info: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      amendment_blocked?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      build_version: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      closed_ledger?: LedgerInfo;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      complete_ledgers: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hostid: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      io_latency_ms: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      last_close: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      converge_time_s: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      proposers: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      load?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      job_types: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      job_type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      per_second: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      in_progress: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      threads: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      load_factor: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      load_factor_local?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      load_factor_net?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      load_factor_cluster?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      load_factor_fee_escalation?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      load_factor_fee_queue?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      load_factor_server?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      peers: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pubkey_node: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pubkey_validator: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      server_state: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      state_accounting: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      uptime: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      validated_ledger?: LedgerInfo;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      validation_quorum: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      validator_list_expires: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SettingsTransaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SettingsTransaction extends TransactionJSON {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property TransferRate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TransferRate?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FormattedOrderCancellation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FormattedOrderCancellation = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            orderSequence: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FormattedOrderCancellationTransaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FormattedOrderCancellationTransaction = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              specification: FormattedOrderCancellation;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              outcome: Outcome;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              address: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sequence: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FormattedOrderTransaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FormattedOrderTransaction = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                specification: FormattedOrderSpecification;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                outcome: Outcome;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                address: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sequence: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FormattedPayment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FormattedPayment = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  source: Adjustment;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  destination: Adjustment;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  paths?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  memos?: Array<Memo>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  invoiceID?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  allowPartialPayment?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  noDirectRipple?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  limitQuality?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FormattedPaymentTransaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FormattedPaymentTransaction = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    specification: FormattedPayment;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    outcome: Outcome;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    address: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sequence: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FormattedSettingsTransaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FormattedSettingsTransaction = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      specification: FormattedSettings;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      outcome: Outcome;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      address: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sequence: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FormattedTransactionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FormattedTransactionType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | FormattedPaymentTransaction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | FormattedOrderTransaction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | FormattedOrderCancellationTransaction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | FormattedTrustlineTransaction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | FormattedSettingsTransaction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FormattedTrustlineTransaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type FormattedTrustlineTransaction = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          specification: FormattedTrustlineSpecification;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          outcome: Outcome;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          address: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sequence: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Instructions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Instructions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sequence?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ticketSequence?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fee?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            maxFee?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            maxLedgerVersion?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            maxLedgerVersionOffset?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            signersCount?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type KeyPair

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type KeyPair = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              publicKey: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              privateKey: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type LedgerClosedEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type LedgerClosedEvent = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'ledgerClosed';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fee_base: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fee_ref: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ledger_hash: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ledger_index: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ledger_time: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reserve_base: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reserve_inc: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                txn_count: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                validated_ledgers: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type LedgerDataResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type LedgerDataResponse = LedgerData;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Outcome

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Outcome = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    result: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ledgerVersion: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    indexInLedger: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fee: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    balanceChanges: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    currency: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    counterparty?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    orderbookChanges: object;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    deliveredAmount?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    currency: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    counterparty?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timestamp?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Prepare

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Prepare = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      txJSON: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      instructions: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fee: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sequence?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ticketSequence?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxLedgerVersion?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SignOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SignOptions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        signAs: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Submit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Submit = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          success: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          engineResult: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          engineResultCode: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          engineResultMessage?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          txBlob?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          txJson?: object;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TransactionJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TransactionJSON = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Account: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TransactionType: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Memos?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Memo: ApiMemo;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Flags?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Fulfillment?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [Field: string]: string | number | Array<any> | RippledAmount | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Package Files (23)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (11)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (29)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/ripple-lib.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/ripple-lib)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/ripple-lib"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>