Modern Viking

Unverified contract

Proxy

Active on Base with 0 txns

No balances found for "Modern Viking"

Txn hash	Method	Block	Age	From	To	Value (ETH)	Fee (ETH)

No transactions found for "Modern Viking"

Functions

Getter at block 22849054

baseURI() view returns (string)

ipfs://bafybeiepnhwryf6lmly3ftwgnx7gqtn5qzrtgvuqbl5d47s2vcpn7gtkuq/{id}

contractURI() view returns (string)

getTransferValidationFunction() pure returns (bytes4 functionSignature, bool isViewFunction)

(functionSignature=0x1854b241, isViewFunction=true)

getTransferValidator() view returns (address)

0x0000000000000000000000000000000000000000

name() view returns (string)

Modern Viking

owner() view returns (address result)

0x668110d197e5e05d0a2409365929e627ae2e75f8

ownershipHandoverValidFor() view returns (uint64)

172800

provenanceHash() view returns (bytes32)

0x0000000000000000000000000000000000000000000000000000000000000000

symbol() view returns (string)

ModVik

Read-only

balanceOf(address owner, uint256 id) view returns (uint256 result)

balanceOfBatch(address[] owners, uint256[] ids) view returns (uint256[] balances)

isApprovedForAll(address owner, address operator) view returns (bool)

maxSupply(uint256 tokenId) view returns (uint256)

ownershipHandoverExpiresAt(address pendingOwner) view returns (uint256 result)

royaltyInfo(uint256 tokenId, uint256 salePrice) view returns (address receiver, uint256 royaltyAmount)

supportsInterface(bytes4 interfaceId) view returns (bool)

totalMinted(uint256 tokenId) view returns (uint256)

totalSupply(uint256 tokenId) view returns (uint256)

uri(uint256) view returns (string)

State-modifying

batchBurn(address from, uint256[] ids, uint256[] amounts)

burn(address from, uint256 id, uint256 amount)

cancelOwnershipHandover() payable

completeOwnershipHandover(address pendingOwner) payable

emitBatchMetadataUpdate(uint256 fromTokenId, uint256 toTokenId)

initialize(address allowedConfigurer, address allowedSeaport, string name_, string symbol_, address initialOwner)

renounceOwnership() payable

requestOwnershipHandover() payable

safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] amounts, bytes data)

safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes data)

setApprovalForAll(address operator, bool isApproved)

setBaseURI(string newBaseURI)

setContractURI(string newContractURI)

setDefaultRoyalty(address receiver, uint96 feeNumerator)

setMaxSupply(uint256 tokenId, uint256 newMaxSupply)

setProvenanceHash(bytes32 newProvenanceHash)

setTransferValidator(address newValidator)

transferOwnership(address newOwner) payable

Events

AllowListUpdated(bytes32 indexed previousMerkleRoot, bytes32 indexed newMerkleRoot, string[] publicKeyURI, string allowListURI)

AllowedFeeRecipientUpdated(address indexed feeRecipient, bool indexed allowed)

AllowedSeaportUpdated(address[] allowedSeaport)

ApprovalForAll(address indexed owner, address indexed operator, bool isApproved)

BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId)

ContractURIUpdated(string newContractURI)

CreatorPayoutsUpdated(struct CreatorPayout[] creatorPayouts)

DropURIUpdated(string newDropURI)

Initialized(uint8 version)

MaxSupplyUpdated(uint256 tokenId, uint256 newMaxSupply)

OwnershipHandoverCanceled(address indexed pendingOwner)

OwnershipHandoverRequested(address indexed pendingOwner)

OwnershipTransferred(address indexed oldOwner, address indexed newOwner)

PayerUpdated(address indexed payer, bool indexed allowed)

ProvenanceHashUpdated(bytes32 previousHash, bytes32 newHash)

PublicDropUpdated(struct PublicDrop publicDrop, uint256 index)

RoyaltyInfoUpdated(address receiver, uint256 basisPoints)

SeaDropMint(address payer, uint256 dropStageIndex)

SeaDropTokenDeployed(uint8 tokenType)

SignerUpdated(address indexed signer, bool indexed allowed)

TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] amounts)

TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 amount)

TransferValidatorUpdated(address oldValidator, address newValidator)

URI(string value, uint256 indexed id)

Constructor

This contract contains no constructor objects.

Fallback and receive

fallback()

Errors

AccountBalanceOverflow()

AllowedSeaportCannotBeZeroAddress()

ArrayLengthsMismatch()

CannotExceedMaxSupplyOfUint64(uint256 got)

CreatorPayoutAddressCannotBeZeroAddress()

CreatorPayoutBasisPointsCannotBeZero()

CreatorPayoutsNotSet()

DuplicateFeeRecipient()

DuplicatePayer()

DuplicateSigner()

FeeRecipientCannotBeZeroAddress()

FeeRecipientNotAllowed(address got)

FeeRecipientNotPresent()

InsufficientBalance()

InvalidCallerOnlyAllowedSeaport(address caller)

InvalidCreatorPayoutBasisPoints(uint256 totalReceivedBasisPoints)

InvalidCreatorPayoutTotalBasisPoints(uint256 totalReceivedBasisPoints)

InvalidExtraDataEncoding(uint8 version)

InvalidFeeBps(uint256 feeBps)

InvalidFromAndToTokenId(uint256 fromTokenId, uint256 toTokenId)

InvalidProof()

InvalidSignedEndTime(uint256 got, uint256 maximum)

InvalidSignedFeeBps(uint256 got, uint256 minimumOrMaximum)

InvalidSignedFromTokenId(uint256 got, uint256 minimum)

InvalidSignedMaxTokenSupplyForStage(uint256 got, uint256 maximum)

InvalidSignedMaxTotalMintableByWallet(uint256 got, uint256 maximum)

InvalidSignedMaxTotalMintableByWalletPerToken(uint256 got, uint256 maximum)

InvalidSignedMintPrice(address paymentToken, uint256 got, uint256 minimum)

InvalidSignedPaymentToken(address got, address want)

InvalidSignedStartTime(uint256 got, uint256 minimum)

InvalidSignedToTokenId(uint256 got, uint256 maximum)

InvalidStartAndEndTime(uint256 startTime, uint256 endTime)

InvalidSubstandard(uint8 substandard)

MaxSupplyMismatch()

MintAmountsMismatch()

MintExceedsMaxSupply(uint256 total, uint256 maxSupply)

MintQuantityExceedsMaxMintedPerWallet(uint256 total, uint256 allowed)

MintQuantityExceedsMaxMintedPerWalletForTokenId(uint256 tokenId, uint256 total, uint256 allowed)

MintQuantityExceedsMaxSupply(uint256 total, uint256 maxSupply)

MintQuantityExceedsMaxTokenSupplyForStage(uint256 total, uint256 maxTokenSupplyForStage)

MustSpecifyERC1155ConsiderationItemForSeaDropMint()

NewOwnerIsZeroAddress()

NoBalanceToWithdraw()

NoHandoverRequest()

NotActive(uint256 currentTimestamp, uint256 startTimestamp, uint256 endTimestamp)

NotOwnerNorApproved()

OfferContainsDuplicateTokenId(uint256 tokenId)

OnlyDelegateCalled()

PayerCannotBeZeroAddress()

PayerNotAllowed(address got)

PayerNotPresent()

ProvenanceHashCannotBeSetAfterAlreadyBeingSet()

ProvenanceHashCannotBeSetAfterMintStarted()

PublicDropStageNotPresent()

PublicDropsMismatch()

RoyaltyOverflow()

RoyaltyReceiverIsZeroAddress()

SameTransferValidator()

SignatureAlreadyUsed()

SignedMintsMustRestrictFeeRecipients()

SignerCannotBeZeroAddress()

SignerNotPresent()

TokenIdNotWithinDropStageRange(uint256 tokenId, uint256 startTokenId, uint256 endTokenId)

TransferToNonERC1155ReceiverImplementer()

TransferToZeroAddress()

Unauthorized()

UnsupportedExtraDataVersion(uint8 version)

UnsupportedFunctionSelector(bytes4 selector)

Modern Viking

Associated implementation

Filters