@0x/typescript-typings

constructor(transport: LedgerTransport);

transport: LedgerTransport;

getAddress: (
    path: string,
    boolDisplay?: boolean,
    boolChaincode?: boolean
) => Promise<{ publicKey: string; address: string; chainCode: string }>;

getAppConfiguration: () => Promise<{
    arbitraryDataEnabled: number;
    version: string;
}>;

signPersonalMessage: (path: string, messageHex: string) => Promise<ECSignature>;

signTransaction: (path: string, rawTxHex: string) => Promise<ECSignatureString>;

close: () => Promise<void>;

static create: () => Promise<LedgerTransport>;

close: () => Promise<void>;

static create: () => Promise<LedgerTransport>;

constructor(trie: any);

checkpoint: () => void;

clear: () => void;

commit: () => void;

del: (key: Buffer) => void;

flush: (cb: any) => void;

get: (key: Buffer) => Account;

getOrLoad: (key: Buffer, cb: any) => void;

lookup: (key: Buffer) => Account | undefined;

put: (key: Buffer, val: Account, fromTrie: boolean) => void;

revert: () => void;

warm: (addresses: string[], cb: any) => void;

constructor(env: Env, state: PStateManager, evm: EVM, common: any, gasLeft: BN);

call: (gasLimit: BN, address: Buffer, value: BN, data: Buffer) => Promise<BN>;

callCode: (
    gasLimit: BN,
    address: Buffer,
    value: BN,
    data: Buffer
) => Promise<BN>;

callDelegate: (
    gasLimit: BN,
    address: Buffer,
    value: BN,
    data: Buffer
) => Promise<BN>;

callStatic: (
    gasLimit: BN,
    address: Buffer,
    value: BN,
    data: Buffer
) => Promise<BN>;

create: (
    gasLimit: BN,
    value: BN,
    data: Buffer,
    salt: Buffer | null
) => Promise<BN>;

create2: (gasLimit: BN, value: BN, data: Buffer, salt: Buffer) => Promise<BN>;

finish: (returnData: Buffer) => void;

getAddress: () => Buffer;

getBlockCoinbase: () => BN;

getBlockDifficulty: () => BN;

getBlockGasLimit: () => BN;

getBlockHash: (num: BN) => Promise<BN>;

getBlockNumber: () => BN;

getBlockTimestamp: () => BN;

getCallData: () => Buffer;

getCallDataSize: () => BN;

getCaller: () => BN;

getCallValue: () => BN;

getChainId: () => BN;

getCode: () => Buffer;

getCodeSize: () => BN;

getExternalBalance: (address: Buffer) => Promise<BN>;

getExternalCode: (address: BN | Buffer) => Promise<Buffer>;

getExternalCodeSize: (address: BN) => Promise<BN>;

getGasLeft: () => BN;

getReturnData: () => Buffer;

getReturnDataSize: () => BN;

getSelfBalance: () => BN;

getTxGasPrice: () => BN;

getTxOrigin: () => BN;

isAccountEmpty: (address: Buffer) => Promise<boolean>;

isStatic: () => boolean;

log: (data: Buffer, numberOfTopics: number, topics: Buffer[]) => void;

refundGas: (amount: BN) => void;

revert: (returnData: Buffer) => void;

selfDestruct: (toAddress: Buffer) => Promise<void>;

storageLoad: (key: Buffer) => Promise<Buffer>;

storageStore: (key: Buffer, value: Buffer) => Promise<void>;

useGas: (amount: BN) => void;

constructor(vm: any, txContext: TxContext, block: any);

executeMessage: (message: Message) => Promise<EVMResult>;

getPrecompile: (address: Buffer) => PrecompileFunc;

runInterpreter: (message: Message, opts: InterpreterOpts) => Promise<ExecResult>;

runPrecompile: (code: PrecompileFunc, data: Buffer, gasLimit: BN) => ExecResult;

constructor();

extend: (offset: number, size: number) => void;

read: (offset: number, size: number) => Buffer;

write: (offset: number, size: number, value: Buffer) => void;

constructor(opts: any);

caller: Buffer;

code: any;

data: Buffer;

delegatecall: boolean;

depth: number;

gasLimit: BN;

isCompiled: boolean;

isStatic: boolean;

salt: Buffer;

selfdestruct: any;

to: Buffer;

value: BN;

codeAddress: () => Buffer;

constructor(wrapped: StateManager);

accountIsEmpty: (address: Buffer) => Promise<boolean>;

checkpoint: () => Promise<void>;

cleanupTouchedAccounts: () => Promise<void>;

clearContractStorage: (addr: Buffer) => Promise<void>;

commit: () => Promise<void>;

copy: () => PStateManager;

dumpStorage: (address: Buffer) => Promise<StorageDump>;

generateCanonicalGenesis: () => Promise<void>;

generateGenesis: (initState: any) => Promise<void>;

getAccount: (addr: Buffer) => Promise<Account>;

getContractCode: (addr: Buffer) => Promise<Buffer>;

getContractStorage: (addr: Buffer, key: Buffer) => Promise<any>;

getOriginalContractStorage: (addr: Buffer, key: Buffer) => Promise<any>;

getStateRoot: () => Promise<Buffer>;

hasGenesisState: () => Promise<boolean>;

putAccount: (addr: Buffer, account: Account) => Promise<void>;

putContractCode: (addr: Buffer, code: Buffer) => Promise<void>;

putContractStorage: (addr: Buffer, key: Buffer, value: Buffer) => Promise<void>;

revert: () => Promise<void>;

setStateRoot: (root: Buffer) => Promise<void>;

constructor();

dup: (position: number) => void;

length: () => number;

pop: () => BN;

popN: (num: number) => BN[];

push: (value: BN) => void;

swap: (position: number) => void;

constructor(opts: StateManagerOpts);

accountIsEmpty: (address: Buffer, cb: any) => void;

checkpoint: (cb: any) => void;

cleanupTouchedAccounts: (cb: any) => void;

clearContractStorage: (address: Buffer, cb: any) => void;

commit: (cb: any) => void;

copy: () => StateManager;

dumpStorage: (address: Buffer, cb: any) => void;

generateCanonicalGenesis: (cb: any) => void;

generateGenesis: (initState: any, cb: any) => void;

getAccount: (address: Buffer, cb: any) => void;

getContractCode: (address: Buffer, cb: any) => void;

getContractStorage: (address: Buffer, key: Buffer, cb: any) => void;

getOriginalContractStorage: (address: Buffer, key: Buffer, cb: any) => void;

getStateRoot: (cb: any) => void;

hasGenesisState: (cb: any) => void;

putAccount: (address: Buffer, account: Account, cb: any) => void;

putContractCode: (address: Buffer, value: Buffer, cb: any) => void;

putContractStorage: (
    address: Buffer,
    key: Buffer,
    value: Buffer,
    cb: any
) => void;

revert: (cb: any) => void;

setStateRoot: (stateRoot: Buffer, cb: any) => void;

touchAccount: (address: Buffer) => void;

constructor(gasPrice: Buffer, origin: Buffer);

gasPrice: Buffer;

origin: Buffer;

constructor(opts: VmOpts);

opts: VmOpts;

stateManager: StateManager;

runCall: (opts: RunCallOpts) => Promise<EVMResult>;

constructor(error: ERROR);

error: ERROR;

errorType: string;

address: Buffer;

block: any;

blockchain: Blockchain;

callData: Buffer;

caller: Buffer;

callValue: BN;

code: Buffer;

contract: Account;

depth: number;

gasPrice: Buffer;

isStatic: boolean;

origin: Buffer;

createdAddress?: Buffer;

execResult: ExecResult;

gasUsed: BN;

exceptionError?: VmError;

gas?: BN;

gasRefund?: BN;

gasUsed: BN;

logs?: any[];

returnValue: Buffer;

runState?: RunState;

selfdestruct?: { [k: string]: Buffer };

pc?: number;

(opts: PrecompileInput): ExecResult;

data: Buffer;

gasLimit: BN;

block?: any;

caller?: Buffer;

code?: Buffer;

compiled?: boolean;

data?: Buffer;

delegatecall?: boolean;

depth?: number;

gasLimit?: Buffer;

gasPrice?: Buffer;

origin?: Buffer;

salt?: Buffer;

selfdestruct?: { [k: string]: boolean };

static?: boolean;

to?: Buffer;

value?: Buffer;

gasRefund: BN;

logs: any;

returnValue?: Buffer;

selfdestruct: { [k: string]: Buffer };

code: Buffer;

eei: EEI;

highestMemCost: BN;

memory: Memory;

memoryWordCount: BN;

opCode: number;

programCounter: number;

stack: Stack;

stateManager: StateManager;

validJumps: number[];

common?: Common;

trie?: any;

[key: string]: string;

activatePrecompiles?: boolean;

allowUnlimitedContractSize?: boolean;

blockchain?: Blockchain;

chain?: string;

common?: Common;

hardfork?: string;

state?: any;

stateManager?: StateManager;

CREATE_COLLISION = 'create collision'

INTERNAL_ERROR = 'internal error'

INVALID_JUMP = 'invalid JUMP'

INVALID_OPCODE = 'invalid opcode'

OUT_OF_GAS = 'out of gas'

OUT_OF_RANGE = 'value out of range'

REVERT = 'revert'

STACK_OVERFLOW = 'stack overflow'

STACK_UNDERFLOW = 'stack underflow'

STATIC_STATE_CHANGE = 'static state change'

STOP = 'stop'

blockTime?: number;

db_path?: string;

fork?: string;

gasLimit?: number;

logger?: {
    log(msg: string): void;
};

mnemonic?: string;

network_id?: number;

networkId?: number;

port?: number;

total_accounts?: number;

unlocked_accounts?: string[];

verbose?: boolean;

vmErrorsOnRPCResponse?: boolean;

constructor(err: string | Error);

constructor();

children: React.ReactNode;

ref: RefHandler;

style: React.CSSProperties;

arrowProps: PopperArrowProps;

outOfBoundaries: boolean | null;

placement: PopperJS.Placement;

ref: RefHandler;

scheduleUpdate: () => void;

style: React.CSSProperties;