import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers"; import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi"; import type { Listener, Provider } from "@ethersproject/providers"; import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "./common"; export declare namespace ERC721Base { type FeeStruct = { recipient: PromiseOrValue; value: PromiseOrValue; }; type FeeStructOutput = [string, BigNumber] & { recipient: string; value: BigNumber; }; } export interface MintableTokenInterface extends utils.Interface { functions: { "approve(address,uint256)": FunctionFragment; "balanceOf(address)": FunctionFragment; "burn(uint256)": FunctionFragment; "contractURI()": FunctionFragment; "fees(uint256,uint256)": FunctionFragment; "getApproved(uint256)": FunctionFragment; "getFeeBps(uint256)": FunctionFragment; "getFeeRecipients(uint256)": FunctionFragment; "isApprovedForAll(address,address)": FunctionFragment; "isOwner()": FunctionFragment; "name()": FunctionFragment; "owner()": FunctionFragment; "ownerOf(uint256)": FunctionFragment; "renounceOwnership()": FunctionFragment; "safeTransferFrom(address,address,uint256)": FunctionFragment; "safeTransferFrom(address,address,uint256,bytes)": FunctionFragment; "setApprovalForAll(address,bool)": FunctionFragment; "supportsInterface(bytes4)": FunctionFragment; "symbol()": FunctionFragment; "tokenByIndex(uint256)": FunctionFragment; "tokenOfOwnerByIndex(address,uint256)": FunctionFragment; "tokenURI(uint256)": FunctionFragment; "tokenURIPrefix()": FunctionFragment; "totalSupply()": FunctionFragment; "transferFrom(address,address,uint256)": FunctionFragment; "transferOwnership(address)": FunctionFragment; "mint(uint256,uint8,bytes32,bytes32,(address,uint256)[],string)": FunctionFragment; "setTokenURIPrefix(string)": FunctionFragment; "setContractURI(string)": FunctionFragment; }; getFunction(nameOrSignatureOrTopic: "approve" | "balanceOf" | "burn" | "contractURI" | "fees" | "getApproved" | "getFeeBps" | "getFeeRecipients" | "isApprovedForAll" | "isOwner" | "name" | "owner" | "ownerOf" | "renounceOwnership" | "safeTransferFrom(address,address,uint256)" | "safeTransferFrom(address,address,uint256,bytes)" | "setApprovalForAll" | "supportsInterface" | "symbol" | "tokenByIndex" | "tokenOfOwnerByIndex" | "tokenURI" | "tokenURIPrefix" | "totalSupply" | "transferFrom" | "transferOwnership" | "mint" | "setTokenURIPrefix" | "setContractURI"): FunctionFragment; encodeFunctionData(functionFragment: "approve", values: [PromiseOrValue, PromiseOrValue]): string; encodeFunctionData(functionFragment: "balanceOf", values: [PromiseOrValue]): string; encodeFunctionData(functionFragment: "burn", values: [PromiseOrValue]): string; encodeFunctionData(functionFragment: "contractURI", values?: undefined): string; encodeFunctionData(functionFragment: "fees", values: [PromiseOrValue, PromiseOrValue]): string; encodeFunctionData(functionFragment: "getApproved", values: [PromiseOrValue]): string; encodeFunctionData(functionFragment: "getFeeBps", values: [PromiseOrValue]): string; encodeFunctionData(functionFragment: "getFeeRecipients", values: [PromiseOrValue]): string; encodeFunctionData(functionFragment: "isApprovedForAll", values: [PromiseOrValue, PromiseOrValue]): string; encodeFunctionData(functionFragment: "isOwner", values?: undefined): string; encodeFunctionData(functionFragment: "name", values?: undefined): string; encodeFunctionData(functionFragment: "owner", values?: undefined): string; encodeFunctionData(functionFragment: "ownerOf", values: [PromiseOrValue]): string; encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string; encodeFunctionData(functionFragment: "safeTransferFrom(address,address,uint256)", values: [ PromiseOrValue, PromiseOrValue, PromiseOrValue ]): string; encodeFunctionData(functionFragment: "safeTransferFrom(address,address,uint256,bytes)", values: [ PromiseOrValue, PromiseOrValue, PromiseOrValue, PromiseOrValue ]): string; encodeFunctionData(functionFragment: "setApprovalForAll", values: [PromiseOrValue, PromiseOrValue]): string; encodeFunctionData(functionFragment: "supportsInterface", values: [PromiseOrValue]): string; encodeFunctionData(functionFragment: "symbol", values?: undefined): string; encodeFunctionData(functionFragment: "tokenByIndex", values: [PromiseOrValue]): string; encodeFunctionData(functionFragment: "tokenOfOwnerByIndex", values: [PromiseOrValue, PromiseOrValue]): string; encodeFunctionData(functionFragment: "tokenURI", values: [PromiseOrValue]): string; encodeFunctionData(functionFragment: "tokenURIPrefix", values?: undefined): string; encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string; encodeFunctionData(functionFragment: "transferFrom", values: [ PromiseOrValue, PromiseOrValue, PromiseOrValue ]): string; encodeFunctionData(functionFragment: "transferOwnership", values: [PromiseOrValue]): string; encodeFunctionData(functionFragment: "mint", values: [ PromiseOrValue, PromiseOrValue, PromiseOrValue, PromiseOrValue, ERC721Base.FeeStruct[], PromiseOrValue ]): string; encodeFunctionData(functionFragment: "setTokenURIPrefix", values: [PromiseOrValue]): string; encodeFunctionData(functionFragment: "setContractURI", values: [PromiseOrValue]): string; decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result; decodeFunctionResult(functionFragment: "contractURI", data: BytesLike): Result; decodeFunctionResult(functionFragment: "fees", data: BytesLike): Result; decodeFunctionResult(functionFragment: "getApproved", data: BytesLike): Result; decodeFunctionResult(functionFragment: "getFeeBps", data: BytesLike): Result; decodeFunctionResult(functionFragment: "getFeeRecipients", data: BytesLike): Result; decodeFunctionResult(functionFragment: "isApprovedForAll", data: BytesLike): Result; decodeFunctionResult(functionFragment: "isOwner", data: BytesLike): Result; decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; decodeFunctionResult(functionFragment: "ownerOf", data: BytesLike): Result; decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result; decodeFunctionResult(functionFragment: "safeTransferFrom(address,address,uint256)", data: BytesLike): Result; decodeFunctionResult(functionFragment: "safeTransferFrom(address,address,uint256,bytes)", data: BytesLike): Result; decodeFunctionResult(functionFragment: "setApprovalForAll", data: BytesLike): Result; decodeFunctionResult(functionFragment: "supportsInterface", data: BytesLike): Result; decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; decodeFunctionResult(functionFragment: "tokenByIndex", data: BytesLike): Result; decodeFunctionResult(functionFragment: "tokenOfOwnerByIndex", data: BytesLike): Result; decodeFunctionResult(functionFragment: "tokenURI", data: BytesLike): Result; decodeFunctionResult(functionFragment: "tokenURIPrefix", data: BytesLike): Result; decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result; decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result; decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result; decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result; decodeFunctionResult(functionFragment: "setTokenURIPrefix", data: BytesLike): Result; decodeFunctionResult(functionFragment: "setContractURI", data: BytesLike): Result; events: { "Approval(address,address,uint256)": EventFragment; "ApprovalForAll(address,address,bool)": EventFragment; "OwnershipTransferred(address,address)": EventFragment; "SecondarySaleFees(uint256,address[],uint256[])": EventFragment; "Transfer(address,address,uint256)": EventFragment; }; getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; getEvent(nameOrSignatureOrTopic: "ApprovalForAll"): EventFragment; getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; getEvent(nameOrSignatureOrTopic: "SecondarySaleFees"): EventFragment; getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; } export interface ApprovalEventObject { owner: string; approved: string; tokenId: BigNumber; } export type ApprovalEvent = TypedEvent<[ string, string, BigNumber ], ApprovalEventObject>; export type ApprovalEventFilter = TypedEventFilter; export interface ApprovalForAllEventObject { owner: string; operator: string; approved: boolean; } export type ApprovalForAllEvent = TypedEvent<[ string, string, boolean ], ApprovalForAllEventObject>; export type ApprovalForAllEventFilter = TypedEventFilter; export interface OwnershipTransferredEventObject { previousOwner: string; newOwner: string; } export type OwnershipTransferredEvent = TypedEvent<[ string, string ], OwnershipTransferredEventObject>; export type OwnershipTransferredEventFilter = TypedEventFilter; export interface SecondarySaleFeesEventObject { tokenId: BigNumber; recipients: string[]; bps: BigNumber[]; } export type SecondarySaleFeesEvent = TypedEvent<[ BigNumber, string[], BigNumber[] ], SecondarySaleFeesEventObject>; export type SecondarySaleFeesEventFilter = TypedEventFilter; export interface TransferEventObject { from: string; to: string; tokenId: BigNumber; } export type TransferEvent = TypedEvent<[ string, string, BigNumber ], TransferEventObject>; export type TransferEventFilter = TypedEventFilter; export interface MintableToken extends BaseContract { connect(signerOrProvider: Signer | Provider | string): this; attach(addressOrName: string): this; deployed(): Promise; interface: MintableTokenInterface; 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: { /** * Approves another address to transfer the given token ID The zero address indicates there is no approved address. There can only be one approved address per token at a given time. Can only be called by the token owner or an approved operator. * @param to address to be approved for the given token ID * @param tokenId uint256 ID of the token to be approved */ approve(to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Gets the balance of the specified address. * @param owner address to query the balance of * @returns uint256 representing the amount owned by the passed address */ balanceOf(owner: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; /** * Burns a specific ERC721 token. * @param tokenId uint256 id of the ERC721 token to be burned. */ burn(tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; contractURI(overrides?: CallOverrides): Promise<[string]>; fees(arg0: PromiseOrValue, arg1: PromiseOrValue, overrides?: CallOverrides): Promise<[string, BigNumber] & { recipient: string; value: BigNumber; }>; /** * Gets the approved address for a token ID, or zero if no address set Reverts if the token ID does not exist. * @param tokenId uint256 ID of the token to query the approval of * @returns address currently approved for the given token ID */ getApproved(tokenId: PromiseOrValue, overrides?: CallOverrides): Promise<[string]>; getFeeBps(id: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber[]]>; getFeeRecipients(id: PromiseOrValue, overrides?: CallOverrides): Promise<[string[]]>; /** * Tells whether an operator is approved by a given owner. * @param operator operator address which you want to query the approval of * @param owner owner address which you want to query the approval of * @returns bool whether the given operator is approved by the given owner */ isApprovedForAll(owner: PromiseOrValue, operator: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; /** * Returns true if the caller is the current owner. */ isOwner(overrides?: CallOverrides): Promise<[boolean]>; name(overrides?: CallOverrides): Promise<[string]>; /** * Returns the address of the current owner. */ owner(overrides?: CallOverrides): Promise<[string]>; /** * Gets the owner of the specified token ID. * @param tokenId uint256 ID of the token to query the owner of * @returns address currently marked as the owner of the given token ID */ ownerOf(tokenId: PromiseOrValue, overrides?: CallOverrides): Promise<[string]>; /** * 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?: PromiseOrValue; }): Promise; /** * Safely transfers the ownership of a given token ID to another address If the target address is a contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer, and return the magic value `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, the transfer is reverted. Requires the msg.sender to be the owner, approved, or operator * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Safely transfers the ownership of a given token ID to another address If the target address is a contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer, and return the magic value `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, the transfer is reverted. Requires the _msgSender() to be the owner, approved, or operator * @param _data bytes data to send along with a safe transfer check * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, _data: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Sets or unsets the approval of a given operator An operator is allowed to transfer all tokens of the sender on their behalf. * @param approved representing the status of the approval to be set * @param to operator address to set the approval */ setApprovalForAll(to: PromiseOrValue, approved: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * See {IERC165-supportsInterface}. * Time complexity O(1), guaranteed to always use less than 30 000 gas. */ supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; symbol(overrides?: CallOverrides): Promise<[string]>; /** * Gets the token ID at a given index of all the tokens in this contract Reverts if the index is greater or equal to the total number of tokens. * @param index uint256 representing the index to be accessed of the tokens list * @returns uint256 token ID at the given index of the tokens list */ tokenByIndex(index: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; /** * Gets the token ID at a given index of the tokens list of the requested owner. * @param index uint256 representing the index to be accessed of the requested tokens list * @param owner address owning the tokens list to be accessed * @returns uint256 token ID at the given index of the tokens list owned by the requested address */ tokenOfOwnerByIndex(owner: PromiseOrValue, index: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; /** * Returns an URI for a given token ID. Throws if the token ID does not exist. May return an empty string. * @param tokenId uint256 ID of the token to query */ tokenURI(tokenId: PromiseOrValue, overrides?: CallOverrides): Promise<[string]>; tokenURIPrefix(overrides?: CallOverrides): Promise<[string]>; /** * Gets the total amount of tokens stored by the contract. * @returns uint256 representing the total amount of tokens */ totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; /** * Transfers the ownership of a given token ID to another address. Usage of this method is discouraged, use {safeTransferFrom} whenever possible. Requires the msg.sender to be the owner, approved, or operator. * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ transferFrom(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner. */ transferOwnership(newOwner: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; mint(tokenId: PromiseOrValue, v: PromiseOrValue, r: PromiseOrValue, s: PromiseOrValue, _fees: ERC721Base.FeeStruct[], tokenURI: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; setTokenURIPrefix(tokenURIPrefix: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; setContractURI(contractURI: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; }; /** * Approves another address to transfer the given token ID The zero address indicates there is no approved address. There can only be one approved address per token at a given time. Can only be called by the token owner or an approved operator. * @param to address to be approved for the given token ID * @param tokenId uint256 ID of the token to be approved */ approve(to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Gets the balance of the specified address. * @param owner address to query the balance of * @returns uint256 representing the amount owned by the passed address */ balanceOf(owner: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Burns a specific ERC721 token. * @param tokenId uint256 id of the ERC721 token to be burned. */ burn(tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; contractURI(overrides?: CallOverrides): Promise; fees(arg0: PromiseOrValue, arg1: PromiseOrValue, overrides?: CallOverrides): Promise<[string, BigNumber] & { recipient: string; value: BigNumber; }>; /** * Gets the approved address for a token ID, or zero if no address set Reverts if the token ID does not exist. * @param tokenId uint256 ID of the token to query the approval of * @returns address currently approved for the given token ID */ getApproved(tokenId: PromiseOrValue, overrides?: CallOverrides): Promise; getFeeBps(id: PromiseOrValue, overrides?: CallOverrides): Promise; getFeeRecipients(id: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Tells whether an operator is approved by a given owner. * @param operator operator address which you want to query the approval of * @param owner owner address which you want to query the approval of * @returns bool whether the given operator is approved by the given owner */ isApprovedForAll(owner: PromiseOrValue, operator: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Returns true if the caller is the current owner. */ isOwner(overrides?: CallOverrides): Promise; name(overrides?: CallOverrides): Promise; /** * Returns the address of the current owner. */ owner(overrides?: CallOverrides): Promise; /** * Gets the owner of the specified token ID. * @param tokenId uint256 ID of the token to query the owner of * @returns address currently marked as the owner of the given token ID */ ownerOf(tokenId: PromiseOrValue, 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?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Safely transfers the ownership of a given token ID to another address If the target address is a contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer, and return the magic value `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, the transfer is reverted. Requires the msg.sender to be the owner, approved, or operator * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Safely transfers the ownership of a given token ID to another address If the target address is a contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer, and return the magic value `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, the transfer is reverted. Requires the _msgSender() to be the owner, approved, or operator * @param _data bytes data to send along with a safe transfer check * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, _data: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Sets or unsets the approval of a given operator An operator is allowed to transfer all tokens of the sender on their behalf. * @param approved representing the status of the approval to be set * @param to operator address to set the approval */ setApprovalForAll(to: PromiseOrValue, approved: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * See {IERC165-supportsInterface}. * Time complexity O(1), guaranteed to always use less than 30 000 gas. */ supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; symbol(overrides?: CallOverrides): Promise; /** * Gets the token ID at a given index of all the tokens in this contract Reverts if the index is greater or equal to the total number of tokens. * @param index uint256 representing the index to be accessed of the tokens list * @returns uint256 token ID at the given index of the tokens list */ tokenByIndex(index: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Gets the token ID at a given index of the tokens list of the requested owner. * @param index uint256 representing the index to be accessed of the requested tokens list * @param owner address owning the tokens list to be accessed * @returns uint256 token ID at the given index of the tokens list owned by the requested address */ tokenOfOwnerByIndex(owner: PromiseOrValue, index: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Returns an URI for a given token ID. Throws if the token ID does not exist. May return an empty string. * @param tokenId uint256 ID of the token to query */ tokenURI(tokenId: PromiseOrValue, overrides?: CallOverrides): Promise; tokenURIPrefix(overrides?: CallOverrides): Promise; /** * Gets the total amount of tokens stored by the contract. * @returns uint256 representing the total amount of tokens */ totalSupply(overrides?: CallOverrides): Promise; /** * Transfers the ownership of a given token ID to another address. Usage of this method is discouraged, use {safeTransferFrom} whenever possible. Requires the msg.sender to be the owner, approved, or operator. * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ transferFrom(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner. */ transferOwnership(newOwner: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; mint(tokenId: PromiseOrValue, v: PromiseOrValue, r: PromiseOrValue, s: PromiseOrValue, _fees: ERC721Base.FeeStruct[], tokenURI: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; setTokenURIPrefix(tokenURIPrefix: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; setContractURI(contractURI: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; callStatic: { /** * Approves another address to transfer the given token ID The zero address indicates there is no approved address. There can only be one approved address per token at a given time. Can only be called by the token owner or an approved operator. * @param to address to be approved for the given token ID * @param tokenId uint256 ID of the token to be approved */ approve(to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Gets the balance of the specified address. * @param owner address to query the balance of * @returns uint256 representing the amount owned by the passed address */ balanceOf(owner: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Burns a specific ERC721 token. * @param tokenId uint256 id of the ERC721 token to be burned. */ burn(tokenId: PromiseOrValue, overrides?: CallOverrides): Promise; contractURI(overrides?: CallOverrides): Promise; fees(arg0: PromiseOrValue, arg1: PromiseOrValue, overrides?: CallOverrides): Promise<[string, BigNumber] & { recipient: string; value: BigNumber; }>; /** * Gets the approved address for a token ID, or zero if no address set Reverts if the token ID does not exist. * @param tokenId uint256 ID of the token to query the approval of * @returns address currently approved for the given token ID */ getApproved(tokenId: PromiseOrValue, overrides?: CallOverrides): Promise; getFeeBps(id: PromiseOrValue, overrides?: CallOverrides): Promise; getFeeRecipients(id: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Tells whether an operator is approved by a given owner. * @param operator operator address which you want to query the approval of * @param owner owner address which you want to query the approval of * @returns bool whether the given operator is approved by the given owner */ isApprovedForAll(owner: PromiseOrValue, operator: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Returns true if the caller is the current owner. */ isOwner(overrides?: CallOverrides): Promise; name(overrides?: CallOverrides): Promise; /** * Returns the address of the current owner. */ owner(overrides?: CallOverrides): Promise; /** * Gets the owner of the specified token ID. * @param tokenId uint256 ID of the token to query the owner of * @returns address currently marked as the owner of the given token ID */ ownerOf(tokenId: PromiseOrValue, 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; /** * Safely transfers the ownership of a given token ID to another address If the target address is a contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer, and return the magic value `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, the transfer is reverted. Requires the msg.sender to be the owner, approved, or operator * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Safely transfers the ownership of a given token ID to another address If the target address is a contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer, and return the magic value `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, the transfer is reverted. Requires the _msgSender() to be the owner, approved, or operator * @param _data bytes data to send along with a safe transfer check * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, _data: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Sets or unsets the approval of a given operator An operator is allowed to transfer all tokens of the sender on their behalf. * @param approved representing the status of the approval to be set * @param to operator address to set the approval */ setApprovalForAll(to: PromiseOrValue, approved: PromiseOrValue, overrides?: CallOverrides): Promise; /** * See {IERC165-supportsInterface}. * Time complexity O(1), guaranteed to always use less than 30 000 gas. */ supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; symbol(overrides?: CallOverrides): Promise; /** * Gets the token ID at a given index of all the tokens in this contract Reverts if the index is greater or equal to the total number of tokens. * @param index uint256 representing the index to be accessed of the tokens list * @returns uint256 token ID at the given index of the tokens list */ tokenByIndex(index: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Gets the token ID at a given index of the tokens list of the requested owner. * @param index uint256 representing the index to be accessed of the requested tokens list * @param owner address owning the tokens list to be accessed * @returns uint256 token ID at the given index of the tokens list owned by the requested address */ tokenOfOwnerByIndex(owner: PromiseOrValue, index: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Returns an URI for a given token ID. Throws if the token ID does not exist. May return an empty string. * @param tokenId uint256 ID of the token to query */ tokenURI(tokenId: PromiseOrValue, overrides?: CallOverrides): Promise; tokenURIPrefix(overrides?: CallOverrides): Promise; /** * Gets the total amount of tokens stored by the contract. * @returns uint256 representing the total amount of tokens */ totalSupply(overrides?: CallOverrides): Promise; /** * Transfers the ownership of a given token ID to another address. Usage of this method is discouraged, use {safeTransferFrom} whenever possible. Requires the msg.sender to be the owner, approved, or operator. * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ transferFrom(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner. */ transferOwnership(newOwner: PromiseOrValue, overrides?: CallOverrides): Promise; mint(tokenId: PromiseOrValue, v: PromiseOrValue, r: PromiseOrValue, s: PromiseOrValue, _fees: ERC721Base.FeeStruct[], tokenURI: PromiseOrValue, overrides?: CallOverrides): Promise; setTokenURIPrefix(tokenURIPrefix: PromiseOrValue, overrides?: CallOverrides): Promise; setContractURI(contractURI: PromiseOrValue, overrides?: CallOverrides): Promise; }; filters: { "Approval(address,address,uint256)"(owner?: PromiseOrValue | null, approved?: PromiseOrValue | null, tokenId?: PromiseOrValue | null): ApprovalEventFilter; Approval(owner?: PromiseOrValue | null, approved?: PromiseOrValue | null, tokenId?: PromiseOrValue | null): ApprovalEventFilter; "ApprovalForAll(address,address,bool)"(owner?: PromiseOrValue | null, operator?: PromiseOrValue | null, approved?: null): ApprovalForAllEventFilter; ApprovalForAll(owner?: PromiseOrValue | null, operator?: PromiseOrValue | null, approved?: null): ApprovalForAllEventFilter; "OwnershipTransferred(address,address)"(previousOwner?: PromiseOrValue | null, newOwner?: PromiseOrValue | null): OwnershipTransferredEventFilter; OwnershipTransferred(previousOwner?: PromiseOrValue | null, newOwner?: PromiseOrValue | null): OwnershipTransferredEventFilter; "SecondarySaleFees(uint256,address[],uint256[])"(tokenId?: null, recipients?: null, bps?: null): SecondarySaleFeesEventFilter; SecondarySaleFees(tokenId?: null, recipients?: null, bps?: null): SecondarySaleFeesEventFilter; "Transfer(address,address,uint256)"(from?: PromiseOrValue | null, to?: PromiseOrValue | null, tokenId?: PromiseOrValue | null): TransferEventFilter; Transfer(from?: PromiseOrValue | null, to?: PromiseOrValue | null, tokenId?: PromiseOrValue | null): TransferEventFilter; }; estimateGas: { /** * Approves another address to transfer the given token ID The zero address indicates there is no approved address. There can only be one approved address per token at a given time. Can only be called by the token owner or an approved operator. * @param to address to be approved for the given token ID * @param tokenId uint256 ID of the token to be approved */ approve(to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Gets the balance of the specified address. * @param owner address to query the balance of * @returns uint256 representing the amount owned by the passed address */ balanceOf(owner: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Burns a specific ERC721 token. * @param tokenId uint256 id of the ERC721 token to be burned. */ burn(tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; contractURI(overrides?: CallOverrides): Promise; fees(arg0: PromiseOrValue, arg1: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Gets the approved address for a token ID, or zero if no address set Reverts if the token ID does not exist. * @param tokenId uint256 ID of the token to query the approval of * @returns address currently approved for the given token ID */ getApproved(tokenId: PromiseOrValue, overrides?: CallOverrides): Promise; getFeeBps(id: PromiseOrValue, overrides?: CallOverrides): Promise; getFeeRecipients(id: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Tells whether an operator is approved by a given owner. * @param operator operator address which you want to query the approval of * @param owner owner address which you want to query the approval of * @returns bool whether the given operator is approved by the given owner */ isApprovedForAll(owner: PromiseOrValue, operator: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Returns true if the caller is the current owner. */ isOwner(overrides?: CallOverrides): Promise; name(overrides?: CallOverrides): Promise; /** * Returns the address of the current owner. */ owner(overrides?: CallOverrides): Promise; /** * Gets the owner of the specified token ID. * @param tokenId uint256 ID of the token to query the owner of * @returns address currently marked as the owner of the given token ID */ ownerOf(tokenId: PromiseOrValue, 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?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Safely transfers the ownership of a given token ID to another address If the target address is a contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer, and return the magic value `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, the transfer is reverted. Requires the msg.sender to be the owner, approved, or operator * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Safely transfers the ownership of a given token ID to another address If the target address is a contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer, and return the magic value `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, the transfer is reverted. Requires the _msgSender() to be the owner, approved, or operator * @param _data bytes data to send along with a safe transfer check * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, _data: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Sets or unsets the approval of a given operator An operator is allowed to transfer all tokens of the sender on their behalf. * @param approved representing the status of the approval to be set * @param to operator address to set the approval */ setApprovalForAll(to: PromiseOrValue, approved: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * See {IERC165-supportsInterface}. * Time complexity O(1), guaranteed to always use less than 30 000 gas. */ supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; symbol(overrides?: CallOverrides): Promise; /** * Gets the token ID at a given index of all the tokens in this contract Reverts if the index is greater or equal to the total number of tokens. * @param index uint256 representing the index to be accessed of the tokens list * @returns uint256 token ID at the given index of the tokens list */ tokenByIndex(index: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Gets the token ID at a given index of the tokens list of the requested owner. * @param index uint256 representing the index to be accessed of the requested tokens list * @param owner address owning the tokens list to be accessed * @returns uint256 token ID at the given index of the tokens list owned by the requested address */ tokenOfOwnerByIndex(owner: PromiseOrValue, index: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Returns an URI for a given token ID. Throws if the token ID does not exist. May return an empty string. * @param tokenId uint256 ID of the token to query */ tokenURI(tokenId: PromiseOrValue, overrides?: CallOverrides): Promise; tokenURIPrefix(overrides?: CallOverrides): Promise; /** * Gets the total amount of tokens stored by the contract. * @returns uint256 representing the total amount of tokens */ totalSupply(overrides?: CallOverrides): Promise; /** * Transfers the ownership of a given token ID to another address. Usage of this method is discouraged, use {safeTransferFrom} whenever possible. Requires the msg.sender to be the owner, approved, or operator. * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ transferFrom(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner. */ transferOwnership(newOwner: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; mint(tokenId: PromiseOrValue, v: PromiseOrValue, r: PromiseOrValue, s: PromiseOrValue, _fees: ERC721Base.FeeStruct[], tokenURI: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; setTokenURIPrefix(tokenURIPrefix: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; setContractURI(contractURI: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; }; populateTransaction: { /** * Approves another address to transfer the given token ID The zero address indicates there is no approved address. There can only be one approved address per token at a given time. Can only be called by the token owner or an approved operator. * @param to address to be approved for the given token ID * @param tokenId uint256 ID of the token to be approved */ approve(to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Gets the balance of the specified address. * @param owner address to query the balance of * @returns uint256 representing the amount owned by the passed address */ balanceOf(owner: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Burns a specific ERC721 token. * @param tokenId uint256 id of the ERC721 token to be burned. */ burn(tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; contractURI(overrides?: CallOverrides): Promise; fees(arg0: PromiseOrValue, arg1: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Gets the approved address for a token ID, or zero if no address set Reverts if the token ID does not exist. * @param tokenId uint256 ID of the token to query the approval of * @returns address currently approved for the given token ID */ getApproved(tokenId: PromiseOrValue, overrides?: CallOverrides): Promise; getFeeBps(id: PromiseOrValue, overrides?: CallOverrides): Promise; getFeeRecipients(id: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Tells whether an operator is approved by a given owner. * @param operator operator address which you want to query the approval of * @param owner owner address which you want to query the approval of * @returns bool whether the given operator is approved by the given owner */ isApprovedForAll(owner: PromiseOrValue, operator: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Returns true if the caller is the current owner. */ isOwner(overrides?: CallOverrides): Promise; name(overrides?: CallOverrides): Promise; /** * Returns the address of the current owner. */ owner(overrides?: CallOverrides): Promise; /** * Gets the owner of the specified token ID. * @param tokenId uint256 ID of the token to query the owner of * @returns address currently marked as the owner of the given token ID */ ownerOf(tokenId: PromiseOrValue, 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?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Safely transfers the ownership of a given token ID to another address If the target address is a contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer, and return the magic value `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, the transfer is reverted. Requires the msg.sender to be the owner, approved, or operator * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Safely transfers the ownership of a given token ID to another address If the target address is a contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer, and return the magic value `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, the transfer is reverted. Requires the _msgSender() to be the owner, approved, or operator * @param _data bytes data to send along with a safe transfer check * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, _data: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Sets or unsets the approval of a given operator An operator is allowed to transfer all tokens of the sender on their behalf. * @param approved representing the status of the approval to be set * @param to operator address to set the approval */ setApprovalForAll(to: PromiseOrValue, approved: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * See {IERC165-supportsInterface}. * Time complexity O(1), guaranteed to always use less than 30 000 gas. */ supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; symbol(overrides?: CallOverrides): Promise; /** * Gets the token ID at a given index of all the tokens in this contract Reverts if the index is greater or equal to the total number of tokens. * @param index uint256 representing the index to be accessed of the tokens list * @returns uint256 token ID at the given index of the tokens list */ tokenByIndex(index: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Gets the token ID at a given index of the tokens list of the requested owner. * @param index uint256 representing the index to be accessed of the requested tokens list * @param owner address owning the tokens list to be accessed * @returns uint256 token ID at the given index of the tokens list owned by the requested address */ tokenOfOwnerByIndex(owner: PromiseOrValue, index: PromiseOrValue, overrides?: CallOverrides): Promise; /** * Returns an URI for a given token ID. Throws if the token ID does not exist. May return an empty string. * @param tokenId uint256 ID of the token to query */ tokenURI(tokenId: PromiseOrValue, overrides?: CallOverrides): Promise; tokenURIPrefix(overrides?: CallOverrides): Promise; /** * Gets the total amount of tokens stored by the contract. * @returns uint256 representing the total amount of tokens */ totalSupply(overrides?: CallOverrides): Promise; /** * Transfers the ownership of a given token ID to another address. Usage of this method is discouraged, use {safeTransferFrom} whenever possible. Requires the msg.sender to be the owner, approved, or operator. * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ transferFrom(from: PromiseOrValue, to: PromiseOrValue, tokenId: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; /** * Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner. */ transferOwnership(newOwner: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; mint(tokenId: PromiseOrValue, v: PromiseOrValue, r: PromiseOrValue, s: PromiseOrValue, _fees: ERC721Base.FeeStruct[], tokenURI: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; setTokenURIPrefix(tokenURIPrefix: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; setContractURI(contractURI: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue; }): Promise; }; }