ripple-lib

constructor(options?: APIOptions);

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

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

static classicAddressToXAddress: any;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

connection: Connection;

static decodeAccountID: any;

static decodeAccountPublic: any;

static decodeNodePublic: any;

static decodeSeed: any;

static decodeXAddress: any;

deriveAddress: (publicKey: any) => string;

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

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

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

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

dropsToXrp: (drops: BigNumber.Value) => string;

static encodeAccountID: any;

static encodeAccountPublic: any;

static encodeNodePublic: any;

static encodeSeed: any;

static encodeXAddress: any;

errors: typeof errors;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

isConnected: (this: RippleAPI) => boolean;

iso8601ToRippleTime: (iso8601: string) => number;

isValidAddress: (address: string) => boolean;

static isValidClassicAddress: any;

isValidSecret: (secret: string) => boolean;

static isValidXAddress: any;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rippleTimeToISO8601: (rippleTime: number) => string;

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

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

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

static 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 };
};

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 };
};

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

static xAddressToClassicAddress: any;

xrpToDrops: (xrp: BigNumber.Value) => string;

convertStringToHex: (string: string) => string;

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

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

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>;
};

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

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

ledgerVersion: number;

getMethodNames: () => string[];

onLedgerEvent: (ledger: any) => void;

account: string;

ledger_hash?: string;

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

queue?: boolean;

signer_lists?: boolean;

strict?: boolean;

account_data: AccountRootLedgerEntry;

ledger_current_index?: number;

ledger_index?: number;

queue_data?: QueueData;

signer_lists?: SignerListLedgerEntry[];

validated?: boolean;

account: string;

ledger_hash?: string;

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

limit?: number;

marker?: any;

peer?: string;

account: string;

ledger_current_index?: number;

ledger_hash?: string;

ledger_index?: number;

lines: Trustline[];

marker?: any;

account: string;

ledger_hash?: string;

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

limit?: number;

marker?: string;

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

account: string;

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

ledger_current_index?: number;

ledger_hash?: string;

ledger_index?: number;

limit?: number;

marker?: string;

validated?: boolean;

account: string;

ledger_hash?: string;

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

limit?: number;

marker?: any;

account: string;

ledger_current_index?: number;

ledger_hash?: string;

ledger_index?: number;

marker?: any;

offers?: AccountOffer[];

feeCushion?: number;

maxFeeXRP?: string;

proxy?: string;

server?: string;

timeout?: number;

ledger_hash?: string;

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

limit?: number;

marker?: any;

taker?: string;

taker_gets: TakerRequestAmount;

taker_pays: TakerRequestAmount;

ledger_current_index?: number;

ledger_hash?: string;

ledger_index?: number;

marker?: any;

offers: BookOffer[];

account: string;

hotwallet: string | Array<string>;

ledger_hash?: string;

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

strict?: boolean;

account: string;

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

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