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 interface ERC20PresetMinterPauserMockInterface extends utils.Interface { contractName: "ERC20PresetMinterPauserMock"; functions: { "DEFAULT_ADMIN_ROLE()": FunctionFragment; "MINTER_ROLE()": FunctionFragment; "PAUSER_ROLE()": FunctionFragment; "allowance(address,address)": FunctionFragment; "approve(address,uint256)": FunctionFragment; "balanceOf(address)": FunctionFragment; "burn(uint256)": FunctionFragment; "burnFrom(address,uint256)": FunctionFragment; "decimals()": FunctionFragment; "decreaseAllowance(address,uint256)": FunctionFragment; "getRoleAdmin(bytes32)": FunctionFragment; "getRoleMember(bytes32,uint256)": FunctionFragment; "getRoleMemberCount(bytes32)": FunctionFragment; "grantRole(bytes32,address)": FunctionFragment; "hasRole(bytes32,address)": FunctionFragment; "increaseAllowance(address,uint256)": FunctionFragment; "mint(address,uint256)": FunctionFragment; "name()": FunctionFragment; "pause()": FunctionFragment; "paused()": FunctionFragment; "renounceRole(bytes32,address)": FunctionFragment; "revokeRole(bytes32,address)": FunctionFragment; "supportsInterface(bytes4)": FunctionFragment; "symbol()": FunctionFragment; "totalSupply()": FunctionFragment; "transfer(address,uint256)": FunctionFragment; "unpause()": FunctionFragment; "transferFrom(address,address,uint256)": FunctionFragment; }; encodeFunctionData(functionFragment: "DEFAULT_ADMIN_ROLE", values?: undefined): string; encodeFunctionData(functionFragment: "MINTER_ROLE", values?: undefined): string; encodeFunctionData(functionFragment: "PAUSER_ROLE", 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: "burn", values: [BigNumberish]): string; encodeFunctionData(functionFragment: "burnFrom", values: [string, BigNumberish]): string; encodeFunctionData(functionFragment: "decimals", values?: undefined): string; encodeFunctionData(functionFragment: "decreaseAllowance", values: [string, BigNumberish]): string; encodeFunctionData(functionFragment: "getRoleAdmin", values: [BytesLike]): string; encodeFunctionData(functionFragment: "getRoleMember", values: [BytesLike, BigNumberish]): string; encodeFunctionData(functionFragment: "getRoleMemberCount", values: [BytesLike]): string; encodeFunctionData(functionFragment: "grantRole", values: [BytesLike, string]): string; encodeFunctionData(functionFragment: "hasRole", values: [BytesLike, string]): string; encodeFunctionData(functionFragment: "increaseAllowance", values: [string, BigNumberish]): string; encodeFunctionData(functionFragment: "mint", values: [string, BigNumberish]): string; encodeFunctionData(functionFragment: "name", values?: undefined): string; encodeFunctionData(functionFragment: "pause", values?: undefined): string; encodeFunctionData(functionFragment: "paused", values?: undefined): string; encodeFunctionData(functionFragment: "renounceRole", values: [BytesLike, string]): string; encodeFunctionData(functionFragment: "revokeRole", values: [BytesLike, string]): string; encodeFunctionData(functionFragment: "supportsInterface", values: [BytesLike]): string; encodeFunctionData(functionFragment: "symbol", values?: undefined): string; encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string; encodeFunctionData(functionFragment: "transfer", values: [string, BigNumberish]): string; encodeFunctionData(functionFragment: "unpause", values?: undefined): string; encodeFunctionData(functionFragment: "transferFrom", values: [string, string, BigNumberish]): string; decodeFunctionResult(functionFragment: "DEFAULT_ADMIN_ROLE", data: BytesLike): Result; decodeFunctionResult(functionFragment: "MINTER_ROLE", data: BytesLike): Result; decodeFunctionResult(functionFragment: "PAUSER_ROLE", data: BytesLike): Result; decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result; decodeFunctionResult(functionFragment: "burnFrom", data: BytesLike): Result; decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result; decodeFunctionResult(functionFragment: "decreaseAllowance", data: BytesLike): Result; decodeFunctionResult(functionFragment: "getRoleAdmin", data: BytesLike): Result; decodeFunctionResult(functionFragment: "getRoleMember", data: BytesLike): Result; decodeFunctionResult(functionFragment: "getRoleMemberCount", data: BytesLike): Result; decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result; decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result; decodeFunctionResult(functionFragment: "increaseAllowance", data: BytesLike): Result; decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result; decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result; decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result; decodeFunctionResult(functionFragment: "renounceRole", data: BytesLike): Result; decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result; decodeFunctionResult(functionFragment: "supportsInterface", data: BytesLike): Result; decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result; decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result; decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result; events: { "Approval(address,address,uint256)": EventFragment; "Paused(address)": EventFragment; "RoleAdminChanged(bytes32,bytes32,bytes32)": EventFragment; "RoleGranted(bytes32,address,address)": EventFragment; "RoleRevoked(bytes32,address,address)": EventFragment; "Transfer(address,address,uint256)": EventFragment; "Unpaused(address)": EventFragment; }; getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment; getEvent(nameOrSignatureOrTopic: "RoleAdminChanged"): EventFragment; getEvent(nameOrSignatureOrTopic: "RoleGranted"): EventFragment; getEvent(nameOrSignatureOrTopic: "RoleRevoked"): EventFragment; getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment; } export declare type ApprovalEvent = TypedEvent<[ string, string, BigNumber ], { owner: string; spender: string; value: BigNumber; }>; export declare type ApprovalEventFilter = TypedEventFilter; export declare type PausedEvent = TypedEvent<[string], { account: string; }>; export declare type PausedEventFilter = TypedEventFilter; export declare type RoleAdminChangedEvent = TypedEvent<[ string, string, string ], { role: string; previousAdminRole: string; newAdminRole: string; }>; export declare type RoleAdminChangedEventFilter = TypedEventFilter; export declare type RoleGrantedEvent = TypedEvent<[ string, string, string ], { role: string; account: string; sender: string; }>; export declare type RoleGrantedEventFilter = TypedEventFilter; export declare type RoleRevokedEvent = TypedEvent<[ string, string, string ], { role: string; account: string; sender: string; }>; export declare type RoleRevokedEventFilter = TypedEventFilter; export declare type TransferEvent = TypedEvent<[ string, string, BigNumber ], { from: string; to: string; value: BigNumber; }>; export declare type TransferEventFilter = TypedEventFilter; export declare type UnpausedEvent = TypedEvent<[string], { account: string; }>; export declare type UnpausedEventFilter = TypedEventFilter; export interface ERC20PresetMinterPauserMock extends BaseContract { contractName: "ERC20PresetMinterPauserMock"; connect(signerOrProvider: Signer | Provider | string): this; attach(addressOrName: string): this; deployed(): Promise; interface: ERC20PresetMinterPauserMockInterface; 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: { DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<[string]>; MINTER_ROLE(overrides?: CallOverrides): Promise<[string]>; PAUSER_ROLE(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]>; /** * Destroys `amount` tokens from the caller. See {ERC20-_burn}. */ burn(amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Destroys `amount` tokens from `account`, deducting from the caller's allowance. See {ERC20-_burn} and {ERC20-allowance}. Requirements: - the caller must have allowance for ``accounts``'s tokens of at least `amount`. */ burnFrom(account: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): 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<[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; /** * Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}. */ getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<[string]>; /** * Returns one of the accounts that have `role`. `index` must be a value between 0 and {getRoleMemberCount}, non-inclusive. Role bearers are not sorted in any particular way, and their ordering may change at any point. WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure you perform all queries on the same block. See the following https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] for more information. */ getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise<[string]>; /** * Returns the number of accounts that have `role`. Can be used together with {getRoleMember} to enumerate all bearers of a role. */ getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise<[BigNumber]>; /** * Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. */ grantRole(role: BytesLike, account: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns `true` if `account` has been granted `role`. */ hasRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise<[boolean]>; /** * 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; /** * Creates `amount` new tokens for `to`. See {ERC20-_mint}. Requirements: - the caller must have the `MINTER_ROLE`. */ mint(to: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns the name of the token. */ name(overrides?: CallOverrides): Promise<[string]>; /** * Pauses all token transfers. See {ERC20Pausable} and {Pausable-_pause}. Requirements: - the caller must have the `PAUSER_ROLE`. */ pause(overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns true if the contract is paused, and false otherwise. */ paused(overrides?: CallOverrides): Promise<[boolean]>; /** * Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`. */ renounceRole(role: BytesLike, account: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. */ revokeRole(role: BytesLike, account: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * See {IERC165-supportsInterface}. */ supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<[boolean]>; /** * 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; /** * Unpauses all token transfers. See {ERC20Pausable} and {Pausable-_unpause}. Requirements: - the caller must have the `PAUSER_ROLE`. */ unpause(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; }; DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise; MINTER_ROLE(overrides?: CallOverrides): Promise; PAUSER_ROLE(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; /** * Destroys `amount` tokens from the caller. See {ERC20-_burn}. */ burn(amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Destroys `amount` tokens from `account`, deducting from the caller's allowance. See {ERC20-_burn} and {ERC20-allowance}. Requirements: - the caller must have allowance for ``accounts``'s tokens of at least `amount`. */ burnFrom(account: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): 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; /** * Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}. */ getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise; /** * Returns one of the accounts that have `role`. `index` must be a value between 0 and {getRoleMemberCount}, non-inclusive. Role bearers are not sorted in any particular way, and their ordering may change at any point. WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure you perform all queries on the same block. See the following https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] for more information. */ getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise; /** * Returns the number of accounts that have `role`. Can be used together with {getRoleMember} to enumerate all bearers of a role. */ getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise; /** * Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. */ grantRole(role: BytesLike, account: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns `true` if `account` has been granted `role`. */ hasRole(role: BytesLike, account: string, 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?: Overrides & { from?: string | Promise; }): Promise; /** * Creates `amount` new tokens for `to`. See {ERC20-_mint}. Requirements: - the caller must have the `MINTER_ROLE`. */ mint(to: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns the name of the token. */ name(overrides?: CallOverrides): Promise; /** * Pauses all token transfers. See {ERC20Pausable} and {Pausable-_pause}. Requirements: - the caller must have the `PAUSER_ROLE`. */ pause(overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns true if the contract is paused, and false otherwise. */ paused(overrides?: CallOverrides): Promise; /** * Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`. */ renounceRole(role: BytesLike, account: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. */ revokeRole(role: BytesLike, account: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * See {IERC165-supportsInterface}. */ supportsInterface(interfaceId: BytesLike, 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?: Overrides & { from?: string | Promise; }): Promise; /** * Unpauses all token transfers. See {ERC20Pausable} and {Pausable-_unpause}. Requirements: - the caller must have the `PAUSER_ROLE`. */ unpause(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; callStatic: { DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise; MINTER_ROLE(overrides?: CallOverrides): Promise; PAUSER_ROLE(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; /** * Destroys `amount` tokens from the caller. See {ERC20-_burn}. */ burn(amount: BigNumberish, overrides?: CallOverrides): Promise; /** * Destroys `amount` tokens from `account`, deducting from the caller's allowance. See {ERC20-_burn} and {ERC20-allowance}. Requirements: - the caller must have allowance for ``accounts``'s tokens of at least `amount`. */ burnFrom(account: string, amount: BigNumberish, 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?: CallOverrides): Promise; /** * Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}. */ getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise; /** * Returns one of the accounts that have `role`. `index` must be a value between 0 and {getRoleMemberCount}, non-inclusive. Role bearers are not sorted in any particular way, and their ordering may change at any point. WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure you perform all queries on the same block. See the following https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] for more information. */ getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise; /** * Returns the number of accounts that have `role`. Can be used together with {getRoleMember} to enumerate all bearers of a role. */ getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise; /** * Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. */ grantRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise; /** * Returns `true` if `account` has been granted `role`. */ hasRole(role: BytesLike, account: string, 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; /** * Creates `amount` new tokens for `to`. See {ERC20-_mint}. Requirements: - the caller must have the `MINTER_ROLE`. */ mint(to: string, amount: BigNumberish, overrides?: CallOverrides): Promise; /** * Returns the name of the token. */ name(overrides?: CallOverrides): Promise; /** * Pauses all token transfers. See {ERC20Pausable} and {Pausable-_pause}. Requirements: - the caller must have the `PAUSER_ROLE`. */ pause(overrides?: CallOverrides): Promise; /** * Returns true if the contract is paused, and false otherwise. */ paused(overrides?: CallOverrides): Promise; /** * Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`. */ renounceRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise; /** * Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. */ revokeRole(role: BytesLike, account: string, overrides?: CallOverrides): Promise; /** * See {IERC165-supportsInterface}. */ supportsInterface(interfaceId: BytesLike, 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; /** * Unpauses all token transfers. See {ERC20Pausable} and {Pausable-_unpause}. Requirements: - the caller must have the `PAUSER_ROLE`. */ unpause(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; }; filters: { "Approval(address,address,uint256)"(owner?: string | null, spender?: string | null, value?: null): ApprovalEventFilter; Approval(owner?: string | null, spender?: string | null, value?: null): ApprovalEventFilter; "Paused(address)"(account?: null): PausedEventFilter; Paused(account?: null): PausedEventFilter; "RoleAdminChanged(bytes32,bytes32,bytes32)"(role?: BytesLike | null, previousAdminRole?: BytesLike | null, newAdminRole?: BytesLike | null): RoleAdminChangedEventFilter; RoleAdminChanged(role?: BytesLike | null, previousAdminRole?: BytesLike | null, newAdminRole?: BytesLike | null): RoleAdminChangedEventFilter; "RoleGranted(bytes32,address,address)"(role?: BytesLike | null, account?: string | null, sender?: string | null): RoleGrantedEventFilter; RoleGranted(role?: BytesLike | null, account?: string | null, sender?: string | null): RoleGrantedEventFilter; "RoleRevoked(bytes32,address,address)"(role?: BytesLike | null, account?: string | null, sender?: string | null): RoleRevokedEventFilter; RoleRevoked(role?: BytesLike | null, account?: string | null, sender?: string | null): RoleRevokedEventFilter; "Transfer(address,address,uint256)"(from?: string | null, to?: string | null, value?: null): TransferEventFilter; Transfer(from?: string | null, to?: string | null, value?: null): TransferEventFilter; "Unpaused(address)"(account?: null): UnpausedEventFilter; Unpaused(account?: null): UnpausedEventFilter; }; estimateGas: { DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise; MINTER_ROLE(overrides?: CallOverrides): Promise; PAUSER_ROLE(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; /** * Destroys `amount` tokens from the caller. See {ERC20-_burn}. */ burn(amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Destroys `amount` tokens from `account`, deducting from the caller's allowance. See {ERC20-_burn} and {ERC20-allowance}. Requirements: - the caller must have allowance for ``accounts``'s tokens of at least `amount`. */ burnFrom(account: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): 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; /** * Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}. */ getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise; /** * Returns one of the accounts that have `role`. `index` must be a value between 0 and {getRoleMemberCount}, non-inclusive. Role bearers are not sorted in any particular way, and their ordering may change at any point. WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure you perform all queries on the same block. See the following https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] for more information. */ getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise; /** * Returns the number of accounts that have `role`. Can be used together with {getRoleMember} to enumerate all bearers of a role. */ getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise; /** * Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. */ grantRole(role: BytesLike, account: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns `true` if `account` has been granted `role`. */ hasRole(role: BytesLike, account: string, 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?: Overrides & { from?: string | Promise; }): Promise; /** * Creates `amount` new tokens for `to`. See {ERC20-_mint}. Requirements: - the caller must have the `MINTER_ROLE`. */ mint(to: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns the name of the token. */ name(overrides?: CallOverrides): Promise; /** * Pauses all token transfers. See {ERC20Pausable} and {Pausable-_pause}. Requirements: - the caller must have the `PAUSER_ROLE`. */ pause(overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns true if the contract is paused, and false otherwise. */ paused(overrides?: CallOverrides): Promise; /** * Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`. */ renounceRole(role: BytesLike, account: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. */ revokeRole(role: BytesLike, account: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * See {IERC165-supportsInterface}. */ supportsInterface(interfaceId: BytesLike, 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?: Overrides & { from?: string | Promise; }): Promise; /** * Unpauses all token transfers. See {ERC20Pausable} and {Pausable-_unpause}. Requirements: - the caller must have the `PAUSER_ROLE`. */ unpause(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; }; populateTransaction: { DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise; MINTER_ROLE(overrides?: CallOverrides): Promise; PAUSER_ROLE(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; /** * Destroys `amount` tokens from the caller. See {ERC20-_burn}. */ burn(amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Destroys `amount` tokens from `account`, deducting from the caller's allowance. See {ERC20-_burn} and {ERC20-allowance}. Requirements: - the caller must have allowance for ``accounts``'s tokens of at least `amount`. */ burnFrom(account: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): 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; /** * Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}. */ getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise; /** * Returns one of the accounts that have `role`. `index` must be a value between 0 and {getRoleMemberCount}, non-inclusive. Role bearers are not sorted in any particular way, and their ordering may change at any point. WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure you perform all queries on the same block. See the following https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] for more information. */ getRoleMember(role: BytesLike, index: BigNumberish, overrides?: CallOverrides): Promise; /** * Returns the number of accounts that have `role`. Can be used together with {getRoleMember} to enumerate all bearers of a role. */ getRoleMemberCount(role: BytesLike, overrides?: CallOverrides): Promise; /** * Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. */ grantRole(role: BytesLike, account: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns `true` if `account` has been granted `role`. */ hasRole(role: BytesLike, account: string, 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?: Overrides & { from?: string | Promise; }): Promise; /** * Creates `amount` new tokens for `to`. See {ERC20-_mint}. Requirements: - the caller must have the `MINTER_ROLE`. */ mint(to: string, amount: BigNumberish, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns the name of the token. */ name(overrides?: CallOverrides): Promise; /** * Pauses all token transfers. See {ERC20Pausable} and {Pausable-_pause}. Requirements: - the caller must have the `PAUSER_ROLE`. */ pause(overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Returns true if the contract is paused, and false otherwise. */ paused(overrides?: CallOverrides): Promise; /** * Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`. */ renounceRole(role: BytesLike, account: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. */ revokeRole(role: BytesLike, account: string, overrides?: Overrides & { from?: string | Promise; }): Promise; /** * See {IERC165-supportsInterface}. */ supportsInterface(interfaceId: BytesLike, 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?: Overrides & { from?: string | Promise; }): Promise; /** * Unpauses all token transfers. See {ERC20Pausable} and {Pausable-_unpause}. Requirements: - the caller must have the `PAUSER_ROLE`. */ unpause(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; }; }