@imtbl/sdk 1.43.3 → 1.43.4

package/dist/index.d-f1471830.d.ts

@@ -0,0 +1,376 @@
+import { B as BigNumber, o as BytesLike, f as BigNumberish, p as Description, q as AccessListish, e as BlockTag, A as AccessList, T as TransactionResponse, S as Signer, P as Provider, g as TransactionRequest, j as Log, L as Listener, a as Block, b as TransactionReceipt } from './index.d-c4a4c17d.js';
+
+interface JsonFragmentType {
+    readonly name?: string;
+    readonly indexed?: boolean;
+    readonly type?: string;
+    readonly internalType?: any;
+    readonly components?: ReadonlyArray<JsonFragmentType>;
+}
+interface JsonFragment {
+    readonly name?: string;
+    readonly type?: string;
+    readonly anonymous?: boolean;
+    readonly payable?: boolean;
+    readonly constant?: boolean;
+    readonly stateMutability?: string;
+    readonly inputs?: ReadonlyArray<JsonFragmentType>;
+    readonly outputs?: ReadonlyArray<JsonFragmentType>;
+    readonly gas?: string;
+}
+declare class ParamType {
+    readonly name: string;
+    readonly type: string;
+    readonly baseType: string;
+    readonly indexed: boolean;
+    readonly components: Array<ParamType>;
+    readonly arrayLength: number;
+    readonly arrayChildren: ParamType;
+    readonly _isParamType: boolean;
+    constructor(constructorGuard: any, params: any);
+    format(format?: string): string;
+    static from(value: string | JsonFragmentType | ParamType, allowIndexed?: boolean): ParamType;
+    static fromObject(value: JsonFragmentType | ParamType): ParamType;
+    static fromString(value: string, allowIndexed?: boolean): ParamType;
+    static isParamType(value: any): value is ParamType;
+}
+declare abstract class Fragment {
+    readonly type: string;
+    readonly name: string;
+    readonly inputs: Array<ParamType>;
+    readonly _isFragment: boolean;
+    constructor(constructorGuard: any, params: any);
+    abstract format(format?: string): string;
+    static from(value: Fragment | JsonFragment | string): Fragment;
+    static fromObject(value: Fragment | JsonFragment): Fragment;
+    static fromString(value: string): Fragment;
+    static isFragment(value: any): value is Fragment;
+}
+declare class EventFragment extends Fragment {
+    readonly anonymous: boolean;
+    format(format?: string): string;
+    static from(value: EventFragment | JsonFragment | string): EventFragment;
+    static fromObject(value: JsonFragment | EventFragment): EventFragment;
+    static fromString(value: string): EventFragment;
+    static isEventFragment(value: any): value is EventFragment;
+}
+declare class ConstructorFragment extends Fragment {
+    stateMutability: string;
+    payable: boolean;
+    gas?: BigNumber;
+    format(format?: string): string;
+    static from(value: ConstructorFragment | JsonFragment | string): ConstructorFragment;
+    static fromObject(value: ConstructorFragment | JsonFragment): ConstructorFragment;
+    static fromString(value: string): ConstructorFragment;
+    static isConstructorFragment(value: any): value is ConstructorFragment;
+}
+declare class FunctionFragment extends ConstructorFragment {
+    constant: boolean;
+    outputs?: Array<ParamType>;
+    format(format?: string): string;
+    static from(value: FunctionFragment | JsonFragment | string): FunctionFragment;
+    static fromObject(value: FunctionFragment | JsonFragment): FunctionFragment;
+    static fromString(value: string): FunctionFragment;
+    static isFunctionFragment(value: any): value is FunctionFragment;
+}
+declare class ErrorFragment extends Fragment {
+    format(format?: string): string;
+    static from(value: ErrorFragment | JsonFragment | string): ErrorFragment;
+    static fromObject(value: ErrorFragment | JsonFragment): ErrorFragment;
+    static fromString(value: string): ErrorFragment;
+    static isErrorFragment(value: any): value is ErrorFragment;
+}
+
+interface Result extends ReadonlyArray<any> {
+    readonly [key: string]: any;
+}
+declare type CoerceFunc$1 = (type: string, value: any) => any;
+declare abstract class Coder {
+    readonly name: string;
+    readonly type: string;
+    readonly localName: string;
+    readonly dynamic: boolean;
+    constructor(name: string, type: string, localName: string, dynamic: boolean);
+    _throwError(message: string, value: any): void;
+    abstract encode(writer: Writer, value: any): number;
+    abstract decode(reader: Reader): any;
+    abstract defaultValue(): any;
+}
+declare class Writer {
+    readonly wordSize: number;
+    _data: Array<Uint8Array>;
+    _dataLength: number;
+    _padding: Uint8Array;
+    constructor(wordSize?: number);
+    get data(): string;
+    get length(): number;
+    _writeData(data: Uint8Array): number;
+    appendWriter(writer: Writer): number;
+    writeBytes(value: BytesLike): number;
+    _getValue(value: BigNumberish): Uint8Array;
+    writeValue(value: BigNumberish): number;
+    writeUpdatableValue(): (value: BigNumberish) => void;
+}
+declare class Reader {
+    readonly wordSize: number;
+    readonly allowLoose: boolean;
+    readonly _data: Uint8Array;
+    readonly _coerceFunc: CoerceFunc$1;
+    _offset: number;
+    constructor(data: BytesLike, wordSize?: number, coerceFunc?: CoerceFunc$1, allowLoose?: boolean);
+    get data(): string;
+    get consumed(): number;
+    static coerce(name: string, value: any): any;
+    coerce(name: string, value: any): any;
+    _peekBytes(offset: number, length: number, loose?: boolean): Uint8Array;
+    subReader(offset: number): Reader;
+    readBytes(length: number, loose?: boolean): Uint8Array;
+    readValue(): BigNumber;
+}
+
+declare type CoerceFunc = (type: string, value: any) => any;
+declare class AbiCoder {
+    readonly coerceFunc: CoerceFunc;
+    constructor(coerceFunc?: CoerceFunc);
+    _getCoder(param: ParamType): Coder;
+    _getWordSize(): number;
+    _getReader(data: Uint8Array, allowLoose?: boolean): Reader;
+    _getWriter(): Writer;
+    getDefaultValue(types: ReadonlyArray<string | ParamType>): Result;
+    encode(types: ReadonlyArray<string | ParamType>, values: ReadonlyArray<any>): string;
+    decode(types: ReadonlyArray<string | ParamType>, data: BytesLike, loose?: boolean): Result;
+}
+
+declare class LogDescription extends Description<LogDescription> {
+    readonly eventFragment: EventFragment;
+    readonly name: string;
+    readonly signature: string;
+    readonly topic: string;
+    readonly args: Result;
+}
+declare class TransactionDescription extends Description<TransactionDescription> {
+    readonly functionFragment: FunctionFragment;
+    readonly name: string;
+    readonly args: Result;
+    readonly signature: string;
+    readonly sighash: string;
+    readonly value: BigNumber;
+}
+declare class ErrorDescription extends Description<ErrorDescription> {
+    readonly errorFragment: ErrorFragment;
+    readonly name: string;
+    readonly args: Result;
+    readonly signature: string;
+    readonly sighash: string;
+}
+declare class Indexed extends Description<Indexed> {
+    readonly hash: string;
+    readonly _isIndexed: boolean;
+    static isIndexed(value: any): value is Indexed;
+}
+declare class Interface {
+    readonly fragments: ReadonlyArray<Fragment>;
+    readonly errors: {
+        [name: string]: ErrorFragment;
+    };
+    readonly events: {
+        [name: string]: EventFragment;
+    };
+    readonly functions: {
+        [name: string]: FunctionFragment;
+    };
+    readonly structs: {
+        [name: string]: any;
+    };
+    readonly deploy: ConstructorFragment;
+    readonly _abiCoder: AbiCoder;
+    readonly _isInterface: boolean;
+    constructor(fragments: string | ReadonlyArray<Fragment | JsonFragment | string>);
+    format(format?: string): string | Array<string>;
+    static getAbiCoder(): AbiCoder;
+    static getAddress(address: string): string;
+    static getSighash(fragment: ErrorFragment | FunctionFragment): string;
+    static getEventTopic(eventFragment: EventFragment): string;
+    getFunction(nameOrSignatureOrSighash: string): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: string): EventFragment;
+    getError(nameOrSignatureOrSighash: string): ErrorFragment;
+    getSighash(fragment: ErrorFragment | FunctionFragment | string): string;
+    getEventTopic(eventFragment: EventFragment | string): string;
+    _decodeParams(params: ReadonlyArray<ParamType>, data: BytesLike): Result;
+    _encodeParams(params: ReadonlyArray<ParamType>, values: ReadonlyArray<any>): string;
+    encodeDeploy(values?: ReadonlyArray<any>): string;
+    decodeErrorResult(fragment: ErrorFragment | string, data: BytesLike): Result;
+    encodeErrorResult(fragment: ErrorFragment | string, values?: ReadonlyArray<any>): string;
+    decodeFunctionData(functionFragment: FunctionFragment | string, data: BytesLike): Result;
+    encodeFunctionData(functionFragment: FunctionFragment | string, values?: ReadonlyArray<any>): string;
+    decodeFunctionResult(functionFragment: FunctionFragment | string, data: BytesLike): Result;
+    encodeFunctionResult(functionFragment: FunctionFragment | string, values?: ReadonlyArray<any>): string;
+    encodeFilterTopics(eventFragment: EventFragment | string, values: ReadonlyArray<any>): Array<string | Array<string>>;
+    encodeEventLog(eventFragment: EventFragment | string, values: ReadonlyArray<any>): {
+        data: string;
+        topics: Array<string>;
+    };
+    decodeEventLog(eventFragment: EventFragment | string, data: BytesLike, topics?: ReadonlyArray<string>): Result;
+    parseTransaction(tx: {
+        data: string;
+        value?: BigNumberish;
+    }): TransactionDescription;
+    parseLog(log: {
+        topics: Array<string>;
+        data: string;
+    }): LogDescription;
+    parseError(data: BytesLike): ErrorDescription;
+    static isInterface(value: any): value is Interface;
+}
+
+interface Overrides {
+    gasLimit?: BigNumberish | Promise<BigNumberish>;
+    gasPrice?: BigNumberish | Promise<BigNumberish>;
+    maxFeePerGas?: BigNumberish | Promise<BigNumberish>;
+    maxPriorityFeePerGas?: BigNumberish | Promise<BigNumberish>;
+    nonce?: BigNumberish | Promise<BigNumberish>;
+    type?: number;
+    accessList?: AccessListish;
+    customData?: Record<string, any>;
+    ccipReadEnabled?: boolean;
+}
+interface PayableOverrides extends Overrides {
+    value?: BigNumberish | Promise<BigNumberish>;
+}
+interface CallOverrides extends PayableOverrides {
+    blockTag?: BlockTag | Promise<BlockTag>;
+    from?: string | Promise<string>;
+}
+interface PopulatedTransaction {
+    to?: string;
+    from?: string;
+    nonce?: number;
+    gasLimit?: BigNumber;
+    gasPrice?: BigNumber;
+    data?: string;
+    value?: BigNumber;
+    chainId?: number;
+    type?: number;
+    accessList?: AccessList;
+    maxFeePerGas?: BigNumber;
+    maxPriorityFeePerGas?: BigNumber;
+    customData?: Record<string, any>;
+    ccipReadEnabled?: boolean;
+}
+declare type EventFilter = {
+    address?: string;
+    topics?: Array<string | Array<string>>;
+};
+declare type ContractFunction<T = any> = (...args: Array<any>) => Promise<T>;
+interface Event extends Log {
+    event?: string;
+    eventSignature?: string;
+    args?: Result;
+    decodeError?: Error;
+    decode?: (data: string, topics?: Array<string>) => any;
+    removeListener: () => void;
+    getBlock: () => Promise<Block>;
+    getTransaction: () => Promise<TransactionResponse>;
+    getTransactionReceipt: () => Promise<TransactionReceipt>;
+}
+interface ContractReceipt extends TransactionReceipt {
+    events?: Array<Event>;
+}
+interface ContractTransaction extends TransactionResponse {
+    wait(confirmations?: number): Promise<ContractReceipt>;
+}
+declare class RunningEvent {
+    readonly tag: string;
+    readonly filter: EventFilter;
+    private _listeners;
+    constructor(tag: string, filter: EventFilter);
+    addListener(listener: Listener, once: boolean): void;
+    removeListener(listener: Listener): void;
+    removeAllListeners(): void;
+    listeners(): Array<Listener>;
+    listenerCount(): number;
+    run(args: Array<any>): number;
+    prepareEvent(event: Event): void;
+    getEmit(event: Event): Array<any>;
+}
+declare type ContractInterface = string | ReadonlyArray<Fragment | JsonFragment | string> | Interface;
+declare class BaseContract {
+    readonly address: string;
+    readonly interface: Interface;
+    readonly signer: Signer;
+    readonly provider: Provider;
+    readonly functions: {
+        [name: string]: ContractFunction;
+    };
+    readonly callStatic: {
+        [name: string]: ContractFunction;
+    };
+    readonly estimateGas: {
+        [name: string]: ContractFunction<BigNumber>;
+    };
+    readonly populateTransaction: {
+        [name: string]: ContractFunction<PopulatedTransaction>;
+    };
+    readonly filters: {
+        [name: string]: (...args: Array<any>) => EventFilter;
+    };
+    readonly resolvedAddress: Promise<string>;
+    readonly deployTransaction: TransactionResponse;
+    _deployedPromise: Promise<Contract>;
+    _runningEvents: {
+        [eventTag: string]: RunningEvent;
+    };
+    _wrappedEmits: {
+        [eventTag: string]: (...args: Array<any>) => void;
+    };
+    constructor(addressOrName: string, contractInterface: ContractInterface, signerOrProvider?: Signer | Provider);
+    static getContractAddress(transaction: {
+        from: string;
+        nonce: BigNumberish;
+    }): string;
+    static getInterface(contractInterface: ContractInterface): Interface;
+    deployed(): Promise<Contract>;
+    _deployed(blockTag?: BlockTag): Promise<Contract>;
+    fallback(overrides?: TransactionRequest): Promise<TransactionResponse>;
+    connect(signerOrProvider: Signer | Provider | string): Contract;
+    attach(addressOrName: string): Contract;
+    static isIndexed(value: any): value is Indexed;
+    private _normalizeRunningEvent;
+    private _getRunningEvent;
+    _checkRunningEvents(runningEvent: RunningEvent): void;
+    _wrapEvent(runningEvent: RunningEvent, log: Log, listener: Listener): Event;
+    private _addEventListener;
+    queryFilter(event: EventFilter | string, fromBlockOrBlockhash?: BlockTag | string, toBlock?: BlockTag): Promise<Array<Event>>;
+    on(event: EventFilter | string, listener: Listener): this;
+    once(event: EventFilter | string, listener: Listener): this;
+    emit(eventName: EventFilter | string, ...args: Array<any>): boolean;
+    listenerCount(eventName?: EventFilter | string): number;
+    listeners(eventName?: EventFilter | string): Array<Listener>;
+    removeAllListeners(eventName?: EventFilter | string): this;
+    off(eventName: EventFilter | string, listener: Listener): this;
+    removeListener(eventName: EventFilter | string, listener: Listener): this;
+}
+declare class Contract extends BaseContract {
+    readonly [key: string]: ContractFunction | any;
+}
+declare class ContractFactory {
+    readonly interface: Interface;
+    readonly bytecode: string;
+    readonly signer: Signer;
+    constructor(contractInterface: ContractInterface, bytecode: BytesLike | {
+        object: string;
+    }, signer?: Signer);
+    getDeployTransaction(...args: Array<any>): TransactionRequest;
+    deploy(...args: Array<any>): Promise<Contract>;
+    attach(address: string): Contract;
+    connect(signer: Signer): ContractFactory;
+    static fromSolidity(compilerOutput: any, signer?: Signer): ContractFactory;
+    static getInterface(contractInterface: ContractInterface): Interface;
+    static getContractAddress(tx: {
+        from: string;
+        nonce: BytesLike | BigNumber | number;
+    }): string;
+    static getContract(address: string, contractInterface: ContractInterface, signer?: Signer): Contract;
+}
+
+export { BaseContract as B, CallOverrides as C, Event as E, FunctionFragment as F, Interface as I, Overrides as O, PopulatedTransaction as P, Result as R, EventFilter as a, EventFragment as b, ContractTransaction as c, PayableOverrides as d, ContractFactory as e };