import { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers"; import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi"; import { Listener, Provider } from "@ethersproject/providers"; import { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common"; export declare namespace IXERC20 { type BridgeParametersStruct = { timestamp: BigNumberish; ratePerSecond: BigNumberish; maxLimit: BigNumberish; currentLimit: BigNumberish; }; type BridgeParametersStructOutput = [ BigNumber, BigNumber, BigNumber, BigNumber ] & { timestamp: BigNumber; ratePerSecond: BigNumber; maxLimit: BigNumber; currentLimit: BigNumber; }; } export interface XERC20Interface extends utils.Interface { contractName: "XERC20"; functions: { "DOMAIN_SEPARATOR()": FunctionFragment; "FACTORY()": FunctionFragment; "allowance(address,address)": FunctionFragment; "approve(address,uint256)": FunctionFragment; "balanceOf(address)": FunctionFragment; "bridges(address)": FunctionFragment; "decimals()": FunctionFragment; "decreaseAllowance(address,uint256)": FunctionFragment; "increaseAllowance(address,uint256)": FunctionFragment; "lockbox()": FunctionFragment; "name()": FunctionFragment; "nonces(address)": FunctionFragment; "owner()": FunctionFragment; "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)": FunctionFragment; "renounceOwnership()": FunctionFragment; "symbol()": FunctionFragment; "totalSupply()": FunctionFragment; "transfer(address,uint256)": FunctionFragment; "transferFrom(address,address,uint256)": FunctionFragment; "transferOwnership(address)": FunctionFragment; "mint(address,uint256)": FunctionFragment; "burn(address,uint256)": FunctionFragment; "setLockbox(address)": FunctionFragment; "setLimits(address,uint256,uint256)": FunctionFragment; "mintingMaxLimitOf(address)": FunctionFragment; "burningMaxLimitOf(address)": FunctionFragment; "mintingCurrentLimitOf(address)": FunctionFragment; "burningCurrentLimitOf(address)": FunctionFragment; }; encodeFunctionData(functionFragment: "DOMAIN_SEPARATOR", values?: undefined): string; encodeFunctionData(functionFragment: "FACTORY", values?: undefined): string; encodeFunctionData(functionFragment: "allowance", values: [string, string]): string; encodeFunctionData(functionFragment: "approve", values: [string, BigNumberish]): string; encodeFunctionData(functionFragment: "balanceOf", values: [string]): string; encodeFunctionData(functionFragment: "bridges", values: [string]): string; encodeFunctionData(functionFragment: "decimals", values?: undefined): string; encodeFunctionData(functionFragment: "decreaseAllowance", values: [string, BigNumberish]): string; encodeFunctionData(functionFragment: "increaseAllowance", values: [string, BigNumberish]): string; encodeFunctionData(functionFragment: "lockbox", values?: undefined): string; encodeFunctionData(functionFragment: "name", values?: undefined): string; encodeFunctionData(functionFragment: "nonces", values: [string]): string; encodeFunctionData(functionFragment: "owner", values?: undefined): string; encodeFunctionData(functionFragment: "permit", values: [ string, string, BigNumberish, BigNumberish, BigNumberish, BytesLike, BytesLike ]): string; encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string; encodeFunctionData(functionFragment: "symbol", values?: undefined): string; encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string; encodeFunctionData(functionFragment: "transfer", values: [string, BigNumberish]): string; encodeFunctionData(functionFragment: "transferFrom", values: [string, string, BigNumberish]): string; encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string; encodeFunctionData(functionFragment: "mint", values: [string, BigNumberish]): string; encodeFunctionData(functionFragment: "burn", values: [string, BigNumberish]): string; encodeFunctionData(functionFragment: "setLockbox", values: [string]): string; encodeFunctionData(functionFragment: "setLimits", values: [string, BigNumberish, BigNumberish]): string; encodeFunctionData(functionFragment: "mintingMaxLimitOf", values: [string]): string; encodeFunctionData(functionFragment: "burningMaxLimitOf", values: [string]): string; encodeFunctionData(functionFragment: "mintingCurrentLimitOf", values: [string]): string; encodeFunctionData(functionFragment: "burningCurrentLimitOf", values: [string]): string; decodeFunctionResult(functionFragment: "DOMAIN_SEPARATOR", data: BytesLike): Result; decodeFunctionResult(functionFragment: "FACTORY", data: BytesLike): Result; decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; decodeFunctionResult(functionFragment: "bridges", data: BytesLike): Result; decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result; decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result; decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result; decodeFunctionResult(functionFragment: "lockbox", data: BytesLike): Result; decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result; decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; decodeFunctionResult(functionFragment: "permit", data: BytesLike): Result; decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result; decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result; decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result; decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result; decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result; decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result; decodeFunctionResult(functionFragment: "setLockbox", data: BytesLike): Result; decodeFunctionResult(functionFragment: "setLimits", data: BytesLike): Result; decodeFunctionResult(functionFragment: "mintingMaxLimitOf", data: BytesLike): Result; decodeFunctionResult(functionFragment: "burningMaxLimitOf", data: BytesLike): Result; decodeFunctionResult(functionFragment: "mintingCurrentLimitOf", data: BytesLike): Result; decodeFunctionResult(functionFragment: "burningCurrentLimitOf", data: BytesLike): Result; events: { "Approval(address,address,uint256)": EventFragment; "BridgeLimitsSet(uint256,uint256,address)": EventFragment; "LockboxSet(address)": EventFragment; "OwnershipTransferred(address,address)": EventFragment; "Transfer(address,address,uint256)": EventFragment; }; getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; getEvent(nameOrSignatureOrTopic: "BridgeLimitsSet"): EventFragment; getEvent(nameOrSignatureOrTopic: "LockboxSet"): EventFragment; getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; } export declare type ApprovalEvent = TypedEvent<[ string, string, BigNumber ], { owner: string; spender: string; value: BigNumber; }>; export declare type ApprovalEventFilter = TypedEventFilter; export declare type BridgeLimitsSetEvent = TypedEvent<[ BigNumber, BigNumber, string ], { _mintingLimit: BigNumber; _burningLimit: BigNumber; _bridge: string; }>; export declare type BridgeLimitsSetEventFilter = TypedEventFilter; export declare type LockboxSetEvent = TypedEvent<[string], { _lockbox: string; }>; export declare type LockboxSetEventFilter = TypedEventFilter; export declare type OwnershipTransferredEvent = TypedEvent<[ string, string ], { previousOwner: string; newOwner: string; }>; export declare type OwnershipTransferredEventFilter = TypedEventFilter; export declare type TransferEvent = TypedEvent<[ string, string, BigNumber ], { from: string; to: string; value: BigNumber; }>; export declare type TransferEventFilter = TypedEventFilter; export interface XERC20 extends BaseContract { contractName: "XERC20"; connect(signerOrProvider: Signer | Provider | string): this; attach(addressOrName: string): this; deployed(): Promise; interface: XERC20Interface; queryFilter(event: TypedEventFilter, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise>; listeners(eventFilter?: TypedEventFilter): Array>; listeners(eventName?: string): Array; removeAllListeners(eventFilter: TypedEventFilter): this; removeAllListeners(eventName?: string): this; off: OnEvent; on: OnEvent; once: OnEvent; removeListener: OnEvent; functions: { /** * See {IERC20Permit-DOMAIN_SEPARATOR}. */ DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<[string]>; /** * The address of the factory which deployed this contract */ FACTORY(overrides?: CallOverrides): Promise<[string]>; /** * See {IERC20-allowance}. */ allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<[BigNumber]>; /** * See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address. */ approve(spender: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * See {IERC20-balanceOf}. */ balanceOf(account: string, overrides?: CallOverrides): Promise<[BigNumber]>; /** * Maps bridge address to bridge configurations */ bridges(arg0: string, overrides?: CallOverrides): Promise<[ IXERC20.BridgeParametersStructOutput, IXERC20.BridgeParametersStructOutput ] & { minterParams: IXERC20.BridgeParametersStructOutput; burnerParams: IXERC20.BridgeParametersStructOutput; }>; /** * Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the value {ERC20} uses, unless this function is overridden; NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}. */ decimals(overrides?: CallOverrides): Promise<[number]>; /** * Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`. */ decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. */ increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * The address of the lockbox contract */ lockbox(overrides?: CallOverrides): Promise<[string]>; /** * Returns the name of the token. */ name(overrides?: CallOverrides): Promise<[string]>; /** * See {IERC20Permit-nonces}. */ nonces(owner: string, overrides?: CallOverrides): Promise<[BigNumber]>; /** * Returns the address of the current owner. */ owner(overrides?: CallOverrides): Promise<[string]>; /** * See {IERC20Permit-permit}. */ permit(owner: string, spender: string, value: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner. */ renounceOwnership(overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns the symbol of the token, usually a shorter version of the name. */ symbol(overrides?: CallOverrides): Promise<[string]>; /** * See {IERC20-totalSupply}. */ totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; /** * See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`. */ transfer(to: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`. */ transferFrom(from: string, to: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner. */ transferOwnership(newOwner: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Can only be called by a bridge * Mints tokens for a user * @param _amount The amount of tokens being minted * @param _user The address of the user who needs tokens minted */ mint(_user: string, _amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Can only be called by a bridge * Burns tokens for a user * @param _amount The amount of tokens being burned * @param _user The address of the user who needs tokens burned */ burn(_user: string, _amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Sets the lockbox address * @param _lockbox The address of the lockbox */ setLockbox(_lockbox: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Can only be called by the owner * Updates the limits of any bridge * @param _bridge The address of the bridge we are setting the limits too * @param _burningLimit The updated burning limit we are setting to the bridge * @param _mintingLimit The updated minting limit we are setting to the bridge */ setLimits(_bridge: string, _mintingLimit: BigNumberish, _burningLimit: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns the max limit of a bridge * @param _bridge the bridge we are viewing the limits of */ mintingMaxLimitOf(_bridge: string, overrides?: CallOverrides): Promise<[BigNumber] & { _limit: BigNumber; }>; /** * Returns the max limit of a bridge * @param _bridge the bridge we are viewing the limits of */ burningMaxLimitOf(_bridge: string, overrides?: CallOverrides): Promise<[BigNumber] & { _limit: BigNumber; }>; /** * Returns the current limit of a bridge * @param _bridge the bridge we are viewing the limits of */ mintingCurrentLimitOf(_bridge: string, overrides?: CallOverrides): Promise<[BigNumber] & { _limit: BigNumber; }>; /** * Returns the current limit of a bridge * @param _bridge the bridge we are viewing the limits of */ burningCurrentLimitOf(_bridge: string, overrides?: CallOverrides): Promise<[BigNumber] & { _limit: BigNumber; }>; }; /** * See {IERC20Permit-DOMAIN_SEPARATOR}. */ DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise; /** * The address of the factory which deployed this contract */ FACTORY(overrides?: CallOverrides): Promise; /** * See {IERC20-allowance}. */ allowance(owner: string, spender: string, overrides?: CallOverrides): Promise; /** * See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address. */ approve(spender: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * See {IERC20-balanceOf}. */ balanceOf(account: string, overrides?: CallOverrides): Promise; /** * Maps bridge address to bridge configurations */ bridges(arg0: string, overrides?: CallOverrides): Promise<[ IXERC20.BridgeParametersStructOutput, IXERC20.BridgeParametersStructOutput ] & { minterParams: IXERC20.BridgeParametersStructOutput; burnerParams: IXERC20.BridgeParametersStructOutput; }>; /** * Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the value {ERC20} uses, unless this function is overridden; NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}. */ decimals(overrides?: CallOverrides): Promise; /** * Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`. */ decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. */ increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * The address of the lockbox contract */ lockbox(overrides?: CallOverrides): Promise; /** * Returns the name of the token. */ name(overrides?: CallOverrides): Promise; /** * See {IERC20Permit-nonces}. */ nonces(owner: string, overrides?: CallOverrides): Promise; /** * Returns the address of the current owner. */ owner(overrides?: CallOverrides): Promise; /** * See {IERC20Permit-permit}. */ permit(owner: string, spender: string, value: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner. */ renounceOwnership(overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns the symbol of the token, usually a shorter version of the name. */ symbol(overrides?: CallOverrides): Promise; /** * See {IERC20-totalSupply}. */ totalSupply(overrides?: CallOverrides): Promise; /** * See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`. */ transfer(to: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`. */ transferFrom(from: string, to: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner. */ transferOwnership(newOwner: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Can only be called by a bridge * Mints tokens for a user * @param _amount The amount of tokens being minted * @param _user The address of the user who needs tokens minted */ mint(_user: string, _amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Can only be called by a bridge * Burns tokens for a user * @param _amount The amount of tokens being burned * @param _user The address of the user who needs tokens burned */ burn(_user: string, _amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Sets the lockbox address * @param _lockbox The address of the lockbox */ setLockbox(_lockbox: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Can only be called by the owner * Updates the limits of any bridge * @param _bridge The address of the bridge we are setting the limits too * @param _burningLimit The updated burning limit we are setting to the bridge * @param _mintingLimit The updated minting limit we are setting to the bridge */ setLimits(_bridge: string, _mintingLimit: BigNumberish, _burningLimit: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns the max limit of a bridge * @param _bridge the bridge we are viewing the limits of */ mintingMaxLimitOf(_bridge: string, overrides?: CallOverrides): Promise; /** * Returns the max limit of a bridge * @param _bridge the bridge we are viewing the limits of */ burningMaxLimitOf(_bridge: string, overrides?: CallOverrides): Promise; /** * Returns the current limit of a bridge * @param _bridge the bridge we are viewing the limits of */ mintingCurrentLimitOf(_bridge: string, overrides?: CallOverrides): Promise; /** * Returns the current limit of a bridge * @param _bridge the bridge we are viewing the limits of */ burningCurrentLimitOf(_bridge: string, overrides?: CallOverrides): Promise; callStatic: { /** * See {IERC20Permit-DOMAIN_SEPARATOR}. */ DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise; /** * The address of the factory which deployed this contract */ FACTORY(overrides?: CallOverrides): Promise; /** * See {IERC20-allowance}. */ allowance(owner: string, spender: string, overrides?: CallOverrides): Promise; /** * See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address. */ approve(spender: string, amount: BigNumberish, overrides?: CallOverrides): Promise; /** * See {IERC20-balanceOf}. */ balanceOf(account: string, overrides?: CallOverrides): Promise; /** * Maps bridge address to bridge configurations */ bridges(arg0: string, overrides?: CallOverrides): Promise<[ IXERC20.BridgeParametersStructOutput, IXERC20.BridgeParametersStructOutput ] & { minterParams: IXERC20.BridgeParametersStructOutput; burnerParams: IXERC20.BridgeParametersStructOutput; }>; /** * Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the value {ERC20} uses, unless this function is overridden; NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}. */ decimals(overrides?: CallOverrides): Promise; /** * Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`. */ decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: CallOverrides): Promise; /** * Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. */ increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: CallOverrides): Promise; /** * The address of the lockbox contract */ lockbox(overrides?: CallOverrides): Promise; /** * Returns the name of the token. */ name(overrides?: CallOverrides): Promise; /** * See {IERC20Permit-nonces}. */ nonces(owner: string, overrides?: CallOverrides): Promise; /** * Returns the address of the current owner. */ owner(overrides?: CallOverrides): Promise; /** * See {IERC20Permit-permit}. */ permit(owner: string, spender: string, value: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise; /** * Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner. */ renounceOwnership(overrides?: CallOverrides): Promise; /** * Returns the symbol of the token, usually a shorter version of the name. */ symbol(overrides?: CallOverrides): Promise; /** * See {IERC20-totalSupply}. */ totalSupply(overrides?: CallOverrides): Promise; /** * See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`. */ transfer(to: string, amount: BigNumberish, overrides?: CallOverrides): Promise; /** * See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`. */ transferFrom(from: string, to: string, amount: BigNumberish, overrides?: CallOverrides): Promise; /** * Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner. */ transferOwnership(newOwner: string, overrides?: CallOverrides): Promise; /** * Can only be called by a bridge * Mints tokens for a user * @param _amount The amount of tokens being minted * @param _user The address of the user who needs tokens minted */ mint(_user: string, _amount: BigNumberish, overrides?: CallOverrides): Promise; /** * Can only be called by a bridge * Burns tokens for a user * @param _amount The amount of tokens being burned * @param _user The address of the user who needs tokens burned */ burn(_user: string, _amount: BigNumberish, overrides?: CallOverrides): Promise; /** * Sets the lockbox address * @param _lockbox The address of the lockbox */ setLockbox(_lockbox: string, overrides?: CallOverrides): Promise; /** * Can only be called by the owner * Updates the limits of any bridge * @param _bridge The address of the bridge we are setting the limits too * @param _burningLimit The updated burning limit we are setting to the bridge * @param _mintingLimit The updated minting limit we are setting to the bridge */ setLimits(_bridge: string, _mintingLimit: BigNumberish, _burningLimit: BigNumberish, overrides?: CallOverrides): Promise; /** * Returns the max limit of a bridge * @param _bridge the bridge we are viewing the limits of */ mintingMaxLimitOf(_bridge: string, overrides?: CallOverrides): Promise; /** * Returns the max limit of a bridge * @param _bridge the bridge we are viewing the limits of */ burningMaxLimitOf(_bridge: string, overrides?: CallOverrides): Promise; /** * Returns the current limit of a bridge * @param _bridge the bridge we are viewing the limits of */ mintingCurrentLimitOf(_bridge: string, overrides?: CallOverrides): Promise; /** * Returns the current limit of a bridge * @param _bridge the bridge we are viewing the limits of */ burningCurrentLimitOf(_bridge: string, overrides?: CallOverrides): Promise; }; filters: { "Approval(address,address,uint256)"(owner?: string | null, spender?: string | null, value?: null): ApprovalEventFilter; Approval(owner?: string | null, spender?: string | null, value?: null): ApprovalEventFilter; "BridgeLimitsSet(uint256,uint256,address)"(_mintingLimit?: null, _burningLimit?: null, _bridge?: string | null): BridgeLimitsSetEventFilter; BridgeLimitsSet(_mintingLimit?: null, _burningLimit?: null, _bridge?: string | null): BridgeLimitsSetEventFilter; "LockboxSet(address)"(_lockbox?: null): LockboxSetEventFilter; LockboxSet(_lockbox?: null): LockboxSetEventFilter; "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter; OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter; "Transfer(address,address,uint256)"(from?: string | null, to?: string | null, value?: null): TransferEventFilter; Transfer(from?: string | null, to?: string | null, value?: null): TransferEventFilter; }; estimateGas: { /** * See {IERC20Permit-DOMAIN_SEPARATOR}. */ DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise; /** * The address of the factory which deployed this contract */ FACTORY(overrides?: CallOverrides): Promise; /** * See {IERC20-allowance}. */ allowance(owner: string, spender: string, overrides?: CallOverrides): Promise; /** * See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address. */ approve(spender: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * See {IERC20-balanceOf}. */ balanceOf(account: string, overrides?: CallOverrides): Promise; /** * Maps bridge address to bridge configurations */ bridges(arg0: string, overrides?: CallOverrides): Promise; /** * Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the value {ERC20} uses, unless this function is overridden; NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}. */ decimals(overrides?: CallOverrides): Promise; /** * Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`. */ decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. */ increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * The address of the lockbox contract */ lockbox(overrides?: CallOverrides): Promise; /** * Returns the name of the token. */ name(overrides?: CallOverrides): Promise; /** * See {IERC20Permit-nonces}. */ nonces(owner: string, overrides?: CallOverrides): Promise; /** * Returns the address of the current owner. */ owner(overrides?: CallOverrides): Promise; /** * See {IERC20Permit-permit}. */ permit(owner: string, spender: string, value: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner. */ renounceOwnership(overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns the symbol of the token, usually a shorter version of the name. */ symbol(overrides?: CallOverrides): Promise; /** * See {IERC20-totalSupply}. */ totalSupply(overrides?: CallOverrides): Promise; /** * See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`. */ transfer(to: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`. */ transferFrom(from: string, to: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner. */ transferOwnership(newOwner: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Can only be called by a bridge * Mints tokens for a user * @param _amount The amount of tokens being minted * @param _user The address of the user who needs tokens minted */ mint(_user: string, _amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Can only be called by a bridge * Burns tokens for a user * @param _amount The amount of tokens being burned * @param _user The address of the user who needs tokens burned */ burn(_user: string, _amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Sets the lockbox address * @param _lockbox The address of the lockbox */ setLockbox(_lockbox: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Can only be called by the owner * Updates the limits of any bridge * @param _bridge The address of the bridge we are setting the limits too * @param _burningLimit The updated burning limit we are setting to the bridge * @param _mintingLimit The updated minting limit we are setting to the bridge */ setLimits(_bridge: string, _mintingLimit: BigNumberish, _burningLimit: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns the max limit of a bridge * @param _bridge the bridge we are viewing the limits of */ mintingMaxLimitOf(_bridge: string, overrides?: CallOverrides): Promise; /** * Returns the max limit of a bridge * @param _bridge the bridge we are viewing the limits of */ burningMaxLimitOf(_bridge: string, overrides?: CallOverrides): Promise; /** * Returns the current limit of a bridge * @param _bridge the bridge we are viewing the limits of */ mintingCurrentLimitOf(_bridge: string, overrides?: CallOverrides): Promise; /** * Returns the current limit of a bridge * @param _bridge the bridge we are viewing the limits of */ burningCurrentLimitOf(_bridge: string, overrides?: CallOverrides): Promise; }; populateTransaction: { /** * See {IERC20Permit-DOMAIN_SEPARATOR}. */ DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise; /** * The address of the factory which deployed this contract */ FACTORY(overrides?: CallOverrides): Promise; /** * See {IERC20-allowance}. */ allowance(owner: string, spender: string, overrides?: CallOverrides): Promise; /** * See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address. */ approve(spender: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * See {IERC20-balanceOf}. */ balanceOf(account: string, overrides?: CallOverrides): Promise; /** * Maps bridge address to bridge configurations */ bridges(arg0: string, overrides?: CallOverrides): Promise; /** * Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the value {ERC20} uses, unless this function is overridden; NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}. */ decimals(overrides?: CallOverrides): Promise; /** * Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`. */ decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. */ increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * The address of the lockbox contract */ lockbox(overrides?: CallOverrides): Promise; /** * Returns the name of the token. */ name(overrides?: CallOverrides): Promise; /** * See {IERC20Permit-nonces}. */ nonces(owner: string, overrides?: CallOverrides): Promise; /** * Returns the address of the current owner. */ owner(overrides?: CallOverrides): Promise; /** * See {IERC20Permit-permit}. */ permit(owner: string, spender: string, value: BigNumberish, deadline: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner. */ renounceOwnership(overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns the symbol of the token, usually a shorter version of the name. */ symbol(overrides?: CallOverrides): Promise; /** * See {IERC20-totalSupply}. */ totalSupply(overrides?: CallOverrides): Promise; /** * See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`. */ transfer(to: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`. */ transferFrom(from: string, to: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner. */ transferOwnership(newOwner: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Can only be called by a bridge * Mints tokens for a user * @param _amount The amount of tokens being minted * @param _user The address of the user who needs tokens minted */ mint(_user: string, _amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Can only be called by a bridge * Burns tokens for a user * @param _amount The amount of tokens being burned * @param _user The address of the user who needs tokens burned */ burn(_user: string, _amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Sets the lockbox address * @param _lockbox The address of the lockbox */ setLockbox(_lockbox: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Can only be called by the owner * Updates the limits of any bridge * @param _bridge The address of the bridge we are setting the limits too * @param _burningLimit The updated burning limit we are setting to the bridge * @param _mintingLimit The updated minting limit we are setting to the bridge */ setLimits(_bridge: string, _mintingLimit: BigNumberish, _burningLimit: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns the max limit of a bridge * @param _bridge the bridge we are viewing the limits of */ mintingMaxLimitOf(_bridge: string, overrides?: CallOverrides): Promise; /** * Returns the max limit of a bridge * @param _bridge the bridge we are viewing the limits of */ burningMaxLimitOf(_bridge: string, overrides?: CallOverrides): Promise; /** * Returns the current limit of a bridge * @param _bridge the bridge we are viewing the limits of */ mintingCurrentLimitOf(_bridge: string, overrides?: CallOverrides): Promise; /** * Returns the current limit of a bridge * @param _bridge the bridge we are viewing the limits of */ burningCurrentLimitOf(_bridge: string, overrides?: CallOverrides): Promise; }; }