eosjs

constructor(args: {
    rpc: JsonRpc;
    authorityProvider?: AuthorityProvider;
    abiProvider?: AbiProvider;
    signatureProvider: SignatureProvider;
    chainId?: string;
    textEncoder?: TextEncoder;
    textDecoder?: TextDecoder;
});

abiProvider: AbiProvider;

abiTypes: Map<string, ser.Type>;

authorityProvider: AuthorityProvider;

cachedAbis: Map<string, CachedAbi>;

chainId: string;

contracts: Map<string, ser.Contract>;

rpc: JsonRpc;

signatureProvider: SignatureProvider;

textDecoder: TextDecoder;

textEncoder: TextEncoder;

transactionTypes: Map<string, ser.Type>;

buildTransaction: (
    cb?: (tx: TransactionBuilder) => void
) => TransactionBuilder | void;

deflateSerializedArray: (serializedArray: Uint8Array) => Uint8Array;

deleteTransactionExtensionObjects: (transaction: Transaction) => Transaction;

deserialize: (buffer: ser.SerialBuffer, type: string) => any;

deserializeActions: (actions: ser.Action[]) => Promise<ser.Action[]>;

deserializeTransaction: (transaction: Uint8Array) => Transaction;

deserializeTransactionExtensions: (data: [number, string][]) => any[];

deserializeTransactionWithActions: (
    transaction: Uint8Array | string
) => Promise<Transaction>;

getAbi: (accountName: string, reload?: boolean) => Promise<Abi>;

getCachedAbi: (accountName: string, reload?: boolean) => Promise<CachedAbi>;

getContract: (accountName: string, reload?: boolean) => Promise<ser.Contract>;

getTransactionAbis: (
    transaction: Transaction,
    reload?: boolean
) => Promise<BinaryAbi[]>;

inflateSerializedArray: (compressedSerializedArray: Uint8Array) => Uint8Array;

jsonToRawAbi: (jsonAbi: Abi) => Uint8Array;

pushCompressedSignedTransaction: (
    {
        signatures,
        serializedTransaction,
        serializedContextFreeData,
    }: PushTransactionArgs,
    readOnlyTrx?: boolean,
    returnFailureTraces?: boolean
) => Promise<TransactResult | ReadOnlyTransactResult>;

pushSignedTransaction: (
    {
        signatures,
        serializedTransaction,
        serializedContextFreeData,
    }: PushTransactionArgs,
    readOnlyTrx?: boolean,
    returnFailureTraces?: boolean
) => Promise<TransactResult | ReadOnlyTransactResult>;

query: (
    account: string,
    short: boolean,
    query: Query,
    { sign, requiredKeys, authorization }: QueryConfig
) => Promise<any>;

rawAbiToJson: (rawAbi: Uint8Array) => Abi;

serialize: (buffer: ser.SerialBuffer, type: string, value: any) => void;

serializeActions: (actions: ser.Action[]) => Promise<ser.SerializedAction[]>;

serializeContextFreeData: (contextFreeData: Uint8Array[]) => Uint8Array;

serializeTransaction: (transaction: Transaction) => Uint8Array;

serializeTransactionExtensions: (transaction: Transaction) => [number, string][];

transact: (
    transaction: Transaction,
    {
        broadcast,
        sign,
        readOnlyTrx,
        returnFailureTraces,
        requiredKeys,
        compression,
        blocksBehind,
        useLastIrreversible,
        expireSeconds,
    }?: TransactConfig
) => Promise<TransactResult | ReadOnlyTransactResult | PushTransactionArgs>;

with: (accountName: string) => ActionBuilder;

constructor(
    endpoint: string,
    args?: { fetch?: (input?: any, init?: any) => Promise<any> }
);

endpoint: string;

fetchBuiltin: (input?: any, init?: any) => Promise<any>;

abi_bin_to_json: (
    code: string,
    action: string,
    binargs: string
) => Promise<AbiBinToJsonResult>;

abi_json_to_bin: (
    code: string,
    action: string,
    args: any[]
) => Promise<AbiJsonToBinResult>;

db_size_get: () => Promise<DBSizeGetResult>;

fetch: (path: string, body: any) => Promise<any>;

get_abi: (accountName: string) => Promise<GetAbiResult>;

get_account: (accountName: string) => Promise<GetAccountResult>;

get_accounts_by_authorizers: (
    accounts: Authorization[],
    keys: string[]
) => Promise<GetAccountsByAuthorizersResult>;

get_activated_protocol_features: ({
    limit,
    search_by_block_num,
    reverse,
    lower_bound,
    upper_bound,
}: GetActivatedProtocolFeaturesParams) => Promise<GetActivatedProtocolFeaturesResult>;

get_block: (blockNumOrId: number | string) => Promise<GetBlockResult>;

get_block_header_state: (
    blockNumOrId: number | string
) => Promise<GetBlockHeaderStateResult>;

get_block_info: (blockNum: number) => Promise<GetBlockInfoResult>;

get_code: (accountName: string) => Promise<GetCodeResult>;

get_code_hash: (accountName: string) => Promise<GetCodeHashResult>;

get_currency_balance: (
    code: string,
    account: string,
    symbol?: string
) => Promise<string[]>;

get_currency_stats: (
    code: string,
    symbol: string
) => Promise<GetCurrencyStatsResult>;

get_info: () => Promise<GetInfoResult>;

get_kv_table_rows: ({
    json,
    code,
    table,
    index_name,
    encode_type,
    index_value,
    lower_bound,
    upper_bound,
    limit,
    reverse,
    show_payer,
}: any) => Promise<GetTableRowsResult>;

get_producer_schedule: () => Promise<GetProducerScheduleResult>;

get_producers: (
    json?: boolean,
    lowerBound?: string,
    limit?: number
) => Promise<GetProducersResult>;

get_raw_abi: (accountName: string) => Promise<GetRawAbiResult>;

get_raw_code_and_abi: (accountName: string) => Promise<GetRawCodeAndAbiResult>;

get_scheduled_transactions: (
    json?: boolean,
    lowerBound?: string,
    limit?: number
) => Promise<GetScheduledTransactionsResult>;

get_table_by_scope: ({
    code,
    table,
    lower_bound,
    upper_bound,
    limit,
}: any) => Promise<GetTableByScopeResult>;

get_table_rows: ({
    json,
    code,
    scope,
    table,
    lower_bound,
    upper_bound,
    index_position,
    key_type,
    limit,
    reverse,
    show_payer,
}: any) => Promise<GetTableRowsResult>;

getRawAbi: (accountName: string) => Promise<BinaryAbi>;

getRequiredKeys: (args: AuthorityProviderArgs) => Promise<string[]>;

history_get_actions: (
    accountName: string,
    pos?: number,
    offset?: number
) => Promise<GetActionsResult>;

history_get_controlled_accounts: (
    controllingAccount: string
) => Promise<GetControlledAccountsResult>;

history_get_key_accounts: (publicKey: string) => Promise<GetKeyAccountsResult>;

history_get_transaction: (
    id: string,
    blockNumHint?: number
) => Promise<GetTransactionResult>;

push_ro_transaction: (
    { signatures, compression, serializedTransaction }: PushTransactionArgs,
    returnFailureTraces?: boolean
) => Promise<ReadOnlyTransactResult>;

push_transaction: ({
    signatures,
    compression,
    serializedTransaction,
    serializedContextFreeData,
}: PushTransactionArgs) => Promise<TransactResult>;

push_transactions: (
    transactions: PushTransactionArgs[]
) => Promise<TransactResult[]>;

send_transaction: ({
    signatures,
    compression,
    serializedTransaction,
    serializedContextFreeData,
}: PushTransactionArgs) => Promise<TransactResult>;

trace_get_block: (block_num: number) => Promise<TraceApiGetBlockResult>;

constructor(json: any);

details: any;

json: any;

type ContextFreeGroupCallback = (index: { cfa: number; cfd: number }) => {
    action?: SerializedAction;
    contextFreeAction?: SerializedAction;
    contextFreeData?: Uint8Array;
};

type Query =
    | string
    | [string, Query[]]
    | [string, Anyvar, Query[]]
    | {
          method: string;
          arg?: Anyvar;
          filter?: Query[];
      };

const privateKeyDataSize: number;

const publicKeyDataSize: number;

const signatureDataSize: number;

base58ToBinary: (size: number, s: string) => Uint8Array;

base64ToBinary: (s: string) => Uint8Array;

binaryToBase58: (bignum: Uint8Array, minDigits?: number) => string;

binaryToDecimal: (bignum: Uint8Array, minDigits?: number) => string;

convertLegacyPublicKey: (s: string) => string;

convertLegacyPublicKeys: (keys: string[]) => string[];

decimalToBinary: (size: number, s: string) => Uint8Array;

isNegative: (bignum: Uint8Array) => boolean;

negate: (bignum: Uint8Array) => void;

privateKeyToLegacyString: (key: Key) => string;

privateKeyToString: (key: Key) => string;

publicKeyToLegacyString: (key: Key) => string;

publicKeyToString: (key: Key) => string;

signatureToString: (signature: Key) => string;

signedBinaryToDecimal: (bignum: Uint8Array, minDigits?: number) => string;

signedDecimalToBinary: (size: number, s: string) => Uint8Array;

stringToPrivateKey: (s: string) => Key;

stringToPublicKey: (s: string) => Key;

stringToSignature: (s: string) => Key;