@pgchain/blockchain-libs/dist/provider/abc.d.ts

PGWallet Blockchain Libs

import { Success, Unsuccessful } from '@onekeyfe/js-sdk';
import BigNumber from 'bignumber.js';
import { ChainInfo, CoinInfo } from '../types/chain';
import { AddressInfo, AddressValidation, ClientInfo, FeePricePerUnit, PartialTokenInfo, SignedTx, TransactionStatus, TypedMessage, UnsignedTx, UTXO } from '../types/provider';
import { Signer, Verifier } from '../types/secret';
declare abstract class BaseClient {
    chainInfo?: ChainInfo;
    setChainInfo(chainInfo: ChainInfo): void;
    abstract getInfo(): Promise<ClientInfo>;
    abstract getAddresses(addresses: Array<string>): Promise<Array<AddressInfo | undefined>>;
    abstract getBalances(requests: Array<{
        address: string;
        coin: Partial<CoinInfo>;
    }>): Promise<Array<BigNumber | undefined>>;
    abstract getTransactionStatuses(txids: Array<string>): Promise<Array<TransactionStatus | undefined>>;
    abstract getFeePricePerUnit(): Promise<FeePricePerUnit>;
    abstract broadcastTransaction(rawTx: string): Promise<string>;
    getTokenInfos(tokenAddresses: Array<string>): Promise<Array<PartialTokenInfo | undefined>>;
    getUTXOs(addresses: Array<string>): Promise<{
        [address: string]: UTXO[];
    }>;
}
declare abstract class SimpleClient extends BaseClient {
    batchCall2SingleCall<T, R>(inputs: T[], handler: (input: T) => Promise<R | undefined>): Promise<Array<R | undefined>>;
    getAddresses(addresses: Array<string>): Promise<Array<AddressInfo | undefined>>;
    abstract getAddress(address: string): Promise<AddressInfo>;
    getBalances(requests: Array<{
        address: string;
        coin: Partial<CoinInfo>;
    }>): Promise<Array<BigNumber | undefined>>;
    getBalance(address: string, coin: Partial<CoinInfo>): Promise<BigNumber>;
    getTransactionStatuses(txids: Array<string>): Promise<Array<TransactionStatus | undefined>>;
    abstract getTransactionStatus(txid: string): Promise<TransactionStatus>;
    getTokenInfos(tokenAddresses: Array<string>): Promise<Array<PartialTokenInfo | undefined>>;
    getTokenInfo(tokenAddress: string): Promise<PartialTokenInfo | undefined>;
    getUTXOs(addresses: Array<string>): Promise<{
        [address: string]: UTXO[];
    }>;
    getUTXO(address: string): Promise<UTXO[]>;
}
declare type ClientFilter = <T extends BaseClient>(client: T) => boolean;
declare abstract class BaseProvider {
    readonly chainInfo: ChainInfo;
    readonly clientSelector: <T extends BaseClient>(filter?: ClientFilter) => Promise<T>;
    constructor(chainInfo: ChainInfo, clientSelector: <T extends BaseClient>(filter?: ClientFilter) => Promise<T>);
    abstract pubkeyToAddress(verifier: Verifier, encoding?: string): Promise<string>;
    abstract verifyAddress(address: string): Promise<AddressValidation>;
    abstract buildUnsignedTx(unsignedTx: UnsignedTx): Promise<UnsignedTx>;
    abstract signTransaction(unsignedTx: UnsignedTx, signers: {
        [p: string]: Signer;
    }): Promise<SignedTx>;
    verifyTokenAddress(address: string): Promise<AddressValidation>;
    signMessage(message: TypedMessage, signer: Signer, address?: string): Promise<string>;
    verifyMessage(address: string, message: TypedMessage, signature: string): Promise<boolean>;
    wrapHardwareCall<T>(callee: () => Promise<Unsuccessful | Success<T>>): Promise<T>;
    hardwareGetXpubs(paths: string[], showOnDevice: boolean): Promise<{
        path: string;
        xpub: string;
    }[]>;
    hardwareGetAddress(path: string, showOnDevice: boolean, addressToVerify?: string): Promise<string>;
    hardwareSignTransaction(unsignedTx: UnsignedTx, signers: Record<string, string>): Promise<SignedTx>;
    hardwareSignMessage(message: TypedMessage, signer: string): Promise<string>;
    hardwareVerifyMessage(address: string, message: TypedMessage, signature: string): Promise<boolean>;
}
export { BaseClient, SimpleClient, BaseProvider, ClientFilter };