@q-dev/gdk-sdk/lib/ethers-contracts/DAOVault.d.ts

Typescript Library to interact with GDK Contracts

import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, 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 } from "./common";
export declare namespace IDAOVault {
    type TomeLockInfoStruct = {
        withdrawalAmount: BigNumberish;
        lockedAmount: BigNumberish;
        unlockTime: BigNumberish;
    };
    type TomeLockInfoStructOutput = [BigNumber, BigNumber, BigNumber] & {
        withdrawalAmount: BigNumber;
        lockedAmount: BigNumber;
        unlockTime: BigNumber;
    };
    type ConstitutionDataInfoStruct = {
        isSigned: boolean;
        signedAt: BigNumberish;
    };
    type ConstitutionDataInfoStructOutput = [boolean, BigNumber] & {
        isSigned: boolean;
        signedAt: BigNumber;
    };
}
export declare namespace PriorityQueue {
    type QueueStruct = {
        _values: BytesLike[];
        _priorities: BigNumberish[];
    };
    type QueueStructOutput = [string[], BigNumber[]] & {
        _values: string[];
        _priorities: BigNumber[];
    };
}
export interface DAOVaultInterface extends utils.Interface {
    functions: {
        "CONNECTED_DAO_REGISTRY()": FunctionFragment;
        "CONSTITUTION_SIGN_TYPEHASH()": FunctionFragment;
        "MAX_LOCKED_TIME()": FunctionFragment;
        "authorizeBySBT(address)": FunctionFragment;
        "depositERC20(address,uint256)": FunctionFragment;
        "depositNFT(address,uint256)": FunctionFragment;
        "depositNative()": FunctionFragment;
        "eip712Domain()": FunctionFragment;
        "getConstitutionSignHash(address)": FunctionFragment;
        "getInjector()": FunctionFragment;
        "getTimeLockInfo(address,address)": FunctionFragment;
        "getTokenSupply(address)": FunctionFragment;
        "getUserConstitutionData(address)": FunctionFragment;
        "getUserNFTs(address,address)": FunctionFragment;
        "getUserTokens(address)": FunctionFragment;
        "getUserVotingPower(address,address)": FunctionFragment;
        "implementation()": FunctionFragment;
        "isAuthorizedBySBT(address,address)": FunctionFragment;
        "isSupportedNFT(address)": FunctionFragment;
        "isSupportedSBT(address)": FunctionFragment;
        "lock(address,address,uint256,uint256)": FunctionFragment;
        "lockAndGetUserVotingPower(address,address,uint256)": FunctionFragment;
        "lockedTokens(address,address)": FunctionFragment;
        "permissionManager()": FunctionFragment;
        "proxiableUUID()": FunctionFragment;
        "revokeSBTAuthorization(address)": FunctionFragment;
        "setDependencies(address,bytes)": FunctionFragment;
        "setInjector(address)": FunctionFragment;
        "signConstitution(address,bytes)": FunctionFragment;
        "signEIP712Constitution(address,bytes)": FunctionFragment;
        "tokenBalance(address)": FunctionFragment;
        "upgradeTo(address)": FunctionFragment;
        "upgradeToAndCall(address,bytes)": FunctionFragment;
        "userTokenBalance(address,address)": FunctionFragment;
        "withdrawERC20(address,uint256)": FunctionFragment;
        "withdrawNFT(address,uint256)": FunctionFragment;
        "withdrawNative(uint256)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "CONNECTED_DAO_REGISTRY" | "CONSTITUTION_SIGN_TYPEHASH" | "MAX_LOCKED_TIME" | "authorizeBySBT" | "depositERC20" | "depositNFT" | "depositNative" | "eip712Domain" | "getConstitutionSignHash" | "getInjector" | "getTimeLockInfo" | "getTokenSupply" | "getUserConstitutionData" | "getUserNFTs" | "getUserTokens" | "getUserVotingPower" | "implementation" | "isAuthorizedBySBT" | "isSupportedNFT" | "isSupportedSBT" | "lock" | "lockAndGetUserVotingPower" | "lockedTokens" | "permissionManager" | "proxiableUUID" | "revokeSBTAuthorization" | "setDependencies" | "setInjector" | "signConstitution" | "signEIP712Constitution" | "tokenBalance" | "upgradeTo" | "upgradeToAndCall" | "userTokenBalance" | "withdrawERC20" | "withdrawNFT" | "withdrawNative"): FunctionFragment;
    encodeFunctionData(functionFragment: "CONNECTED_DAO_REGISTRY", values?: undefined): string;
    encodeFunctionData(functionFragment: "CONSTITUTION_SIGN_TYPEHASH", values?: undefined): string;
    encodeFunctionData(functionFragment: "MAX_LOCKED_TIME", values?: undefined): string;
    encodeFunctionData(functionFragment: "authorizeBySBT", values: [string]): string;
    encodeFunctionData(functionFragment: "depositERC20", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "depositNFT", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "depositNative", values?: undefined): string;
    encodeFunctionData(functionFragment: "eip712Domain", values?: undefined): string;
    encodeFunctionData(functionFragment: "getConstitutionSignHash", values: [string]): string;
    encodeFunctionData(functionFragment: "getInjector", values?: undefined): string;
    encodeFunctionData(functionFragment: "getTimeLockInfo", values: [string, string]): string;
    encodeFunctionData(functionFragment: "getTokenSupply", values: [string]): string;
    encodeFunctionData(functionFragment: "getUserConstitutionData", values: [string]): string;
    encodeFunctionData(functionFragment: "getUserNFTs", values: [string, string]): string;
    encodeFunctionData(functionFragment: "getUserTokens", values: [string]): string;
    encodeFunctionData(functionFragment: "getUserVotingPower", values: [string, string]): string;
    encodeFunctionData(functionFragment: "implementation", values?: undefined): string;
    encodeFunctionData(functionFragment: "isAuthorizedBySBT", values: [string, string]): string;
    encodeFunctionData(functionFragment: "isSupportedNFT", values: [string]): string;
    encodeFunctionData(functionFragment: "isSupportedSBT", values: [string]): string;
    encodeFunctionData(functionFragment: "lock", values: [string, string, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "lockAndGetUserVotingPower", values: [string, string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "lockedTokens", values: [string, string]): string;
    encodeFunctionData(functionFragment: "permissionManager", values?: undefined): string;
    encodeFunctionData(functionFragment: "proxiableUUID", values?: undefined): string;
    encodeFunctionData(functionFragment: "revokeSBTAuthorization", values: [string]): string;
    encodeFunctionData(functionFragment: "setDependencies", values: [string, BytesLike]): string;
    encodeFunctionData(functionFragment: "setInjector", values: [string]): string;
    encodeFunctionData(functionFragment: "signConstitution", values: [string, BytesLike]): string;
    encodeFunctionData(functionFragment: "signEIP712Constitution", values: [string, BytesLike]): string;
    encodeFunctionData(functionFragment: "tokenBalance", values: [string]): string;
    encodeFunctionData(functionFragment: "upgradeTo", values: [string]): string;
    encodeFunctionData(functionFragment: "upgradeToAndCall", values: [string, BytesLike]): string;
    encodeFunctionData(functionFragment: "userTokenBalance", values: [string, string]): string;
    encodeFunctionData(functionFragment: "withdrawERC20", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "withdrawNFT", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "withdrawNative", values: [BigNumberish]): string;
    decodeFunctionResult(functionFragment: "CONNECTED_DAO_REGISTRY", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "CONSTITUTION_SIGN_TYPEHASH", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MAX_LOCKED_TIME", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "authorizeBySBT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "depositERC20", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "depositNFT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "depositNative", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "eip712Domain", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getConstitutionSignHash", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getInjector", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getTimeLockInfo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getTokenSupply", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getUserConstitutionData", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getUserNFTs", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getUserTokens", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getUserVotingPower", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "implementation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isAuthorizedBySBT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isSupportedNFT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isSupportedSBT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lock", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lockAndGetUserVotingPower", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lockedTokens", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "permissionManager", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "proxiableUUID", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "revokeSBTAuthorization", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setDependencies", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setInjector", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "signConstitution", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "signEIP712Constitution", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "tokenBalance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "upgradeToAndCall", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "userTokenBalance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawERC20", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawNFT", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawNative", data: BytesLike): Result;
    events: {
        "AdminChanged(address,address)": EventFragment;
        "AuthenticatedBySBT(address,address)": EventFragment;
        "AuthorizedBySBT(address,address)": EventFragment;
        "BeaconUpgraded(address)": EventFragment;
        "ConstitutionSigned(address)": EventFragment;
        "EIP712DomainChanged()": EventFragment;
        "Initialized(uint8)": EventFragment;
        "NFTDeposited(address,address,uint256)": EventFragment;
        "NFTLocked(address,address,uint256,uint256)": EventFragment;
        "NFTWithdrew(address,address,uint256)": EventFragment;
        "SBTAuthorizationRevoked(address,address)": EventFragment;
        "TokensDeposited(address,address,uint256)": EventFragment;
        "TokensLocked(address,address,uint256,uint256)": EventFragment;
        "TokensWithdrew(address,address,uint256)": EventFragment;
        "Upgraded(address)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "AuthenticatedBySBT"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "AuthorizedBySBT"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ConstitutionSigned"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "EIP712DomainChanged"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "NFTDeposited"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "NFTLocked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "NFTWithdrew"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SBTAuthorizationRevoked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TokensDeposited"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TokensLocked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TokensWithdrew"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment;
}
export interface AdminChangedEventObject {
    previousAdmin: string;
    newAdmin: string;
}
export type AdminChangedEvent = TypedEvent<[
    string,
    string
], AdminChangedEventObject>;
export type AdminChangedEventFilter = TypedEventFilter<AdminChangedEvent>;
export interface AuthenticatedBySBTEventObject {
    tokenAddress: string;
    sender: string;
}
export type AuthenticatedBySBTEvent = TypedEvent<[
    string,
    string
], AuthenticatedBySBTEventObject>;
export type AuthenticatedBySBTEventFilter = TypedEventFilter<AuthenticatedBySBTEvent>;
export interface AuthorizedBySBTEventObject {
    tokenAddress: string;
    sender: string;
}
export type AuthorizedBySBTEvent = TypedEvent<[
    string,
    string
], AuthorizedBySBTEventObject>;
export type AuthorizedBySBTEventFilter = TypedEventFilter<AuthorizedBySBTEvent>;
export interface BeaconUpgradedEventObject {
    beacon: string;
}
export type BeaconUpgradedEvent = TypedEvent<[
    string
], BeaconUpgradedEventObject>;
export type BeaconUpgradedEventFilter = TypedEventFilter<BeaconUpgradedEvent>;
export interface ConstitutionSignedEventObject {
    user: string;
}
export type ConstitutionSignedEvent = TypedEvent<[
    string
], ConstitutionSignedEventObject>;
export type ConstitutionSignedEventFilter = TypedEventFilter<ConstitutionSignedEvent>;
export interface EIP712DomainChangedEventObject {
}
export type EIP712DomainChangedEvent = TypedEvent<[
], EIP712DomainChangedEventObject>;
export type EIP712DomainChangedEventFilter = TypedEventFilter<EIP712DomainChangedEvent>;
export interface InitializedEventObject {
    version: number;
}
export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;
export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
export interface NFTDepositedEventObject {
    tokenAddress: string;
    sender: string;
    tokenId: BigNumber;
}
export type NFTDepositedEvent = TypedEvent<[
    string,
    string,
    BigNumber
], NFTDepositedEventObject>;
export type NFTDepositedEventFilter = TypedEventFilter<NFTDepositedEvent>;
export interface NFTLockedEventObject {
    tokenAddress: string;
    sender: string;
    tokenId: BigNumber;
    unlockTime: BigNumber;
}
export type NFTLockedEvent = TypedEvent<[
    string,
    string,
    BigNumber,
    BigNumber
], NFTLockedEventObject>;
export type NFTLockedEventFilter = TypedEventFilter<NFTLockedEvent>;
export interface NFTWithdrewEventObject {
    tokenAddress: string;
    sender: string;
    tokenId: BigNumber;
}
export type NFTWithdrewEvent = TypedEvent<[
    string,
    string,
    BigNumber
], NFTWithdrewEventObject>;
export type NFTWithdrewEventFilter = TypedEventFilter<NFTWithdrewEvent>;
export interface SBTAuthorizationRevokedEventObject {
    tokenAddress: string;
    sender: string;
}
export type SBTAuthorizationRevokedEvent = TypedEvent<[
    string,
    string
], SBTAuthorizationRevokedEventObject>;
export type SBTAuthorizationRevokedEventFilter = TypedEventFilter<SBTAuthorizationRevokedEvent>;
export interface TokensDepositedEventObject {
    tokenAddress: string;
    sender: string;
    amount: BigNumber;
}
export type TokensDepositedEvent = TypedEvent<[
    string,
    string,
    BigNumber
], TokensDepositedEventObject>;
export type TokensDepositedEventFilter = TypedEventFilter<TokensDepositedEvent>;
export interface TokensLockedEventObject {
    tokenAddress: string;
    sender: string;
    amount: BigNumber;
    unlockTime: BigNumber;
}
export type TokensLockedEvent = TypedEvent<[
    string,
    string,
    BigNumber,
    BigNumber
], TokensLockedEventObject>;
export type TokensLockedEventFilter = TypedEventFilter<TokensLockedEvent>;
export interface TokensWithdrewEventObject {
    tokenAddress: string;
    sender: string;
    amount: BigNumber;
}
export type TokensWithdrewEvent = TypedEvent<[
    string,
    string,
    BigNumber
], TokensWithdrewEventObject>;
export type TokensWithdrewEventFilter = TypedEventFilter<TokensWithdrewEvent>;
export interface UpgradedEventObject {
    implementation: string;
}
export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>;
export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;
export interface DAOVault extends BaseContract {
    contractName: "DAOVault";
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: DAOVaultInterface;
    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: {
        CONNECTED_DAO_REGISTRY(overrides?: CallOverrides): Promise<[string]>;
        CONSTITUTION_SIGN_TYPEHASH(overrides?: CallOverrides): Promise<[string]>;
        MAX_LOCKED_TIME(overrides?: CallOverrides): Promise<[BigNumber]>;
        authorizeBySBT(tokenAddress_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        depositERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        depositNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        depositNative(overrides?: PayableOverrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        eip712Domain(overrides?: CallOverrides): Promise<[
            string,
            string,
            string,
            BigNumber,
            string,
            string,
            BigNumber[]
        ] & {
            fields: string;
            name: string;
            version: string;
            chainId: BigNumber;
            verifyingContract: string;
            salt: string;
            extensions: BigNumber[];
        }>;
        getConstitutionSignHash(signer_: string, overrides?: CallOverrides): Promise<[string]>;
        getInjector(overrides?: CallOverrides): Promise<[string] & {
            injector_: string;
        }>;
        getTimeLockInfo(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<[
            IDAOVault.TomeLockInfoStructOutput
        ] & {
            info_: IDAOVault.TomeLockInfoStructOutput;
        }>;
        getTokenSupply(tokenAddress_: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        getUserConstitutionData(userAddress_: string, overrides?: CallOverrides): Promise<[IDAOVault.ConstitutionDataInfoStructOutput]>;
        getUserNFTs(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<[BigNumber[]]>;
        getUserTokens(userAddress_: string, overrides?: CallOverrides): Promise<[string[]]>;
        getUserVotingPower(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        implementation(overrides?: CallOverrides): Promise<[string]>;
        isAuthorizedBySBT(sender_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<[boolean]>;
        isSupportedNFT(tokenAddress_: string, overrides?: CallOverrides): Promise<[boolean]>;
        isSupportedSBT(tokenAddress_: string, overrides?: CallOverrides): Promise<[boolean]>;
        lock(sender_: string, tokenAddress_: string, amount_: BigNumberish, timeToLock_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        lockAndGetUserVotingPower(userAddress_: string, tokenAddress_: string, timeToLock_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        lockedTokens(user: string, token: string, overrides?: CallOverrides): Promise<[
            PriorityQueue.QueueStructOutput
        ] & {
            _queue: PriorityQueue.QueueStructOutput;
        }>;
        permissionManager(overrides?: CallOverrides): Promise<[string]>;
        proxiableUUID(overrides?: CallOverrides): Promise<[string]>;
        revokeSBTAuthorization(tokenAddress_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setDependencies(registryAddress_: string, arg1: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setInjector(injector_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        signConstitution(signer_: string, signature_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        signEIP712Constitution(signer_: string, signature_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        tokenBalance(token: string, overrides?: CallOverrides): Promise<[BigNumber] & {
            amountInVault: BigNumber;
        }>;
        upgradeTo(newImplementation: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        upgradeToAndCall(newImplementation: string, data: BytesLike, overrides?: PayableOverrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        userTokenBalance(user: string, token: string, overrides?: CallOverrides): Promise<[BigNumber] & {
            balance: BigNumber;
        }>;
        withdrawERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        withdrawNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        withdrawNative(amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
    };
    CONNECTED_DAO_REGISTRY(overrides?: CallOverrides): Promise<string>;
    CONSTITUTION_SIGN_TYPEHASH(overrides?: CallOverrides): Promise<string>;
    MAX_LOCKED_TIME(overrides?: CallOverrides): Promise<BigNumber>;
    authorizeBySBT(tokenAddress_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    depositERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    depositNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    depositNative(overrides?: PayableOverrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    eip712Domain(overrides?: CallOverrides): Promise<[
        string,
        string,
        string,
        BigNumber,
        string,
        string,
        BigNumber[]
    ] & {
        fields: string;
        name: string;
        version: string;
        chainId: BigNumber;
        verifyingContract: string;
        salt: string;
        extensions: BigNumber[];
    }>;
    getConstitutionSignHash(signer_: string, overrides?: CallOverrides): Promise<string>;
    getInjector(overrides?: CallOverrides): Promise<string>;
    getTimeLockInfo(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<IDAOVault.TomeLockInfoStructOutput>;
    getTokenSupply(tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
    getUserConstitutionData(userAddress_: string, overrides?: CallOverrides): Promise<IDAOVault.ConstitutionDataInfoStructOutput>;
    getUserNFTs(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber[]>;
    getUserTokens(userAddress_: string, overrides?: CallOverrides): Promise<string[]>;
    getUserVotingPower(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
    implementation(overrides?: CallOverrides): Promise<string>;
    isAuthorizedBySBT(sender_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<boolean>;
    isSupportedNFT(tokenAddress_: string, overrides?: CallOverrides): Promise<boolean>;
    isSupportedSBT(tokenAddress_: string, overrides?: CallOverrides): Promise<boolean>;
    lock(sender_: string, tokenAddress_: string, amount_: BigNumberish, timeToLock_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    lockAndGetUserVotingPower(userAddress_: string, tokenAddress_: string, timeToLock_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    lockedTokens(user: string, token: string, overrides?: CallOverrides): Promise<PriorityQueue.QueueStructOutput>;
    permissionManager(overrides?: CallOverrides): Promise<string>;
    proxiableUUID(overrides?: CallOverrides): Promise<string>;
    revokeSBTAuthorization(tokenAddress_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setDependencies(registryAddress_: string, arg1: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setInjector(injector_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    signConstitution(signer_: string, signature_: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    signEIP712Constitution(signer_: string, signature_: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    tokenBalance(token: string, overrides?: CallOverrides): Promise<BigNumber>;
    upgradeTo(newImplementation: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    upgradeToAndCall(newImplementation: string, data: BytesLike, overrides?: PayableOverrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    userTokenBalance(user: string, token: string, overrides?: CallOverrides): Promise<BigNumber>;
    withdrawERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    withdrawNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    withdrawNative(amount_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    callStatic: {
        CONNECTED_DAO_REGISTRY(overrides?: CallOverrides): Promise<string>;
        CONSTITUTION_SIGN_TYPEHASH(overrides?: CallOverrides): Promise<string>;
        MAX_LOCKED_TIME(overrides?: CallOverrides): Promise<BigNumber>;
        authorizeBySBT(tokenAddress_: string, overrides?: CallOverrides): Promise<void>;
        depositERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        depositNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        depositNative(overrides?: CallOverrides): Promise<void>;
        eip712Domain(overrides?: CallOverrides): Promise<[
            string,
            string,
            string,
            BigNumber,
            string,
            string,
            BigNumber[]
        ] & {
            fields: string;
            name: string;
            version: string;
            chainId: BigNumber;
            verifyingContract: string;
            salt: string;
            extensions: BigNumber[];
        }>;
        getConstitutionSignHash(signer_: string, overrides?: CallOverrides): Promise<string>;
        getInjector(overrides?: CallOverrides): Promise<string>;
        getTimeLockInfo(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<IDAOVault.TomeLockInfoStructOutput>;
        getTokenSupply(tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        getUserConstitutionData(userAddress_: string, overrides?: CallOverrides): Promise<IDAOVault.ConstitutionDataInfoStructOutput>;
        getUserNFTs(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber[]>;
        getUserTokens(userAddress_: string, overrides?: CallOverrides): Promise<string[]>;
        getUserVotingPower(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        implementation(overrides?: CallOverrides): Promise<string>;
        isAuthorizedBySBT(sender_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<boolean>;
        isSupportedNFT(tokenAddress_: string, overrides?: CallOverrides): Promise<boolean>;
        isSupportedSBT(tokenAddress_: string, overrides?: CallOverrides): Promise<boolean>;
        lock(sender_: string, tokenAddress_: string, amount_: BigNumberish, timeToLock_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        lockAndGetUserVotingPower(userAddress_: string, tokenAddress_: string, timeToLock_: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        lockedTokens(user: string, token: string, overrides?: CallOverrides): Promise<PriorityQueue.QueueStructOutput>;
        permissionManager(overrides?: CallOverrides): Promise<string>;
        proxiableUUID(overrides?: CallOverrides): Promise<string>;
        revokeSBTAuthorization(tokenAddress_: string, overrides?: CallOverrides): Promise<void>;
        setDependencies(registryAddress_: string, arg1: BytesLike, overrides?: CallOverrides): Promise<void>;
        setInjector(injector_: string, overrides?: CallOverrides): Promise<void>;
        signConstitution(signer_: string, signature_: BytesLike, overrides?: CallOverrides): Promise<void>;
        signEIP712Constitution(signer_: string, signature_: BytesLike, overrides?: CallOverrides): Promise<void>;
        tokenBalance(token: string, overrides?: CallOverrides): Promise<BigNumber>;
        upgradeTo(newImplementation: string, overrides?: CallOverrides): Promise<void>;
        upgradeToAndCall(newImplementation: string, data: BytesLike, overrides?: CallOverrides): Promise<void>;
        userTokenBalance(user: string, token: string, overrides?: CallOverrides): Promise<BigNumber>;
        withdrawERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        withdrawNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        withdrawNative(amount_: BigNumberish, overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        "AdminChanged(address,address)"(previousAdmin?: null, newAdmin?: null): AdminChangedEventFilter;
        AdminChanged(previousAdmin?: null, newAdmin?: null): AdminChangedEventFilter;
        "AuthenticatedBySBT(address,address)"(tokenAddress?: string | null, sender?: string | null): AuthenticatedBySBTEventFilter;
        AuthenticatedBySBT(tokenAddress?: string | null, sender?: string | null): AuthenticatedBySBTEventFilter;
        "AuthorizedBySBT(address,address)"(tokenAddress?: string | null, sender?: string | null): AuthorizedBySBTEventFilter;
        AuthorizedBySBT(tokenAddress?: string | null, sender?: string | null): AuthorizedBySBTEventFilter;
        "BeaconUpgraded(address)"(beacon?: string | null): BeaconUpgradedEventFilter;
        BeaconUpgraded(beacon?: string | null): BeaconUpgradedEventFilter;
        "ConstitutionSigned(address)"(user?: string | null): ConstitutionSignedEventFilter;
        ConstitutionSigned(user?: string | null): ConstitutionSignedEventFilter;
        "EIP712DomainChanged()"(): EIP712DomainChangedEventFilter;
        EIP712DomainChanged(): EIP712DomainChangedEventFilter;
        "Initialized(uint8)"(version?: null): InitializedEventFilter;
        Initialized(version?: null): InitializedEventFilter;
        "NFTDeposited(address,address,uint256)"(tokenAddress?: string | null, sender?: string | null, tokenId?: null): NFTDepositedEventFilter;
        NFTDeposited(tokenAddress?: string | null, sender?: string | null, tokenId?: null): NFTDepositedEventFilter;
        "NFTLocked(address,address,uint256,uint256)"(tokenAddress?: string | null, sender?: string | null, tokenId?: null, unlockTime?: null): NFTLockedEventFilter;
        NFTLocked(tokenAddress?: string | null, sender?: string | null, tokenId?: null, unlockTime?: null): NFTLockedEventFilter;
        "NFTWithdrew(address,address,uint256)"(tokenAddress?: string | null, sender?: string | null, tokenId?: null): NFTWithdrewEventFilter;
        NFTWithdrew(tokenAddress?: string | null, sender?: string | null, tokenId?: null): NFTWithdrewEventFilter;
        "SBTAuthorizationRevoked(address,address)"(tokenAddress?: string | null, sender?: string | null): SBTAuthorizationRevokedEventFilter;
        SBTAuthorizationRevoked(tokenAddress?: string | null, sender?: string | null): SBTAuthorizationRevokedEventFilter;
        "TokensDeposited(address,address,uint256)"(tokenAddress?: string | null, sender?: string | null, amount?: null): TokensDepositedEventFilter;
        TokensDeposited(tokenAddress?: string | null, sender?: string | null, amount?: null): TokensDepositedEventFilter;
        "TokensLocked(address,address,uint256,uint256)"(tokenAddress?: string | null, sender?: string | null, amount?: null, unlockTime?: null): TokensLockedEventFilter;
        TokensLocked(tokenAddress?: string | null, sender?: string | null, amount?: null, unlockTime?: null): TokensLockedEventFilter;
        "TokensWithdrew(address,address,uint256)"(tokenAddress?: string | null, sender?: string | null, amount?: null): TokensWithdrewEventFilter;
        TokensWithdrew(tokenAddress?: string | null, sender?: string | null, amount?: null): TokensWithdrewEventFilter;
        "Upgraded(address)"(implementation?: string | null): UpgradedEventFilter;
        Upgraded(implementation?: string | null): UpgradedEventFilter;
    };
    estimateGas: {
        CONNECTED_DAO_REGISTRY(overrides?: CallOverrides): Promise<BigNumber>;
        CONSTITUTION_SIGN_TYPEHASH(overrides?: CallOverrides): Promise<BigNumber>;
        MAX_LOCKED_TIME(overrides?: CallOverrides): Promise<BigNumber>;
        authorizeBySBT(tokenAddress_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        depositERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        depositNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        depositNative(overrides?: PayableOverrides & {
            from?: string;
        }): Promise<BigNumber>;
        eip712Domain(overrides?: CallOverrides): Promise<BigNumber>;
        getConstitutionSignHash(signer_: string, overrides?: CallOverrides): Promise<BigNumber>;
        getInjector(overrides?: CallOverrides): Promise<BigNumber>;
        getTimeLockInfo(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        getTokenSupply(tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        getUserConstitutionData(userAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        getUserNFTs(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        getUserTokens(userAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        getUserVotingPower(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        implementation(overrides?: CallOverrides): Promise<BigNumber>;
        isAuthorizedBySBT(sender_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        isSupportedNFT(tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        isSupportedSBT(tokenAddress_: string, overrides?: CallOverrides): Promise<BigNumber>;
        lock(sender_: string, tokenAddress_: string, amount_: BigNumberish, timeToLock_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        lockAndGetUserVotingPower(userAddress_: string, tokenAddress_: string, timeToLock_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        lockedTokens(user: string, token: string, overrides?: CallOverrides): Promise<BigNumber>;
        permissionManager(overrides?: CallOverrides): Promise<BigNumber>;
        proxiableUUID(overrides?: CallOverrides): Promise<BigNumber>;
        revokeSBTAuthorization(tokenAddress_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setDependencies(registryAddress_: string, arg1: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setInjector(injector_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        signConstitution(signer_: string, signature_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        signEIP712Constitution(signer_: string, signature_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        tokenBalance(token: string, overrides?: CallOverrides): Promise<BigNumber>;
        upgradeTo(newImplementation: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        upgradeToAndCall(newImplementation: string, data: BytesLike, overrides?: PayableOverrides & {
            from?: string;
        }): Promise<BigNumber>;
        userTokenBalance(user: string, token: string, overrides?: CallOverrides): Promise<BigNumber>;
        withdrawERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        withdrawNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        withdrawNative(amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        CONNECTED_DAO_REGISTRY(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        CONSTITUTION_SIGN_TYPEHASH(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MAX_LOCKED_TIME(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        authorizeBySBT(tokenAddress_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        depositERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        depositNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        depositNative(overrides?: PayableOverrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        eip712Domain(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getConstitutionSignHash(signer_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getInjector(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getTimeLockInfo(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getTokenSupply(tokenAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getUserConstitutionData(userAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getUserNFTs(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getUserTokens(userAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getUserVotingPower(userAddress_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        implementation(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isAuthorizedBySBT(sender_: string, tokenAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isSupportedNFT(tokenAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isSupportedSBT(tokenAddress_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lock(sender_: string, tokenAddress_: string, amount_: BigNumberish, timeToLock_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        lockAndGetUserVotingPower(userAddress_: string, tokenAddress_: string, timeToLock_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        lockedTokens(user: string, token: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        permissionManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        proxiableUUID(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        revokeSBTAuthorization(tokenAddress_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setDependencies(registryAddress_: string, arg1: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setInjector(injector_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        signConstitution(signer_: string, signature_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        signEIP712Constitution(signer_: string, signature_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        tokenBalance(token: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        upgradeTo(newImplementation: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        upgradeToAndCall(newImplementation: string, data: BytesLike, overrides?: PayableOverrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        userTokenBalance(user: string, token: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        withdrawERC20(tokenAddress_: string, amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        withdrawNFT(tokenAddress_: string, tokenId_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        withdrawNative(amount_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
    };
}