Class Client

Client for interacting with rippled servers.

Hierarchy

EventEmitter<EventTypes>
- Client

Index

Constructor

constructor

new Client(server: string, options?: ClientOptions): Client
Creates a new Client with a websocket connection to a rippled server.
Parameters
- server: string
  URL of the server to connect to.
- options: ClientOptions = {}
  Options for client settings.
Returns Client
Example
```
import { Client } from "xrpl"
const client = new Client('wss://s.altnet.rippletest.net:51233')
```
Overrides EventEmitter<EventTypes>.constructor
- Defined in packages/xrpl/src/client/index.ts:246

Abstraction

getBalances

getBalances(
    address: string,
    options?: {
        ledger_hash?: string;
        ledger_index?: LedgerIndex;
        limit?: number;
        peer?: string;
    },
): Promise<{ currency: string; issuer?: string; value: string }[]>
Get XRP/non-XRP balances for an account.
Parameters
- address: string
  Address of the account to retrieve balances for.
- options: {
      ledger_hash?: string;
      ledger_index?: LedgerIndex;
      limit?: number;
      peer?: string;
  } = {}
  Allows the client to specify a ledger_hash, ledger_index, filter by peer, and/or limit number of balances.
  - Optionalledger_hash?: string
    Retrieve the account balances at the ledger with a given ledger_hash.
  - Optionalledger_index?: LedgerIndex
    Retrieve the account balances at a given ledger_index.
  - Optionallimit?: number
    Limit number of balances to return.
  - Optionalpeer?: string
    Filter balances by peer.
Returns Promise<{ currency: string; issuer?: string; value: string }[]>
An array of XRP/non-XRP balances for the given account.
Example
```
const { Client } = require('xrpl')
const client = new Client('wss://s.altnet.rippletest.net:51233')
await client.connect()

async function getAccountBalances(address) {
  try {
    const options = {
      ledger_index: 'validated',
      limit: 10
    };

    const balances = await xrplClient.getBalances(address, options);

    console.log('Account Balances:');
    balances.forEach((balance) => {
      console.log(`Currency: ${balance.currency}`);
      console.log(`Value: ${balance.value}`);
      console.log(`Issuer: ${balance.issuer}`);
      console.log('---');
    });
  } catch (error) {
    console.error('Error retrieving account balances:', error);
  }
}

const address = 'rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh';
await getAccountBalances(address);
await client.disconnect();
```
- Defined in packages/xrpl/src/client/index.ts:999

getLedgerIndex

getLedgerIndex(): Promise<number>

Returns the index of the most recently validated ledger.

Returns Promise<number>

The most recently validated ledger index.

Example

const { Client } = require('xrpl')
const client = new Client('wss://s.altnet.rippletest.net:51233')
await client.connect()
const ledgerIndex = await client.getLedgerIndex()
console.log(ledgerIndex)
// 884039

getOrderbook

getOrderbook(
    currency1: BookOfferCurrency,
    currency2: BookOfferCurrency,
    options?: {
        ledger_hash?: null | string;
        ledger_index?: LedgerIndex;
        limit?: number;
        taker?: null | string;
    },
): Promise<{ buy: BookOffer[]; sell: BookOffer[] }>
Fetch orderbook (buy/sell orders) between two currency pairs. This checks both sides of the orderbook by making two order_book requests (with the second reversing takerPays and takerGets). Returned offers are not normalized in this function, so either currency could be takerGets or takerPays.
Parameters
- currency1: BookOfferCurrency
  Specification of one currency involved. (With a currency code and optionally an issuer)
- currency2: BookOfferCurrency
  Specification of a second currency involved. (With a currency code and optionally an issuer)
- options: {
      ledger_hash?: null | string;
      ledger_index?: LedgerIndex;
      limit?: number;
      taker?: null | string;
  } = {}
  Options allowing the client to specify ledger_index, ledger_hash, filter by taker, and/or limit number of orders.
  - Optionalledger_hash?: null | string
    Retrieve the orderbook at the ledger with a given ledger_hash.
  - Optionalledger_index?: LedgerIndex
    Retrieve the orderbook at a given ledger_index.
  - Optionallimit?: number
    The limit passed into each book_offers request. Can return more than this due to two calls being made. Defaults to 20.
  - Optionaltaker?: null | string
    Filter orders by taker.
Returns Promise<{ buy: BookOffer[]; sell: BookOffer[] }>
An object containing buy and sell objects.
- Defined in packages/xrpl/src/client/index.ts:1068

getXrpBalance

getXrpBalance(
address: string,
options?: { ledger_hash?: string; ledger_index?: LedgerIndex },
): Promise<number>
Retrieves the XRP balance of a given account address.
Parameters
- address: string
  The XRP address to retrieve the balance for.
- Optionaloptions: { ledger_hash?: string; ledger_index?: LedgerIndex } = {}
  Additional options for fetching the balance (optional).
  - Optionalledger_hash?: string
    The hash of the ledger to retrieve the balance from (optional).
  - Optionalledger_index?: LedgerIndex
    The index of the ledger to retrieve the balance from (optional).
Returns Promise<number>
A promise that resolves with the XRP balance as a number.
Example
```
const client = new Client(wss://s.altnet.rippletest.net:51233)
await client.connect()
const balance = await client.getXrpBalance('rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn')
console.log(balance)
await client.disconnect()
/// '200'
```
- Defined in packages/xrpl/src/client/index.ts:933

Core

autofill

autofill<T extends SubmittableTransaction>(
transaction: T,
signersCount?: number,
): Promise<T>
Autofills fields in a transaction. This will set Sequence, Fee, lastLedgerSequence according to the current state of the server this Client is connected to. It also converts all X-Addresses to classic addresses and flags interfaces into numbers.
Type Parameters
- T extends SubmittableTransaction
Parameters
- transaction: T
  A SubmittableTransaction in JSON format
- OptionalsignersCount: number
  The expected number of signers for this transaction. Only used for multisigned transactions.
Returns Promise<T>
The autofilled transaction.
Example
```
const { Client } = require('xrpl')

const client = new Client('wss://s.altnet.rippletest.net:51233')

async function createAndAutofillTransaction() {
  const transaction = {
    TransactionType: 'Payment',
    Account: 'rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh',
    Destination: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
    Amount: '10000000' // 10 XRP in drops (1/1,000,000th of an XRP)
  }

  try {
    const autofilledTransaction = await client.autofill(transaction)
    console.log(autofilledTransaction)
  } catch (error) {
    console.error(`Failed to autofill transaction: ${error}`)
  }
}

createAndAutofillTransaction()
```
Autofill helps fill in fields which should be included in a transaction, but can be determined automatically such as LastLedgerSequence and Fee. If you override one of the fields autofill changes, your explicit values will be used instead. By default, this is done as part of submit and submitAndWait when you pass in an unsigned transaction along with your wallet to be submitted.
Throws
ValidationError If Amount and DeliverMax fields are not identical in a Payment Transaction
- Defined in packages/xrpl/src/client/index.ts:666

simulate

simulate<Binary extends boolean = false>(
    transaction: string | SubmittableTransaction,
    opts?: { binary?: Binary },
): Promise<
    Binary extends true
        ? SimulateBinaryResponse
        : SimulateJsonResponse<Transaction>,
>
Simulates an unsigned transaction. Steps performed on a transaction:
1. Autofill.
2. Sign & Encode.
3. Submit.
Type Parameters
- Binary extends boolean = false
Parameters
- transaction: string | SubmittableTransaction
  A transaction to autofill, sign & encode, and submit.
- Optionalopts: { binary?: Binary }
  (Optional) Options used to sign and submit a transaction.
  - Optionalbinary?: Binary
    If true, return the metadata in a binary encoding.
Returns Promise<
    Binary extends true
        ? SimulateBinaryResponse
        : SimulateJsonResponse<Transaction>,
>
A promise that contains SimulateResponse.

Throws
RippledError if the simulate request fails.
- Defined in packages/xrpl/src/client/index.ts:789

submit

submit(
transaction: string | SubmittableTransaction,
opts?: { autofill?: boolean; failHard?: boolean; wallet?: Wallet },
): Promise<SubmitResponse>
Submits a signed/unsigned transaction. Steps performed on a transaction:
1. Autofill.
2. Sign & Encode.
3. Submit.
Parameters
- transaction: string | SubmittableTransaction
  A transaction to autofill, sign & encode, and submit.
- Optionalopts: { autofill?: boolean; failHard?: boolean; wallet?: Wallet }
  (Optional) Options used to sign and submit a transaction.
  - Optionalautofill?: boolean
    If true, autofill a transaction.
  - OptionalfailHard?: boolean
    If true, and the transaction fails locally, do not retry or relay the transaction to other servers.
  - Optionalwallet?: Wallet
    A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.
Returns Promise<SubmitResponse>
A promise that contains SubmitResponse.
Throws
RippledError if submit request fails.
Example
```
const { Client, Wallet } = require('xrpl')
const client = new Client('wss://s.altnet.rippletest.net:51233')
await client.connect()
const wallet = Wallet.generate()
const transaction = {
  TransactionType: 'Payment',
  Account: wallet.classicAddress,
  Destination: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
  Amount: '10000000' // 10 XRP in drops (1/1,000,000th of an XRP)
}
const submitResponse = await client.submit(transaction, { wallet })
console.log(submitResponse)
```
- Defined in packages/xrpl/src/client/index.ts:757

submitAndWait

submitAndWait<T extends SubmittableTransaction = SubmittableTransaction>(
transaction: string | T,
opts?: { autofill?: boolean; failHard?: boolean; wallet?: Wallet },
): Promise<TxResponse<T>>
Asynchronously submits a transaction and verifies that it has been included in a validated ledger (or has errored/will not be included for some reason). See Reliable Transaction Submission.
Type Parameters
- T extends SubmittableTransaction = SubmittableTransaction
Parameters
- transaction: string | T
  A transaction to autofill, sign & encode, and submit.
- Optionalopts: { autofill?: boolean; failHard?: boolean; wallet?: Wallet }
  (Optional) Options used to sign and submit a transaction.
  - Optionalautofill?: boolean
    If true, autofill a transaction.
  - OptionalfailHard?: boolean
    If true, and the transaction fails locally, do not retry or relay the transaction to other servers.
  - Optionalwallet?: Wallet
    A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.
Returns Promise<TxResponse<T>>
A promise that contains TxResponse, that will return when the transaction has been validated.
Example
```
const { Client, Wallet } = require('xrpl')
const client = new Client('wss://s.altnet.rippletest.net:51233')

async function submitTransaction() {
  const senderWallet = client.fundWallet()
  const recipientWallet = client.fundWallet()

  const transaction = {
    TransactionType: 'Payment',
    Account: senderWallet.address,
    Destination: recipientWallet.address,
    Amount: '10'
  }

  try {
    await client.submit(signedTransaction, { wallet: senderWallet })
    console.log(result)
  } catch (error) {
    console.error(`Failed to submit transaction: ${error}`)
  }
}

submitTransaction()
```
In this example we submit a payment transaction between two newly created testnet accounts.

Under the hood, submit will call client.autofill by default, and because we've passed in a Wallet it Will also sign the transaction for us before submitting the signed transaction binary blob to the ledger.

This is similar to submitAndWait which does all of the above, but also waits to see if the transaction has been validated.
Throws
Connection errors: If the Client object is unable to establish a connection to the specified WebSocket endpoint, an error will be thrown.

Throws
Transaction errors: If the submitted transaction is invalid or cannot be included in a validated ledger for any reason, the promise returned by submitAndWait() will be rejected with an error. This could include issues with insufficient balance, invalid transaction fields, or other issues specific to the transaction being submitted.

Throws
Ledger errors: If the ledger being used to submit the transaction is undergoing maintenance or otherwise unavailable, an error will be thrown.

Throws
Timeout errors: If the transaction takes longer than the specified timeout period to be included in a validated ledger, the promise returned by submitAndWait() will be rejected with an error.
- Defined in packages/xrpl/src/client/index.ts:864

Faucet

fundWallet

fundWallet(
    this: Client,
    wallet?: null | Wallet,
    options?: FundingOptions,
): Promise<{ balance: number; wallet: Wallet }>
The fundWallet() method is used to send an amount of XRP (usually 1000) to a new (randomly generated) or existing XRP Ledger wallet.
Parameters
- this: Client
- Optionalwallet: null | Wallet
  An existing XRPL Wallet to fund. If undefined or null, a new Wallet will be created.
- options: FundingOptions = {}
  See below.
  - Optionalamount?: string
    A custom amount to fund, if undefined or null, the default amount will be 1000.
  - OptionalfaucetHost?: string
    A custom host for a faucet server. On devnet, testnet, AMM devnet, and HooksV3 testnet, fundWallet will attempt to determine the correct server automatically. In other environments, or if you would like to customize the faucet host in devnet or testnet, you should provide the host using this option.
  - OptionalfaucetPath?: string
    A custom path for a faucet server. On devnet, testnet, AMM devnet, and HooksV3 testnet, fundWallet will attempt to determine the correct path automatically. In other environments, or if you would like to customize the faucet path in devnet or testnet, you should provide the path using this option. Ex: client.fundWallet(null,{'faucet.altnet.rippletest.net', '/accounts'}) specifies a request to 'faucet.altnet.rippletest.net/accounts' to fund a new wallet.
  - OptionalusageContext?: string
    An optional field to indicate the use case context of the faucet transaction Ex: integration test, code snippets.
Returns Promise<{ balance: number; wallet: Wallet }>
A Wallet on the Testnet or Devnet that contains some amount of XRP, and that wallet's balance in XRP.
Example
Example 1: Fund a randomly generated wallet const { Client, Wallet } = require('xrpl')

const client = new Client('wss://s.altnet.rippletest.net:51233') await client.connect() const { balance, wallet } = await client.fundWallet()

Under the hood, this will use Wallet.generate() to create a new random wallet, then ask a testnet faucet To send it XRP on ledger to make it a real account. If successful, this will return the new account balance in XRP Along with the Wallet object to track the keys for that account. If you'd like, you can also re-fill an existing Account by passing in a Wallet you already have.
```
const api = new xrpl.Client("wss://s.altnet.rippletest.net:51233")
await api.connect()
const { wallet, balance } = await api.fundWallet()
```
Example 2: Fund wallet using a custom faucet host and known wallet address

fundWallet will try to infer the url of a faucet API from the network your client is connected to. There are hardcoded default faucets for popular test networks like testnet and devnet. However, if you're working with a newer or more obscure network, you may have to specify the faucetHost And faucetPath so fundWallet can ask that faucet to fund your wallet.
```
const newWallet = Wallet.generate()
const { balance, wallet  } = await client.fundWallet(newWallet, {
      amount: '10',
      faucetHost: 'https://custom-faucet.example.com',
      faucetPath: '/accounts'
    })
    console.log(`Sent 10 XRP to wallet: ${address} from the given faucet. Resulting balance: ${balance} XRP`)
  } catch (error) {
    console.error(`Failed to fund wallet: ${error}`)
  }
}
```
Throws
When either Client isn't connected or unable to fund wallet address.
- Defined in packages/xrpl/src/client/index.ts:1199

Fee

`Readonly`feeCushion

feeCushion: number

Factor to multiply estimated fee by to provide a cushion in case the required fee rises during submission of a transaction. Defaults to 1.2.

`Readonly`maxFeeXRP

maxFeeXRP: string

Maximum transaction cost to allow, in decimal XRP. Must be a string-encoded number. Defaults to '2'.

Network

url

get url(): string
Get the url that the client is connected to.

Returns string
The URL of the server this client is connected to.
- Defined in packages/xrpl/src/client/index.ts:317

connect

connect(): Promise<void>
Tells the Client instance to connect to its rippled server.

Returns Promise<void>
A promise that resolves with a void value when a connection is established.
Example
Client.connect() establishes a connection between a Client object and the server.
```
const { Client } = require('xrpl')
const client = new Client('wss://s.altnet.rippletest.net:51233')
await client.connect()
// do something with the client
await client.disconnect()
```
If you open a client connection, be sure to close it with await client.disconnect() before exiting your application.
Example
```
const { Client } = require('xrpl')
const client = new Client('wss://s.altnet.rippletest.net:51233')
await client.connect()
// do something with the client
await client.disconnect()
```
- Defined in packages/xrpl/src/client/index.ts:562

disconnect

disconnect(): Promise<void>
Disconnects the XRPL client from the server and cancels all pending requests and subscriptions. Call when you want to disconnect the client from the server, such as when you're finished using the client or when you need to switch to a different server.

Returns Promise<void>
A promise that resolves with a void value when a connection is destroyed.
Example
To use the disconnect() method, you first need to create a new Client object and connect it to a server:
```
const { Client } = require('xrpl')
const client = new Client('wss://s.altnet.rippletest.net:51233')
await client.connect()
// do something with the client
await client.disconnect()
```
- Defined in packages/xrpl/src/client/index.ts:589

isConnected

isConnected(): boolean

Checks if the Client instance is connected to its rippled server.

Returns boolean

Whether the client instance is connected.

Example

const { Client } = require('xrpl')
const client = new Client('wss://s.altnet.rippletest.net:51233')
await client.connect()
console.log(client.isConnected())
// true
await client.disconnect()
console.log(client.isConnected())
// false

on

on<
    T extends EventTypes,
    U extends (...args: any[]) => void = OnEventToListenerMap<T>,
>(
    eventName: T,
    listener: U,
): this
Event handler for subscription streams.
Type Parameters
- T extends EventTypes
- U extends (...args: any[]) => void = OnEventToListenerMap<T>
Parameters
- eventName: T
  Name of the event. Only forwards streams.
- listener: U
  Function to run on event.
Returns this
This, because it inherits from EventEmitter.
Example
```
const api = new Client('wss://s.altnet.rippletest.net:51233')

api.on('transaction', (tx: TransactionStream) => {
 console.log("Received Transaction")
 console.log(tx)
})

await api.connect()
const response = await api.request({
    command: 'subscribe',
    streams: ['transactions_proposed']
})
```
Overrides EventEmitter.on
- Defined in packages/xrpl/src/client/index.ts:422

request

request<
    R extends Request,
    V extends APIVersion = 2,
    T = RequestResponseMap<R, V>,
>(
    req: R,
): Promise<T>
Makes a request to the client with the given command and additional request body parameters.
Type Parameters
- R extends Request
- V extends APIVersion = 2
- T = RequestResponseMap<R, V>
Parameters
- req: R
  Request to send to the server.
Returns Promise<T>
The response from the server.
Example
```
const response = await client.request({
  command: 'account_info',
  account: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
})
console.log(response)
```
- Defined in packages/xrpl/src/client/index.ts:338

requestAll

requestAll<T extends MarkerRequest, U = RequestAllResponseMap<T, APIVersion>>(
request: T,
collect?: string,
): Promise<U[]>
Makes multiple paged requests to the client to return a given number of resources. Multiple paged requests will be made until the limit number of resources is reached (if no limit is provided, a single request will be made).

If the command is unknown, an additional collect property is required to know which response key contains the array of resources.

NOTE: This command is used by existing methods and is not recommended for general use. Instead, use rippled's built-in pagination and make multiple requests as needed.
Type Parameters
- T extends MarkerRequest
- U = RequestAllResponseMap<T, APIVersion>
Parameters
- request: T
  The initial request to send to the server.
- Optionalcollect: string
  (Optional) the param to use to collect the array of resources (only needed if command is unknown).
Returns Promise<U[]>
The array of all responses.
Throws
ValidationError if there is no collection key (either from a known command or for the unknown command).
Example
```
// Request all ledger data pages
const allResponses = await client.requestAll({ command: 'ledger_data' });
console.log(allResponses);
```
Example
```
// Request all transaction data pages
const allResponses = await client.requestAll({ command: 'transaction_data' });
console.log(allResponses);
```
- Defined in packages/xrpl/src/client/index.ts:461

requestNextPage

requestNextPage<
    T extends RequestNextPageType,
    U extends

            | AccountChannelsResponse
            | AccountLinesResponse
            | AccountObjectsResponse
            | AccountOffersResponse
            | AccountTxResponse
            | LedgerDataResponse,
>(
    req: T,
    resp: U,
): Promise<RequestNextPageReturnMap<T>>
Requests the next page of data.
Type Parameters
- T extends RequestNextPageType
- U extends
      | AccountChannelsResponse
      | AccountLinesResponse
      | AccountObjectsResponse
      | AccountOffersResponse
      | AccountTxResponse
      | LedgerDataResponse
Parameters
- req: T
  Request to send.
- resp: U
  Response with the marker to use in the request.
Returns Promise<RequestNextPageReturnMap<T>>
The response with the next page of data.
Example
```
const response = await client.request({
 command: 'account_tx',
 account: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
})
console.log(response)
const nextResponse = await client.requestNextPage({
  command: 'account_tx',
  account: 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59',
},
response)
console.log(nextResponse)
```
- Defined in packages/xrpl/src/client/index.ts:383

Other

apiVersion

apiVersion: APIVersion = DEFAULT_API_VERSION

API Version used by the server this client is connected to

buildVersion

buildVersion: undefined | string

Rippled Version used by the server this client is connected to

`Readonly`connection

connection: Connection

networkID

networkID: undefined | number

Network ID of the server this client is connected to

`Static`prefixed

prefixed: string | boolean

addListener

addListener<T extends EventTypes>(
    event: T,
    fn: (...args: any[]) => void,
    context?: any,
): this
Type Parameters
- T extends EventTypes
Parameters
- event: T
- fn: (...args: any[]) => void
- Optionalcontext: any
Returns this
Inherited from EventEmitter.addListener
- Defined in node_modules/eventemitter3/index.d.ts:45

emit

emit<T extends EventTypes>(event: T, ...args: any[]): boolean
Calls each of the listeners registered for a given event.
Type Parameters
- T extends EventTypes
Parameters
- event: T
- ...args: any[]
Returns boolean
Inherited from EventEmitter.emit
- Defined in node_modules/eventemitter3/index.d.ts:32

eventNames

eventNames(): EventTypes[]
Return an array listing the events for which the emitter has registered listeners.

Returns EventTypes[]
Inherited from EventEmitter.eventNames
- Defined in node_modules/eventemitter3/index.d.ts:15

getServerInfo

getServerInfo(): Promise<void>

Get networkID and buildVersion from server_info

Returns Promise<void>

void

Example

const { Client } = require('xrpl')
const client = new Client('wss://s.altnet.rippletest.net:51233')
await client.getServerInfo()
console.log(client.networkID)
console.log(client.buildVersion)

listenerCount

listenerCount(event: EventTypes): number
Return the number of listeners listening to a given event.
Parameters
- event: EventTypes
Returns number
Inherited from EventEmitter.listenerCount
- Defined in node_modules/eventemitter3/index.d.ts:27

listeners

listeners<T extends EventTypes>(event: T): (...args: any[]) => void[]
Return the listeners registered for a given event.
Type Parameters
- T extends EventTypes
Parameters
- event: T
Returns (...args: any[]) => void[]
Inherited from EventEmitter.listeners
- Defined in node_modules/eventemitter3/index.d.ts:20

off

off<T extends EventTypes>(
    event: T,
    fn?: (...args: any[]) => void,
    context?: any,
    once?: boolean,
): this
Type Parameters
- T extends EventTypes
Parameters
- event: T
- Optionalfn: (...args: any[]) => void
- Optionalcontext: any
- Optionalonce: boolean
Returns this
Inherited from EventEmitter.off
- Defined in node_modules/eventemitter3/index.d.ts:69

once

once<T extends EventTypes>(
    event: T,
    fn: (...args: any[]) => void,
    context?: any,
): this
Add a one-time listener for a given event.
Type Parameters
- T extends EventTypes
Parameters
- event: T
- fn: (...args: any[]) => void
- Optionalcontext: any
Returns this
Inherited from EventEmitter.once
- Defined in node_modules/eventemitter3/index.d.ts:54

prepareTransaction

prepareTransaction(
transaction: SubmittableTransaction,
signersCount?: number,
): Promise<SubmittableTransaction>
Deprecated: Use autofill instead, provided for users familiar with v1
Parameters
- transaction: SubmittableTransaction
  A Transaction in JSON format
- OptionalsignersCount: number
  The expected number of signers for this transaction. Only used for multisigned transactions.
Returns Promise<SubmittableTransaction>
Deprecated
Use autofill instead, provided for users familiar with v1
- Defined in packages/xrpl/src/client/index.ts:905

removeAllListeners

removeAllListeners(event?: EventTypes): this
Remove all listeners, or those of the specified event.
Parameters
- Optionalevent: EventTypes
Returns this
Inherited from EventEmitter.removeAllListeners
- Defined in node_modules/eventemitter3/index.d.ts:79

removeListener

removeListener<T extends EventTypes>(
    event: T,
    fn?: (...args: any[]) => void,
    context?: any,
    once?: boolean,
): this
Remove the listeners of a given event.
Type Parameters
- T extends EventTypes
Parameters
- event: T
- Optionalfn: (...args: any[]) => void
- Optionalcontext: any
- Optionalonce: boolean
Returns this
Inherited from EventEmitter.removeListener
- Defined in node_modules/eventemitter3/index.d.ts:63

Class Client

Hierarchy

Index

Constructor

Abstraction

Core

Faucet

Fee

Network

Other

Constructor

constructor

Parameters

Returns Client

Example

Abstraction

getBalances

Parameters

Optionalledger_hash?: string

Optionalledger_index?: LedgerIndex

Optionallimit?: number

Optionalpeer?: string

Returns Promise<{ currency: string; issuer?: string; value: string }[]>

Example

getLedgerIndex

Returns Promise<number>

Example

getOrderbook

Parameters

Optionalledger_hash?: null | string

Optionalledger_index?: LedgerIndex

Optionallimit?: number

Optionaltaker?: null | string

Returns Promise<{ buy: BookOffer[]; sell: BookOffer[] }>

getXrpBalance

Parameters

Optionalledger_hash?: string

Optionalledger_index?: LedgerIndex

Returns Promise<number>

Example

Core

autofill

Type Parameters

Parameters

Returns Promise<T>

Example

Throws

simulate

Type Parameters

Parameters

Optionalbinary?: Binary

Returns Promise< Binary extends true ? SimulateBinaryResponse : SimulateJsonResponse<Transaction>,>

Throws

submit

Parameters

Optionalautofill?: boolean

OptionalfailHard?: boolean

Optionalwallet?: Wallet

Returns Promise<SubmitResponse>

Throws

Example

submitAndWait

Type Parameters

Parameters

Optionalautofill?: boolean

OptionalfailHard?: boolean

Optionalwallet?: Wallet

Returns Promise<TxResponse<T>>

Example

Throws

Throws

Throws

Throws

Faucet

fundWallet

Parameters

Optionalamount?: string

OptionalfaucetHost?: string

OptionalfaucetPath?: string

OptionalusageContext?: string

`Optional`ledger_hash?: string

`Optional`ledger_index?: LedgerIndex

`Optional`limit?: number

`Optional`peer?: string

`Optional`ledger_hash?: null | string

`Optional`ledger_index?: LedgerIndex

`Optional`limit?: number

`Optional`taker?: null | string

`Optional`ledger_hash?: string

`Optional`ledger_index?: LedgerIndex

`Optional`binary?: Binary

Returns Promise<
Binary extends true
? SimulateBinaryResponse
: SimulateJsonResponse<Transaction>,
>

`Optional`autofill?: boolean

`Optional`failHard?: boolean

`Optional`wallet?: Wallet

`Optional`autofill?: boolean

`Optional`failHard?: boolean

`Optional`wallet?: Wallet

`Optional`amount?: string

`Optional`faucetHost?: string

`Optional`faucetPath?: string

`Optional`usageContext?: string

`Readonly`feeCushion

`Readonly`maxFeeXRP

`Readonly`connection

`Static`prefixed