opnet/build/providers/AbstractRpcProvider.d.ts

The perfect library for building Bitcoin-based applications.

import { Network } from '@btc-vision/bitcoin';
import { Address, AddressTypes, ChallengeSolution, IP2WSHAddress } from '@btc-vision/transaction';
import '../serialize/BigInt.js';
import { Block } from '../block/Block.js';
import { BlockGasParameters } from '../block/BlockGasParameters.js';
import { BlockWitnesses } from '../block/interfaces/IBlockWitness.js';
import { BigNumberish, BlockTag } from '../common/CommonTypes.js';
import { CallResult } from '../contracts/CallResult.js';
import { ContractData } from '../contracts/ContractData.js';
import { IAccessList } from '../contracts/interfaces/IAccessList.js';
import { ICallRequestError } from '../contracts/interfaces/ICallResult.js';
import { ParsedSimulatedTransaction } from '../contracts/interfaces/SimulatedTransaction.js';
import { Epoch } from '../epoch/Epoch.js';
import { EpochWithSubmissions } from '../epoch/EpochSubmission.js';
import { EpochTemplate } from '../epoch/EpochTemplate.js';
import { EpochSubmissionParams } from '../epoch/interfaces/EpochSubmissionParams.js';
import { SubmittedEpoch } from '../epoch/SubmittedEpoch.js';
import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
import { StoredValue } from '../storage/StoredValue.js';
import { BroadcastedTransaction } from '../transactions/interfaces/BroadcastedTransaction.js';
import { TransactionReceipt } from '../transactions/metadata/TransactionReceipt.js';
import { TransactionBase } from '../transactions/Transaction.js';
import { UTXOsManager } from '../utxos/UTXOsManager.js';
import { JsonRpcPayload } from './interfaces/JSONRpc.js';
import { JSONRpcMethods } from './interfaces/JSONRpcMethods.js';
import { JsonRpcCallResult, JsonRpcResult } from './interfaces/JSONRpcResult.js';
import { AddressesInfo, IPublicKeyInfoResult } from './interfaces/PublicKeyInfo.js';
import { ReorgInformation } from './interfaces/ReorgInformation.js';
export declare abstract class AbstractRpcProvider {
    readonly network: Network;
    private nextId;
    private chainId;
    private gasCache;
    private lastFetchedGas;
    private challengeCache;
    private csvCache;
    protected constructor(network: Network);
    private _utxoManager;
    get utxoManager(): UTXOsManager;
    getCSV1ForAddress(address: Address): IP2WSHAddress;
    getPublicKeyInfo(addressRaw: string | Address, isContract: boolean): Promise<Address>;
    validateAddress(addr: string | Address, network: Network): AddressTypes | null;
    getBlockNumber(): Promise<bigint>;
    getBlockByChecksum(checksum: string, prefetchTxs?: boolean): Promise<Block>;
    getChallenge(): Promise<ChallengeSolution>;
    getBlock(blockNumberOrHash: BlockTag, prefetchTxs?: boolean): Promise<Block>;
    getBlocks(blockNumbers: BlockTag[], prefetchTxs?: boolean): Promise<Block[]>;
    getBlockByHash(blockHash: string): Promise<Block>;
    getBalance(address: string | Address, filterOrdinals?: boolean): Promise<bigint>;
    getBalances(addressesLike: string[], filterOrdinals?: boolean): Promise<Record<string, bigint>>;
    getTransaction(txHash: string): Promise<TransactionBase<OPNetTransactionTypes>>;
    getTransactionReceipt(txHash: string): Promise<TransactionReceipt>;
    getNetwork(): Network;
    getChainId(): Promise<bigint>;
    getCode(address: string | Address, onlyBytecode?: boolean): Promise<ContractData | Buffer>;
    getStorageAt(address: string | Address, rawPointer: bigint | string, proofs?: boolean, height?: BigNumberish): Promise<StoredValue>;
    call(to: string | Address, data: Buffer | string, from?: Address, height?: BigNumberish, simulatedTransaction?: ParsedSimulatedTransaction, accessList?: IAccessList): Promise<CallResult | ICallRequestError>;
    gasParameters(): Promise<BlockGasParameters>;
    sendRawTransaction(tx: string, psbt: boolean): Promise<BroadcastedTransaction>;
    sendRawTransactions(txs: string[]): Promise<BroadcastedTransaction[]>;
    getBlockWitness(height?: BigNumberish, trusted?: boolean, limit?: number, page?: number): Promise<BlockWitnesses>;
    getReorg(fromBlock?: BigNumberish, toBlock?: BigNumberish): Promise<ReorgInformation[]>;
    abstract _send(payload: JsonRpcPayload | JsonRpcPayload[]): Promise<JsonRpcCallResult>;
    callPayloadSingle(payload: JsonRpcPayload): Promise<JsonRpcResult>;
    callMultiplePayloads(payloads: JsonRpcPayload[]): Promise<JsonRpcCallResult>;
    buildJsonRpcPayload<T extends JSONRpcMethods>(method: T, params: unknown[]): JsonRpcPayload;
    getPublicKeysInfoRaw(addresses: string | string[] | Address | Address[]): Promise<IPublicKeyInfoResult>;
    getPublicKeysInfo(addresses: string | string[] | Address | Address[], isContract?: boolean, logErrors?: boolean): Promise<AddressesInfo>;
    getLatestEpoch(includeSubmissions: boolean): Promise<Epoch>;
    getEpochByNumber(epochNumber: BigNumberish, includeSubmissions?: boolean): Promise<Epoch | EpochWithSubmissions>;
    getEpochByHash(epochHash: string, includeSubmissions?: boolean): Promise<Epoch | EpochWithSubmissions>;
    getEpochTemplate(): Promise<EpochTemplate>;
    submitEpoch(params: EpochSubmissionParams): Promise<SubmittedEpoch>;
    protected abstract providerUrl(url: string): string;
    private _gasParameters;
    private parseSimulatedTransaction;
    private bufferToHex;
    private bigintToBase64;
}