@0x/web3-wrapper/lib/src/web3_wrapper.d.ts

import { AbiDecoder, BigNumber } from '@0x/utils';
import { BlockParam, BlockWithoutTransactionData, BlockWithTransactionData, CallData, FilterObject, JSONRPCRequestPayload, LogEntry, SupportedProvider, TraceParams, Transaction, TransactionReceipt, TransactionReceiptWithDecodedLogs, TransactionTrace, TxAccessListWithGas, TxData } from 'ethereum-types';
import { NodeType } from './types';
/**
 * An alternative to the Web3.js library that provides a consistent, clean, promise-based interface.
 */
export declare class Web3Wrapper {
    /**
     * Flag to check if this instance is of type Web3Wrapper
     */
    isZeroExWeb3Wrapper: boolean;
    abiDecoder: AbiDecoder;
    private _provider;
    private readonly _supportedProvider;
    private readonly _callAndTxnDefaults;
    private _jsonRpcRequestId;
    /**
     * Check if an address is a valid Ethereum address
     * @param address Address to check
     * @returns Whether the address is a valid Ethereum address
     */
    static isAddress(address: string): boolean;
    /**
     * A unit amount is defined as the amount of a token above the specified decimal places (integer part).
     * E.g: If a currency has 18 decimal places, 1e18 or one quintillion of the currency is equivalent
     * to 1 unit.
     * @param   amount      The amount in baseUnits that you would like converted to units.
     * @param   decimals    The number of decimal places the unit amount has.
     * @return  The amount in units.
     */
    static toUnitAmount(amount: BigNumber, decimals: number): BigNumber;
    /**
     * A baseUnit is defined as the smallest denomination of a token. An amount expressed in baseUnits
     * is the amount expressed in the smallest denomination.
     * E.g: 1 unit of a token with 18 decimal places is expressed in baseUnits as 1000000000000000000
     * @param   amount      The amount of units that you would like converted to baseUnits.
     * @param   decimals    The number of decimal places the unit amount has.
     * @return  The amount in baseUnits.
     */
    static toBaseUnitAmount(amount: BigNumber | number, decimals: number): BigNumber;
    /**
     * Convert an Ether amount from ETH to Wei
     * @param ethAmount Amount of Ether to convert to wei
     * @returns Amount in wei
     */
    static toWei(ethAmount: BigNumber): BigNumber;
    private static _assertBlockParam;
    private static _assertBlockParamOrString;
    private static _normalizeTxReceiptStatus;
    /**
     * Instantiates a new Web3Wrapper.
     * @param   provider    The Web3 provider instance you would like the Web3Wrapper to use for interacting with
     *                      the backing Ethereum node.
     * @param   callAndTxnDefaults  Override Call and Txn Data defaults sent with RPC requests to the backing Ethereum node.
     * @return  An instance of the Web3Wrapper class.
     */
    constructor(supportedProvider: SupportedProvider, callAndTxnDefaults?: Partial<CallData>);
    /**
     * Get the contract defaults set to the Web3Wrapper instance
     * @return  CallAndTxnData defaults (e.g gas, gasPrice, nonce, etc...)
     */
    getContractDefaults(): Partial<CallData> | undefined;
    /**
     * Retrieve the Web3 provider
     * @return  Web3 provider instance
     */
    getProvider(): SupportedProvider;
    /**
     * Update the used Web3 provider
     * @param provider The new Web3 provider to be set
     */
    setProvider(supportedProvider: SupportedProvider): void;
    /**
     * Check whether an address is available through the backing provider. This can be
     * useful if you want to know whether a user can sign messages or transactions from
     * a given Ethereum address.
     * @param senderAddress Address to check availability for
     * @returns Whether the address is available through the provider.
     */
    isSenderAddressAvailableAsync(senderAddress: string): Promise<boolean>;
    /**
     * Fetch the backing Ethereum node's version string (e.g `MetaMask/v4.2.0`)
     * @returns Ethereum node's version string
     */
    getNodeVersionAsync(): Promise<string>;
    /**
     * Fetches the networkId of the backing Ethereum node
     * @returns The network id
     */
    getNetworkIdAsync(): Promise<number>;
    /**
     * Fetches the chainId of the backing Ethereum node
     * @returns The chain id
     */
    getChainIdAsync(): Promise<number>;
    /**
     * Fetch the current gas price.
     * For post-London hardfork chains, this will be baseFeePerGas + maxPriorityFeePerGas
     */
    getGasPriceAsync(): Promise<BigNumber>;
    /**
     * Fetch the base fee per gas for the pending block.
     */
    getBaseFeePerGasAsync(): Promise<BigNumber>;
    /**
     * Fetch the current max piority fee per gas. This is the suggested miner tip
     * to get mined in the current block.
     */
    getMaxPriorityFeePerGasAsync(): Promise<BigNumber>;
    /**
     * Retrieves the transaction receipt for a given transaction hash if found
     * @param txHash Transaction hash
     * @returns The transaction receipt, including it's status (0: failed, 1: succeeded). Returns undefined if transaction not found.
     */
    getTransactionReceiptIfExistsAsync(txHash: string): Promise<TransactionReceipt | undefined>;
    /**
     * Retrieves the transaction data for a given transaction
     * @param txHash Transaction hash
     * @returns The raw transaction data
     */
    getTransactionByHashAsync(txHash: string): Promise<Transaction>;
    /**
     * Retrieves an accounts Ether balance in wei
     * @param owner Account whose balance you wish to check
     * @param defaultBlock The block depth at which to fetch the balance (default=latest)
     * @returns Balance in wei
     */
    getBalanceInWeiAsync(owner: string, defaultBlock?: BlockParam): Promise<BigNumber>;
    /**
     * Check if a contract exists at a given address
     * @param address Address to which to check
     * @returns Whether or not contract code was found at the supplied address
     */
    doesContractExistAtAddressAsync(address: string): Promise<boolean>;
    /**
     * Gets the contract code by address
     * @param  address Address of the contract
     * @param defaultBlock Block height at which to make the call. Defaults to `latest`
     * @return Code of the contract
     */
    getContractCodeAsync(address: string, defaultBlock?: BlockParam): Promise<string>;
    /**
     * Gets the debug trace of a transaction
     * @param  txHash Hash of the transactuon to get a trace for
     * @param  traceParams Config object allowing you to specify if you need memory/storage/stack traces.
     * @return Transaction trace
     */
    getTransactionTraceAsync(txHash: string, traceParams: TraceParams): Promise<TransactionTrace>;
    /**
     * Sign a message with a specific address's private key (`eth_sign`)
     * @param address Address of signer
     * @param message Message to sign
     * @returns Signature string (might be VRS or RSV depending on the Signer)
     */
    signMessageAsync(address: string, message: string): Promise<string>;
    /**
     * Sign an EIP712 typed data message with a specific address's private key (`eth_signTypedData`)
     * @param address Address of signer
     * @param typedData Typed data message to sign
     * @returns Signature string (as RSV)
     */
    signTypedDataAsync(address: string, typedData: any): Promise<string>;
    /**
     * Fetches the latest block number
     * @returns Block number
     */
    getBlockNumberAsync(): Promise<number>;
    /**
     * Fetches the nonce for an account (transaction count for EOAs).
     * @param address Address of account.
     * @param defaultBlock Block height at which to make the call. Defaults to `latest`
     * @returns Account nonce.
     */
    getAccountNonceAsync(address: string, defaultBlock?: BlockParam): Promise<number>;
    /**
     * Fetch a specific Ethereum block without transaction data
     * @param blockParam The block you wish to fetch (blockHash, blockNumber or blockLiteral)
     * @returns The requested block without transaction data, or undefined if block was not found
     * (e.g the node isn't fully synced, there was a block re-org and the requested block was uncles, etc...)
     */
    getBlockIfExistsAsync(blockParam: string | BlockParam): Promise<BlockWithoutTransactionData | undefined>;
    /**
     * Fetch a specific Ethereum block with transaction data
     * @param blockParam The block you wish to fetch (blockHash, blockNumber or blockLiteral)
     * @returns The requested block with transaction data
     */
    getBlockWithTransactionDataAsync(blockParam: string | BlockParam): Promise<BlockWithTransactionData>;
    /**
     * Fetch a block's timestamp
     * @param blockParam The block you wish to fetch (blockHash, blockNumber or blockLiteral)
     * @returns The block's timestamp
     */
    getBlockTimestampAsync(blockParam: string | BlockParam): Promise<number>;
    /**
     * Retrieve the user addresses available through the backing provider
     * @returns Available user addresses
     */
    getAvailableAddressesAsync(): Promise<string[]>;
    /**
     * Take a snapshot of the blockchain state on a TestRPC/Ganache local node
     * @returns The snapshot id. This can be used to revert to this snapshot
     */
    takeSnapshotAsync(): Promise<number>;
    /**
     * Revert the blockchain state to a previous snapshot state on TestRPC/Ganache local node
     * @param snapshotId snapshot id to revert to
     * @returns Whether the revert was successful
     */
    revertSnapshotAsync(snapshotId: number): Promise<boolean>;
    /**
     * Mine a block on a TestRPC/Ganache local node
     */
    mineBlockAsync(): Promise<void>;
    /**
     * Increase the next blocks timestamp on TestRPC/Ganache or Geth local node.
     * Will throw if provider is neither TestRPC/Ganache or Geth.
     * @param timeDelta Amount of time to add in seconds
     */
    increaseTimeAsync(timeDelta: number): Promise<number>;
    /**
     * Retrieve smart contract logs for a given filter
     * @param filter Parameters by which to filter which logs to retrieve
     * @returns The corresponding log entries
     */
    getLogsAsync(filter: FilterObject): Promise<LogEntry[]>;
    /**
     * Calculate the estimated gas cost for a given transaction
     * @param txData Transaction data
     * @returns Estimated gas cost
     */
    estimateGasAsync(txData: Partial<TxData>): Promise<number>;
    /**
     * Generate an access list for an ethereum call and also compute the gas used.
     * @param callData Call data
     * @param defaultBlock Block height at which to make the call. Defaults to 'latest'.
     * @returns The access list and gas used.
     */
    createAccessListAsync(callData: CallData, defaultBlock?: BlockParam): Promise<TxAccessListWithGas>;
    /**
     * Call a smart contract method at a given block height
     * @param callData Call data
     * @param defaultBlock Block height at which to make the call. Defaults to `latest`
     * @returns The raw call result
     */
    callAsync(callData: CallData, defaultBlock?: BlockParam): Promise<string>;
    /**
     * Send a transaction
     * @param txData Transaction data
     * @returns Transaction hash
     */
    sendTransactionAsync(txData: TxData): Promise<string>;
    /**
     * Waits for a transaction to be mined and returns the transaction receipt.
     * Note that just because a transaction was mined does not mean it was
     * successful. You need to check the status code of the transaction receipt
     * to find out if it was successful, or use the helper method
     * awaitTransactionSuccessAsync.
     * @param   txHash            Transaction hash
     * @param   pollingIntervalMs How often (in ms) should we check if the transaction is mined.
     * @param   timeoutMs         How long (in ms) to poll for transaction mined until aborting.
     * @return  Transaction receipt with decoded log args.
     */
    awaitTransactionMinedAsync(txHash: string, pollingIntervalMs?: number, timeoutMs?: number): Promise<TransactionReceiptWithDecodedLogs>;
    /**
     * Waits for a transaction to be mined and returns the transaction receipt.
     * Unlike awaitTransactionMinedAsync, it will throw if the receipt has a
     * status that is not equal to 1. A status of 0 or null indicates that the
     * transaction was mined, but failed. See:
     * https://github.com/ethereum/wiki/wiki/JavaScript-API#web3ethgettransactionreceipt
     * @param   txHash            Transaction hash
     * @param   pollingIntervalMs How often (in ms) should we check if the transaction is mined.
     * @param   timeoutMs         How long (in ms) to poll for transaction mined until aborting.
     * @return  Transaction receipt with decoded log args.
     */
    awaitTransactionSuccessAsync(txHash: string, pollingIntervalMs?: number, timeoutMs?: number): Promise<TransactionReceiptWithDecodedLogs>;
    /**
     * Calls the 'debug_setHead' JSON RPC method, which sets the current head of
     * the local chain by block number. Note, this is a destructive action and
     * may severely damage your chain. Use with extreme caution. As of now, this
     * is only supported by Geth. It sill throw if the 'debug_setHead' method is
     * not supported.
     * @param  blockNumber The block number to reset to.
     */
    setHeadAsync(blockNumber: number): Promise<void>;
    /**
     * Sends a raw Ethereum JSON RPC payload and returns the response's `result` key
     * @param payload A partial JSON RPC payload. No need to include version, id, params (if none needed)
     * @return The contents nested under the result key of the response body
     */
    sendRawPayloadAsync<A>(payload: Partial<JSONRPCRequestPayload>): Promise<A>;
    /**
     * Returns either NodeType.Geth or NodeType.Ganache depending on the type of
     * the backing Ethereum node. Throws for any other type of node.
     */
    getNodeTypeAsync(): Promise<NodeType>;
}
//# sourceMappingURL=web3_wrapper.d.ts.map