@soma-finance/core-contracts/ISOMA.d.ts

SOMA Finance core contracts

import type { BaseContract, BigNumber, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "./common";
export declare namespace ISOMA {
    type SnapshotStruct = {
        master: PromiseOrValue<string>;
        subMaster: PromiseOrValue<string>;
        access: PromiseOrValue<string>;
        guard: PromiseOrValue<string>;
        factory: PromiseOrValue<string>;
        token: PromiseOrValue<string>;
    };
    type SnapshotStructOutput = [
        string,
        string,
        string,
        string,
        string,
        string
    ] & {
        master: string;
        subMaster: string;
        access: string;
        guard: string;
        factory: string;
        token: string;
    };
}
export interface ISOMAInterface extends utils.Interface {
    functions: {
        "__upgrade(bytes32)": FunctionFragment;
        "access()": FunctionFragment;
        "factory()": FunctionFragment;
        "guard()": FunctionFragment;
        "master()": FunctionFragment;
        "mintTo()": FunctionFragment;
        "pause()": FunctionFragment;
        "seizeTo()": FunctionFragment;
        "setMintTo(address)": FunctionFragment;
        "setSeizeTo(address)": FunctionFragment;
        "snapshot()": FunctionFragment;
        "snapshotHash()": FunctionFragment;
        "snapshotVersion()": FunctionFragment;
        "snapshots(bytes32)": FunctionFragment;
        "subMaster()": FunctionFragment;
        "token()": FunctionFragment;
        "unpause()": FunctionFragment;
        "versions(bytes32)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "__upgrade" | "access" | "factory" | "guard" | "master" | "mintTo" | "pause" | "seizeTo" | "setMintTo" | "setSeizeTo" | "snapshot" | "snapshotHash" | "snapshotVersion" | "snapshots" | "subMaster" | "token" | "unpause" | "versions"): FunctionFragment;
    encodeFunctionData(functionFragment: "__upgrade", values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "access", values?: undefined): string;
    encodeFunctionData(functionFragment: "factory", values?: undefined): string;
    encodeFunctionData(functionFragment: "guard", values?: undefined): string;
    encodeFunctionData(functionFragment: "master", values?: undefined): string;
    encodeFunctionData(functionFragment: "mintTo", values?: undefined): string;
    encodeFunctionData(functionFragment: "pause", values?: undefined): string;
    encodeFunctionData(functionFragment: "seizeTo", values?: undefined): string;
    encodeFunctionData(functionFragment: "setMintTo", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "setSeizeTo", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "snapshot", values?: undefined): string;
    encodeFunctionData(functionFragment: "snapshotHash", values?: undefined): string;
    encodeFunctionData(functionFragment: "snapshotVersion", values?: undefined): string;
    encodeFunctionData(functionFragment: "snapshots", values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "subMaster", values?: undefined): string;
    encodeFunctionData(functionFragment: "token", values?: undefined): string;
    encodeFunctionData(functionFragment: "unpause", values?: undefined): string;
    encodeFunctionData(functionFragment: "versions", values: [PromiseOrValue<BytesLike>]): string;
    decodeFunctionResult(functionFragment: "__upgrade", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "access", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "factory", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "guard", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "master", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "mintTo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "seizeTo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setMintTo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setSeizeTo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "snapshot", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "snapshotHash", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "snapshotVersion", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "snapshots", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "subMaster", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "token", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "versions", data: BytesLike): Result;
    events: {
        "MintToUpdated(address,address,address)": EventFragment;
        "SOMAUpgraded(bytes32,bytes32,bytes)": EventFragment;
        "SeizeToUpdated(address,address,address)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "MintToUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SOMAUpgraded"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SeizeToUpdated"): EventFragment;
}
export interface MintToUpdatedEventObject {
    prevMintTo: string;
    newMintTo: string;
    sender: string;
}
export declare type MintToUpdatedEvent = TypedEvent<[
    string,
    string,
    string
], MintToUpdatedEventObject>;
export declare type MintToUpdatedEventFilter = TypedEventFilter<MintToUpdatedEvent>;
export interface SOMAUpgradedEventObject {
    version: string;
    hash: string;
    snapshot: string;
}
export declare type SOMAUpgradedEvent = TypedEvent<[
    string,
    string,
    string
], SOMAUpgradedEventObject>;
export declare type SOMAUpgradedEventFilter = TypedEventFilter<SOMAUpgradedEvent>;
export interface SeizeToUpdatedEventObject {
    prevSeizeTo: string;
    newSeizeTo: string;
    sender: string;
}
export declare type SeizeToUpdatedEvent = TypedEvent<[
    string,
    string,
    string
], SeizeToUpdatedEventObject>;
export declare type SeizeToUpdatedEventFilter = TypedEventFilter<SeizeToUpdatedEvent>;
export interface ISOMA extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: ISOMAInterface;
    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
    listeners(eventName?: string): Array<Listener>;
    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
    removeAllListeners(eventName?: string): this;
    off: OnEvent<this>;
    on: OnEvent<this>;
    once: OnEvent<this>;
    removeListener: OnEvent<this>;
    functions: {
        __upgrade(version: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        access(overrides?: CallOverrides): Promise<[string]>;
        factory(overrides?: CallOverrides): Promise<[string]>;
        guard(overrides?: CallOverrides): Promise<[string]>;
        master(overrides?: CallOverrides): Promise<[string]>;
        mintTo(overrides?: CallOverrides): Promise<[string]>;
        pause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        seizeTo(overrides?: CallOverrides): Promise<[string]>;
        setMintTo(_mintTo: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setSeizeTo(_seizeTo: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        snapshot(overrides?: CallOverrides): Promise<[
            ISOMA.SnapshotStructOutput
        ] & {
            _snapshot: ISOMA.SnapshotStructOutput;
        }>;
        snapshotHash(overrides?: CallOverrides): Promise<[string]>;
        snapshotVersion(overrides?: CallOverrides): Promise<[string]>;
        snapshots(hash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string] & {
            _snapshot: string;
        }>;
        subMaster(overrides?: CallOverrides): Promise<[string]>;
        token(overrides?: CallOverrides): Promise<[string]>;
        unpause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        versions(versionOrHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string] & {
            hashOrVersion: string;
        }>;
    };
    __upgrade(version: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    access(overrides?: CallOverrides): Promise<string>;
    factory(overrides?: CallOverrides): Promise<string>;
    guard(overrides?: CallOverrides): Promise<string>;
    master(overrides?: CallOverrides): Promise<string>;
    mintTo(overrides?: CallOverrides): Promise<string>;
    pause(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    seizeTo(overrides?: CallOverrides): Promise<string>;
    setMintTo(_mintTo: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setSeizeTo(_seizeTo: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    snapshot(overrides?: CallOverrides): Promise<ISOMA.SnapshotStructOutput>;
    snapshotHash(overrides?: CallOverrides): Promise<string>;
    snapshotVersion(overrides?: CallOverrides): Promise<string>;
    snapshots(hash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
    subMaster(overrides?: CallOverrides): Promise<string>;
    token(overrides?: CallOverrides): Promise<string>;
    unpause(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    versions(versionOrHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
    callStatic: {
        __upgrade(version: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        access(overrides?: CallOverrides): Promise<string>;
        factory(overrides?: CallOverrides): Promise<string>;
        guard(overrides?: CallOverrides): Promise<string>;
        master(overrides?: CallOverrides): Promise<string>;
        mintTo(overrides?: CallOverrides): Promise<string>;
        pause(overrides?: CallOverrides): Promise<void>;
        seizeTo(overrides?: CallOverrides): Promise<string>;
        setMintTo(_mintTo: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setSeizeTo(_seizeTo: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        snapshot(overrides?: CallOverrides): Promise<ISOMA.SnapshotStructOutput>;
        snapshotHash(overrides?: CallOverrides): Promise<string>;
        snapshotVersion(overrides?: CallOverrides): Promise<string>;
        snapshots(hash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
        subMaster(overrides?: CallOverrides): Promise<string>;
        token(overrides?: CallOverrides): Promise<string>;
        unpause(overrides?: CallOverrides): Promise<void>;
        versions(versionOrHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
    };
    filters: {
        "MintToUpdated(address,address,address)"(prevMintTo?: PromiseOrValue<string> | null, newMintTo?: PromiseOrValue<string> | null, sender?: PromiseOrValue<string> | null): MintToUpdatedEventFilter;
        MintToUpdated(prevMintTo?: PromiseOrValue<string> | null, newMintTo?: PromiseOrValue<string> | null, sender?: PromiseOrValue<string> | null): MintToUpdatedEventFilter;
        "SOMAUpgraded(bytes32,bytes32,bytes)"(version?: PromiseOrValue<BytesLike> | null, hash?: PromiseOrValue<BytesLike> | null, snapshot?: null): SOMAUpgradedEventFilter;
        SOMAUpgraded(version?: PromiseOrValue<BytesLike> | null, hash?: PromiseOrValue<BytesLike> | null, snapshot?: null): SOMAUpgradedEventFilter;
        "SeizeToUpdated(address,address,address)"(prevSeizeTo?: PromiseOrValue<string> | null, newSeizeTo?: PromiseOrValue<string> | null, sender?: PromiseOrValue<string> | null): SeizeToUpdatedEventFilter;
        SeizeToUpdated(prevSeizeTo?: PromiseOrValue<string> | null, newSeizeTo?: PromiseOrValue<string> | null, sender?: PromiseOrValue<string> | null): SeizeToUpdatedEventFilter;
    };
    estimateGas: {
        __upgrade(version: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        access(overrides?: CallOverrides): Promise<BigNumber>;
        factory(overrides?: CallOverrides): Promise<BigNumber>;
        guard(overrides?: CallOverrides): Promise<BigNumber>;
        master(overrides?: CallOverrides): Promise<BigNumber>;
        mintTo(overrides?: CallOverrides): Promise<BigNumber>;
        pause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        seizeTo(overrides?: CallOverrides): Promise<BigNumber>;
        setMintTo(_mintTo: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setSeizeTo(_seizeTo: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        snapshot(overrides?: CallOverrides): Promise<BigNumber>;
        snapshotHash(overrides?: CallOverrides): Promise<BigNumber>;
        snapshotVersion(overrides?: CallOverrides): Promise<BigNumber>;
        snapshots(hash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
        subMaster(overrides?: CallOverrides): Promise<BigNumber>;
        token(overrides?: CallOverrides): Promise<BigNumber>;
        unpause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        versions(versionOrHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        __upgrade(version: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        access(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        factory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        guard(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        master(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        mintTo(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        pause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        seizeTo(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        setMintTo(_mintTo: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setSeizeTo(_seizeTo: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        snapshot(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        snapshotHash(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        snapshotVersion(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        snapshots(hash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        subMaster(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        token(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        unpause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        versions(versionOrHash: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}
//# sourceMappingURL=ISOMA.d.ts.map