raiden-ts/dist/utils/ethers.d.ts

Raiden Light Client Typescript/Javascript SDK

import type { Contract } from '@ethersproject/contracts';
import type { Filter, JsonRpcProvider, Log, Network, Provider } from '@ethersproject/providers';
import type { Observable } from 'rxjs';
import type { TypedEvent, TypedEventFilter, TypedListener } from '../contracts/common';
import { HexString } from './types';
declare const _event: unique symbol;
/**
 * A simple Log, but tagged (at typecheck-time) to indicate the logs will map to a specific
 * TypedEvent/EventTuple
 */
export interface LogWithEvent<E extends TypedEvent> extends Log {
    readonly [_event]: E;
}
declare type EventFromLog<L extends LogWithEvent<any>> = L[typeof _event];
declare type EventFromFilter<F> = F extends TypedEventFilter<infer E> ? E : never;
declare type BlockRange = {
    fromBlock: number;
    toBlock: number;
};
declare type MultiFilter = Omit<Filter, 'address'> & {
    address?: string | string[];
};
/**
 * Extract the union of TypedEventFilters for a given contract
 */
export declare type ContractFilter<C extends Contract, E extends keyof C['filters'] = keyof C['filters']> = ReturnType<C['filters'][E]>;
export declare type ContractEvent<C extends Contract, E extends keyof C['filters'] = keyof C['filters']> = EventFromFilter<ContractFilter<C, E>>;
/**
 * For given TypedEventFilters, return the tuple of arguments plus the TypedEvent as last element
 */
export declare type EventTuple<F extends TypedEvent> = Parameters<TypedListener<F>>;
export declare function getLogsByChunk$<F extends TypedEventFilter<any>>(provider: JsonRpcProvider, filter: F & BlockRange, chunk?: number, minChunk?: number): Observable<LogWithEvent<EventFromFilter<F>>>;
export declare function getLogsByChunk$(provider: JsonRpcProvider, filter: MultiFilter & BlockRange, chunk?: number, minChunk?: number): Observable<Log>;
export declare function fromEthersEvent<T>(target: JsonRpcProvider, event: string | string[]): Observable<T>;
export declare function fromEthersEvent<F extends TypedEventFilter<any>>(target: JsonRpcProvider, event: F, opts?: {
    fromBlock?: number;
    confirmations?: number | Observable<number>;
    blockNumber$?: Observable<number>;
    onPastCompleted?: (elapsedMs: number) => void;
}): Observable<LogWithEvent<EventFromFilter<F>>>;
export declare function fromEthersEvent<T extends Log>(target: JsonRpcProvider, event: Filter, opts?: {
    fromBlock?: number;
    confirmations?: number | Observable<number>;
    blockNumber$?: Observable<number>;
    onPastCompleted?: (elapsedMs: number) => void;
}): Observable<T>;
/**
 * Function to map an ethers's Provider log to a contract event tuple
 * It requires logs coming from getLogsByChunk$ or fromEthersEvent overloads which tag at
 * type-check time to which set of events the logs belong, and use that information to narrow
 * the types of the tuple events emitted
 *
 * @param contract - Contract fo parse logs for
 * @returns Function to map logs to event tuples for contract
 */
export declare function logToContractEvent<C extends Contract>(contract: C): <L extends LogWithEvent<EventFromFilter<ReturnType<C["filters"][keyof C["filters"]]>>>>(log: L) => [...EventFromLog<L> extends infer T ? T extends EventFromLog<L> ? T extends TypedEvent<any[], any> ? any[] : never : never : never, EventFromLog<L>];
/**
 * Return a network name, if known, or stringified chainId otherwise
 *
 * @param network - Network to get name from
 * @returns name or chainId as string
 */
export declare function getNetworkName(network: Network): string;
/**
 * Verify that contract has given method
 *
 * @param sighash - method to search for, as signature hash
 * @param contract - Contract-like interface
 * @param contract.address - Contract's address
 * @param contract.provider - Contract's provider
 * @returns truthy if contract has a method with given signature
 */
export declare function contractHasMethod(sighash: HexString<4>, { address, provider }: {
    address: string;
    provider: Provider;
}): Promise<boolean>;
/**
 * Fetches contract's code and parse if it has given method (by name)
 *
 * @param contract - contract instance to check
 * @param method - method name
 * @returns Observable of true, emitting a single value if successful, or erroring
 */
export declare function checkContractHasMethod$<C extends Contract>(contract: C, method: keyof C['functions'] & string): Observable<true>;
export {};