web3-typescript-typings

public constructor(provider?: Web3.Provider);

currentProvider: Web3.Provider;

eth: Web3.EthApi;

net: Web3.NetApi;

personal: Web3.PersonalApi;

static providers: typeof providers;

version: Web3.VersionApi;

fromAscii: (ascii: string, padding?: number) => string;

fromDecimal: (value: number | string) => string;

fromWei: {
    (value: number | string, unit: Web3.Unit): string;
    (value: BigNumber.BigNumber, unit: Web3.Unit): BigNumber.BigNumber;
};

isAddress: (address: string) => boolean;

isChecksumAddress: (address: string) => boolean;

isConnected: () => boolean;

reset: (keepIsSyncing: boolean) => void;

setProvider: (provider: Web3.Provider) => void;

sha3: (value: string, options?: Web3.Sha3Options) => string;

toAscii: (hex: string) => string;

toBigNumber: (value: number | string) => BigNumber.BigNumber;

toDecimal: (hex: string) => number;

toHex: (data: MixedData) => string;

toWei: {
    (amount: number | string, unit: Web3.Unit): string;
    (amount: BigNumber.BigNumber, unit: Web3.Unit): BigNumber.BigNumber;
};

difficulty: BigNumber.BigNumber;

extraData: string;

gasLimit: number;

gasUsed: number;

hash: string | null;

logsBloom: string | null;

miner: string;

nonce: string | null;

number: number | null;

parentHash: string;

sha3Uncles: string;

size: number;

stateRoot: string;

timestamp: number;

totalDifficulty: BigNumber.BigNumber;

transactionsRoot: string;

uncles: string[];

transactions: string[];

transactions: Transaction[];

from?: string;

data?: string;

gas?: number | string | BigNumber.BigNumber;

gasPrice?: number | string | BigNumber.BigNumber;

nonce?: number;

to?: string;

value?: number | string | BigNumber.BigNumber;

inputs: DataItem[];

payable: boolean;

stateMutability: ConstructorStateMutability;

type: AbiType.Constructor;

new: (...args: any[]) => A;

at: (address: string) => A;

getData: (...args: any[]) => string;

abi: Web3.ContractAbi;

address: string;

[name: string]: any;

components: DataItem[];

name: string;

type: string;

args: A;

event: string;

removed: boolean;

accounts: string[];

blockNumber: number;

coinbase: string;

compile: {
    solidity(
        sourceString: string,
        cb?: (err: Error, result: any) => void
    ): object;
};

defaultAccount?: string;

defaultBlock: Web3.BlockParam;

gasPrice: BigNumber.BigNumber;

hashrate: number;

mining: boolean;

syncing: Web3.SyncingResult;

call: {
    (callData: Web3.CallData): string;
    (callData: CallData, callback: (err: Error, result: string) => void): void;
};

contract: (abi: Web3.AbiDefinition[]) => Web3.Contract<any>;

estimateGas: {
    (callData: Web3.CallData): number;
    (callData: CallData, callback: (err: Error, gas: number) => void): void;
};

filter: (value: string | Web3.FilterObject) => Web3.FilterResult;

getAccounts: (cd: (err: Error, accounts: string[]) => void) => void;

getBalance: {
    (addressHexString: string): BigNumber.BigNumber;
    (
        addressHexString: string,
        callback: (err: Error, result: BigNumber.BigNumber) => void
    ): void;
};

getBlock: {
    (
        hashStringOrBlockNumber: string | Web3.BlockParam
    ): Web3.BlockWithoutTransactionData;
    (
        hashStringOrBlockNumber: string | number,
        callback: (err: Error, blockObj: BlockWithoutTransactionData) => void
    ): void;
    (
        hashStringOrBlockNumber: string | number,
        returnTransactionObjects: true
    ): BlockWithTransactionData;
    (
        hashStringOrBlockNumber: string | number,
        returnTransactionObjects: true,
        callback: (err: Error, blockObj: BlockWithTransactionData) => void
    ): void;
};

getBlockNumber: (callback: (err: Error, blockNumber: number) => void) => void;

getBlockTransactionCount: {
    (hashStringOrBlockNumber: string | Web3.BlockParam): number;
    (
        hashStringOrBlockNumber: string | number,
        callback: (err: Error, blockTransactionCount: number) => void
    ): void;
};

getCode: {
    (addressHexString: string): string;
    (
        addressHexString: string,
        callback: (err: Error, code: string) => void
    ): void;
};

getGasPrice: (cd: (err: Error, gasPrice: BigNumber.BigNumber) => void) => void;

getHashrate: (cd: (err: Error, hashrate: number) => void) => void;

getMining: (cd: (err: Error, mining: boolean) => void) => void;

getStorageAt: {
    (address: string, position: number): string;
    (
        address: string,
        position: number,
        callback: (err: Error, storage: string) => void
    ): void;
};

getSyncing: (cd: (err: Error, syncing: Web3.SyncingResult) => void) => void;

getTransaction: {
    (transactionHash: string): Web3.Transaction;
    (
        transactionHash: string,
        callback: (err: Error, transaction: Transaction) => void
    ): void;
};

getTransactionCount: {
    (address: string): number;
    (address: string, callback: (err: Error, count: number) => void): void;
};

getTransactionFromBlock: {
    (
        hashStringOrBlockNumber: string | Web3.BlockParam,
        indexNumber: number
    ): Web3.Transaction;
    (
        hashStringOrBlockNumber: string | number,
        indexNumber: number,
        callback: (err: Error, transaction: Transaction) => void
    ): void;
};

getTransactionReceipt: {
    (txHash: string): Web3.TransactionReceipt | null;
    (
        txHash: string,
        callback: (err: Error, receipt: TransactionReceipt) => void
    ): void;
};

getUncle: {
    (
        hashStringOrBlockNumber: string | Web3.BlockParam,
        uncleNumber: number
    ): Web3.BlockWithoutTransactionData;
    (
        hashStringOrBlockNumber: string | number,
        uncleNumber: number,
        callback: (err: Error, uncle: BlockWithoutTransactionData) => void
    ): void;
};

isSyncing: (
    cb: (err: Error, isSyncing: boolean, syncingState: Web3.SyncingState) => void
) => Web3.IsSyncing;

sendRawTransaction: {
    (rawTxData: string): string;
    (rawTxData: string, callback: (err: Error, value: string) => void): void;
};

sendTransaction: {
    (txData: Web3.TxData): string;
    (txData: TxData, callback: (err: Error, value: string) => void): void;
};

sign: {
    (address: string, data: string): string;
    (
        address: string,
        data: string,
        callback: (err: Error, signature: string) => void
    ): void;
};

anonymous: boolean;

inputs: EventParameter[];

name: string;

type: AbiType.Event;

indexed: boolean;

payable: boolean;

type: AbiType.Fallback;

address?: string;

fromBlock?: number | string;

toBlock?: number | string;

topics?: LogTopic[];

get: (callback: () => void) => void;

stopWatching: (callback?: () => void) => void;

watch: (callback: (err: Error, result: LogEntryEvent) => void) => void;

addCallback: (
    cb: (err: Error, isSyncing: boolean, syncingState: SyncingState) => void
) => void;

stopWatching: () => void;

id: number;

jsonrpc: string;

method: string;

params: any[];

id: number;

jsonrpc: string;

result: any;

address: string;

blockHash: string | null;

blockNumber: number | null;

data: string;

logIndex: number | null;

topics: string[];

transactionHash: string;

transactionIndex: number | null;

removed: boolean;

constant: boolean;

inputs: DataItem[];

name: string;

outputs: DataItem[];

payable: boolean;

stateMutability: StateMutability;

type: AbiType.Function;

listening: boolean;

peerCount: number;

getListening: (cd: (err: Error, listening: boolean) => void) => void;

getPeerCount: (cd: (err: Error, peerCount: number) => void) => void;

listAccounts: string[] | undefined;

lockAccount: (address: string) => boolean;

newAccount: (password?: string) => string;

sign: {
    (message: string, account: string, password: string): string;
    (
        hexMessage: string,
        account: string,
        callback: (error: Error, signature: string) => void
    ): void;
};

unlockAccount: (
    address: string,
    password?: string,
    duration?: number
) => boolean;

sendAsync: (
    payload: JSONRPCRequestPayload,
    callback: (err: Error, result: JSONRPCResponsePayload) => void
) => void;

encoding: 'hex';

depth: number;

error: string;

gas: number;

gasCost: number;

memory: string[];

op: OpCode;

pc: number;

stack: string[];

storage: { [location: string]: string };

currentBlock: number;

highestBlock: number;

startingBlock: number;

blockHash: string | null;

blockNumber: number | null;

from: string;

gas: number;

gasPrice: BigNumber.BigNumber;

hash: string;

input: string;

nonce: number;

to: string | null;

transactionIndex: number | null;

value: BigNumber.BigNumber;

blockHash: string;

blockNumber: number;

contractAddress: string | null;

cumulativeGasUsed: number;

from: string;

gasUsed: number;

logs: LogEntry[];

status: null | string | 0 | 1;

to: string;

transactionHash: string;

transactionIndex: number;

gas: number;

returnValue: any;

structLogs: StructLog[];

from: string;

api: string;

ethereum: string;

network: string;

node: string;

whisper: string;

getEthereum: (cd: (err: Error, ethereum: string) => void) => void;

getNetwork: (cd: (err: Error, networkId: string) => void) => void;

getNode: (cd: (err: Error, nodeVersion: string) => void) => void;

getWhisper: (cd: (err: Error, whisper: string) => void) => void;

Constructor = 'constructor'

Event = 'event'

Fallback = 'fallback'

Function = 'function'