Creator & Premium 13 분 읽기

Collectibles V2 collection function reference

Every readable and writable function in AuroraCollectiblesV2, with permissions, supply accounting and opening recovery.

이 페이지

The creator controls collection settings; holders control their own tokens and wallet transactions. — Collectibles separates the ERC-1155 token ledger from its paired sales and pack opening engine. 이미지 확대

Choose the correct version and address

This reference covers AuroraCollectiblesV2, 2.0.0-collectibles-beta.1. V3 is the current factory build in Aurora; available networks depend on enabled deployments. Existing V2 collections remain V2 and V1 has no sealed packs. A website update does not upgrade an existing contract.

Use your collection address for balances, transfers, metadata and owner minting. Read packEngine() for its paired sale and opening engine. Never send clone actions to an implementation address.

Reads need no wallet transaction. Writes require gas and the permission shown below. Prices and quantities are integers; times on chain are Unix seconds, with zero meaning no opening start or deadline. Use Aurora transaction preparation for proofs and signed fee authorization.

Collectibles Studio walkthrough

Legacy V1 reference (no packs)

What is permanent

Collection and engine implementations, factory, provider, identities, lifetime caps and pool definitions cannot be replaced. A token belongs to one on-chain pool, but can appear in several organizational sets.
Closing a phase or collection minting is permanent. Issued pack contents stay reserved and can still be delivered; configured opening windows still apply to new requests. Ownership renunciation is disabled.
Pack slot pools, duplicate policy and transferability are fixed. Boxes contain card slots, not nested boosters. Consuming a wrapper does not restore its lifetime issuance capacity.
V2 token metadata and opening deadlines are fixed. There is no setTokenURI, metadata freeze, opening-start setter or combined allocation/delivery method in V2.

Supply, randomness and recovery

Lifetime minted + pooled + retired contents cannot exceed the token cap or configured collection cap. Wrapper supply is separate. Issuing a pack reserves its pool contents and provider capacity; only allocation identifies exact token IDs.

Openings progress through Requested, Seeded, Allocated and Opened. A request cannot be cancelled or rerolled. Allocation follows engine-wide request order; an earlier missing seed delays later allocation. Anyone may allocate the next seeded request, but only its original opener can choose the delivery recipient.

V2 allocate and deliver are separate transactions. Failed delivery preserves the allocated result for retry with a compatible recipient, while later requests can continue allocating.

Opening gas and provider requirements depend on the configured adapter. The user-paid OpenVRF path submits the fixed proof in the collector wallet; the Chainlink adapter depends on its configured subscription. The final card-flip ceremony shows already confirmed contents and sends no extra transaction.

Readable functions

DEFAULT_TRANSFER_VALIDATORRead only · constant

Upstream library default validator address. Use getTransferValidator for this collection’s actual validator.

기능 및 논쟁: DEFAULT_TRANSFER_VALIDATOR()
반환 / 지불: address

autoApproveTransfersFromValidatorRead only · locked setting

Reports whether the validator has automatic operator approval. It is disabled and cannot be enabled after initialization in these builds.

기능 및 논쟁: autoApproveTransfersFromValidator()
반환 / 지불: bool

balanceOfRead only · holder balance

ERC-721: number of NFTs held by a wallet. ERC-1155: number of copies of a specified token ID held by an account.

기능 및 논쟁: balanceOf(address account, uint256 id)
반환 / 지불: uint256

balanceOfBatchRead only · holder balances

Returns ERC-1155 balances for matching account and token-ID arrays. The arrays must have equal length.

기능 및 논쟁: balanceOfBatch(address[] accounts, uint256[] ids)
반환 / 지불: uint256[]

collectibleVersionRead only · version

Returns this collection version: 2 or 3. Aurora also checks the exact deployment build and runtime before enabling capabilities.

기능 및 논쟁: collectibleVersion()
반환 / 지불: uint256

contractFamilyRead only · family identity

Identifies this immutable collection as the independent Aurora Collectibles family; its token interface is ERC-1155.

기능 및 논쟁: contractFamily()
반환 / 지불: string

contractURIRead only · reference

Returns collection-level metadata, such as its profile. This is separate from individual token metadata.

기능 및 논쟁: contractURI()
반환 / 지불: string

factoryRead only · deployment binding

The immutable factory that created this implementation and initialized its clones.

기능 및 논쟁: factory()
반환 / 지불: address

galleryIdRead only · written ONCE

Aurora folder identity used to create this collection. It is fixed when initialized.

기능 및 논쟁: galleryId()
반환 / 지불: bytes32

getTransferValidationFunctionRead only · integration helper

Returns the validator function selector and whether the validation call is read-only. ERC-1155 validation includes transfer amount.

기능 및 논쟁: getTransferValidationFunction()
반환 / 지불: bytes4 functionSignature, bool isViewFunction

getTransferValidatorRead only · current validator or zero

Returns the active transfer validator. The zero address means validator checks are disabled. The owner can change this using updateTransferValidator.

기능 및 논쟁: getTransferValidator()
반환 / 지불: address validator

isApprovedForAllRead only · operator approval

Reports whether an operator is approved to transfer the holder’s tokens. Approval does not give collection administrator permissions.

기능 및 논쟁: isApprovedForAll(address owner, address operator)
반환 / 지불: bool isApproved

isCollectibleRead only · token kind

True for a configured content token, false for sealed wrappers and unknown IDs.

기능 및 논쟁: isCollectible(uint256 tokenId)
반환 / 지불: bool

lockedPacksRead only · pending opening balance

Number of wrappers locked for an account and pack ID by pending openings. Locked copies cannot be transferred.

기능 및 논쟁: lockedPacks(address, uint256)
반환 / 지불: uint256

mintSupplyCapRead only · content cap

Immutable lifetime ceiling for collectible contents; zero means no collection-wide ceiling. Sealed pack wrappers have separate per-token caps and do not consume it.

기능 및 논쟁: mintSupplyCap()
반환 / 지불: uint256

mintingClosedRead only · permanent flag

Whether new minting and pack issuance have been permanently closed. Existing pack commitments remain deliverable.

기능 및 논쟁: mintingClosed()
반환 / 지불: bool

nameRead only · written ONCE

Collection name set at deployment. No later name setter is provided.

기능 및 논쟁: name()
반환 / 지불: string

ownerRead only · authority

The current collection administrator. The engine reads this owner for every owner-only action; it has no separate administrator.

기능 및 논쟁: owner()
반환 / 지불: address

packEngineRead only · action destination

The fixed paired engine address. Send purchase, pool, phase and opening actions here; ERC-1155 transfers stay on the collection.

기능 및 논쟁: packEngine()
반환 / 지불: address

pendingOwnerRead only · ownership handover

The nominated next owner, or zero if no handover is pending.

기능 및 논쟁: pendingOwner()
반환 / 지불: address

royaltyBpsRead only · royalty setting

Secondary-sale royalty setting in basis points: 500 means 5%. This is unrelated to primary mint price.

기능 및 논쟁: royaltyBps()
반환 / 지불: uint96

royaltyInfoRead only · ERC-2981

Returns the royalty receiver and calculated amount for a token and sale price. It is royalty information, not proof that every marketplace enforces payment.

기능 및 논쟁: royaltyInfo(uint256 tokenId, uint256 salePrice)
반환 / 지불: address, uint256

royaltyReceiverRead only · separate from mint proceeds

Receiving wallet for secondary-sale royalties. It does not gain ownership or withdrawal permission.

기능 및 논쟁: royaltyReceiver()
반환 / 지불: address

saleAvailableRead only · direct-item availability

Unpooled, unretired content capacity available to a direct sale, bounded by token and collection lifetime caps. Zero for packs, unknown IDs or closed minting.

기능 및 논쟁: saleAvailable(uint256 tokenId)
반환 / 지불: uint256 available

supportsInterfaceRead only · integration helper

Reports support for a given interface identifier. This does not attest to audit status or marketplace compatibility.

기능 및 논쟁: supportsInterface(bytes4 id)
반환 / 지불: bool

symbolRead only · written ONCE

Collection ticker set during deployment. No later symbol setter is provided.

기능 및 논쟁: symbol()
반환 / 지불: string

tokenStandardRead only · constant

Returns ERC1155 for edition contracts.

기능 및 논쟁: tokenStandard()
반환 / 지불: string

tokenURIRead only · token metadata

Alias for uri(tokenId), including its empty result for an unknown ID.

기능 및 논쟁: tokenURI(uint256 tokenId)
반환 / 지불: string

tokensRead only · token accounting

Returns cap, lifetime minted, circulating supply, pooled, allocated-but-undelivered reserved, retired, pack, transferable and exists fields for one ID. Before allocation a pack reservation belongs to pools, not specific token IDs.

기능 및 논쟁: tokens(uint256)
반환 / 지불: uint256 maxLifetimeMinted, uint256 totalMinted, uint256 totalSupply, uint256 pooled, uint256 reserved, uint256 retired, bool pack, bool transferable, bool exists

totalMintedRead only · lifetime content count

Lifetime collectible contents minted through all paths, excluding sealed wrappers. Delivery increments this count; wrapper burning does not restore capacity.

기능 및 논쟁: totalMinted()
반환 / 지불: uint256

totalPooledRead only · allocated inventory

Content copies allocated to pools, including inventory backing unopened packs. Unallocated direct mints cannot use these copies.

기능 및 논쟁: totalPooled()
반환 / 지불: uint256

totalReservedRead only · pack commitments

Contents promised to issued but undelivered packs. Includes pool-level commitments before a specific token has been selected.

기능 및 논쟁: totalReserved()
반환 / 지불: uint256

totalRetiredRead only · permanent supply reduction

Content capacity permanently retired by pool releases. It cannot be minted or reallocated later.

기능 및 논쟁: totalRetired()
반환 / 지불: uint256

totalSupplyRead only · circulating contents

Circulating collectible contents, excluding sealed pack wrappers. Use totalSupplyOf or tokens for an individual wrapper or card ID.

기능 및 논쟁: totalSupply()
반환 / 지불: uint256

totalSupplyOfRead only · per-token circulation

Circulating copies of one token ID, including sealed packs. Successful opening burns a wrapper and reduces its circulating count.

기능 및 논쟁: totalSupplyOf(uint256 tokenId)
반환 / 지불: uint256

uriRead only · token metadata

Returns the stored metadata reference for a token, or an empty string for an unknown ID. V2 references are fixed; V3 owners may correct unfrozen references.

기능 및 논쟁: uri(uint256 tokenId)
반환 / 지불: string

validatorRead only · immutable initial binding

Initial validator bound into the factory/implementation at deployment for provenance. It does not change when a collection replaces or disables its active validator. Read getTransferValidator on the collection for the active setting.

기능 및 논쟁: validator()
반환 / 지불: address

Writable functions

acceptOwnershipPending owner · completes two-step transfer

The nominated wallet accepts collection control, including administration of its paired pack engine. Existing holders and reserved pack contents stay unchanged.

기능 및 논쟁: acceptOwnership()
반환 / 지불: No return value

allocatePoolPaired engine only

Moves unused content capacity into pool accounting, respecting token and collection caps. It does not mint tokens.

기능 및 논쟁: allocatePool(uint256 id, uint256 amount)
반환 / 지불: No return value

closeMintingOwner · ONE WAY

Permanently stops new content minting, token configuration, pool allocation and pack issuance. Already issued packs can still request opening within their schedule and deliver reserved contents.

기능 및 논쟁: closeMinting()
반환 / 지불: No return value

configurePackTokenPaired engine only · ONCE per token ID

Creates the sealed wrapper token, cap and transferability while the engine configures a pack. Holders and owners cannot call this ledger method directly.

기능 및 논쟁: configurePackToken(uint256 tokenId, string tokenURI_, uint256 cap, bool transferable)
반환 / 지불: No return value

configureTokenOwner · ONCE per token ID, before mint closure

Defines an unused nonzero collectible ID, a nonempty metadata URI up to 2,048 bytes and a positive lifetime cap. Token identity and cap cannot later change.

기능 및 논쟁: configureToken(uint256 tokenId, string tokenURI_, uint256 maxLifetimeMinted)
반환 / 지불: No return value

configureTokensOwner · bounded batch, before mint closure

Defines 1–50 collectible IDs atomically, with matching URI and cap arrays. Existing IDs cannot be redefined.

기능 및 논쟁: configureTokens(uint256[] ids, string[] uris, uint256[] caps)
반환 / 지불: No return value

consumePackPaired engine only

Burns one locked wrapper and delivers its exact reserved contents. Receiver rejection rolls back burning, delivery and accounting together.

기능 및 논쟁: consumePack(address opener, uint256 packId, uint256[] ids, uint256[] amounts, address recipient)
반환 / 지불: No return value

initializeFactory only · ONCE

Binds the clone to its collection or engine during factory deployment. A second initialization or direct implementation initialization is rejected.

기능 및 논쟁: initialize(address creator, address engine, bytes32 galleryId_, string name_, string symbol_, address receiver, uint96 bps, uint256 cap)
반환 / 지불: No return value

initializeERC1155BLOCKED after initialization

Inherited initializer already consumed during factory deployment. It cannot reinitialize a deployed collection.

기능 및 논쟁: initializeERC1155(string uri_)
반환 / 지불: No return value

issuePackPaired engine only

Mints sealed wrappers after the paired engine has reserved contents and provider capacity. Owners must use the engine issuance method.

기능 및 논쟁: issuePack(uint256 id, uint256 amount, address recipient)
반환 / 지불: No return value

lockPackPaired engine only

Locks one available wrapper in the opener wallet while its opening is pending. No separate holder approval is required for this engine path.

기능 및 논쟁: lockPack(address opener, uint256 packId)
반환 / 지불: No return value

mintBatchOwner · before mint closure

Mints unallocated content to a recipient: 1–20 array entries and at most 400 copies in total. All quantities are positive. Caps, pooled inventory and receiver checks apply atomically.

기능 및 논쟁: mintBatch(uint256[] ids, uint256[] amounts, address recipient)
반환 / 지불: No return value

mintFromSalePaired engine only

Mints 1–20 direct-sale copies from unallocated capacity, after the paired engine validates the purchase.

기능 및 논쟁: mintFromSale(uint256 tokenId, uint256 quantity, address recipient)
반환 / 지불: No return value

releasePoolPaired engine only

Updates pool accounting for an engine-authorized release. Cannot release exact reserved contents; retirement permanently reduces remaining mint capacity.

기능 및 논쟁: releasePool(uint256 id, uint256 amount, bool retire)
반환 / 지불: No return value

renounceOwnershipBLOCKED · including owner calls

Always reverts. V2 and V3 disable renunciation so required collection and engine administration cannot be abandoned this way.

기능 및 논쟁: renounceOwnership()
반환 / 지불: No return value

reserveContentsPaired engine only

Records aggregate contents promised by newly issued sealed packs, bounded by allocated inventory.

기능 및 논쟁: reserveContents(uint256 amount)
반환 / 지불: No return value

reserveTokenPaired engine only

Marks exact selected token copies as reserved when a seeded opening is allocated.

기능 및 논쟁: reserveToken(uint256 id, uint256 amount)
반환 / 지불: No return value

safeBatchTransferFromHolder or approved operator

Transfers matching ID/amount arrays with ERC-1155 approvals, validator and receiver checks. Duplicate entries cannot bypass locked-pack accounting.

기능 및 논쟁: safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] amounts, bytes data)
반환 / 지불: No return value

safeTransferFromHolder or approved operator

Transfers ERC-1155 copies with holder/operator permission, validator checks and receiver acceptance. Nontransferable wrappers and locked opening copies cannot move. There is no separate enableTrading gate in V2/V3.

기능 및 논쟁: safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes data)
반환 / 지불: No return value

setApprovalForAllToken holder · repeatable approval/revocation

Grants or revokes an operator’s ability to transfer all of the caller’s collection tokens. It cannot transfer collection administrator ownership.

기능 및 논쟁: setApprovalForAll(address operator, bool approved)
반환 / 지불: No return value

setAutomaticApprovalOfTransfersFromValidatorBLOCKED after initialization

Inherited upstream setter. Disabled after factory initialization; the collection owner cannot use it to grant automatic validator approval.

기능 및 논쟁: setAutomaticApprovalOfTransfersFromValidator(bool autoApprove)
반환 / 지불: No return value

setContractURIOwner · repeatable

Changes collection-level metadata, up to 2,048 bytes; an empty value clears it. Separate from individual token URIs and V3 token freezes.

기능 및 논쟁: setContractURI(string value)
반환 / 지불: No return value

setDefaultRoyaltyOwner · repeatable

Sets a nonzero royalty recipient and rate from 0 to 1,000 basis points (10%). Does not change a phase payout recipient or guarantee marketplace enforcement.

기능 및 논쟁: setDefaultRoyalty(address receiver, uint96 bps)
반환 / 지불: No return value

setTransferValidatorFactory initialization / internal guarded call only · direct calls BLOCKED

Inherited setter visible in the ABI. Direct calls after initialization are BLOCKED, including owner calls. Use the guarded updateTransferValidator function to replace, disable or restore the active validator.

기능 및 논쟁: setTransferValidator(address transferValidator_)
반환 / 지불: No return value

transferOwnershipOwner · two-step handover

Nominates the next collection owner. That address must accept. A zero address cancels the nomination without renouncing ownership.

기능 및 논쟁: transferOwnership(address newOwner)
반환 / 지불: No return value

updateTransferValidatorOwner · repeatable

Replaces the active validator or disables it with zero. Holder approvals, pack locks and royalties data remain. Nonzero replacements must satisfy upstream code checks; compatible policy setup remains separate. Automatic validator approval stays disabled.

기능 및 논쟁: updateTransferValidator(address next)
반환 / 지불: No return value

Sale requests and gift recipients

PhaseConfig.packId may name either a sealed pack or a direct collectible. Prices exclude the signed platform fee and gas. A zero phase or wallet cap means no limit at that level; actual inventory and lifetime caps still apply. A nonzero payoutRecipient receives the sale price immediately.

MintRequest binds phaseId, quantity, expectedVersion, payer nonce, maxUnitPrice, recipient, allowance and allowlistPrice. Gifts send tokens to recipient while the payer signs, pays and consumes its own phase allowance. buyPack also serves direct-item phases.

A quote does not reserve stock or authorize payment. Phase edits, expiry, inventory consumption, provider availability and receiver acceptance can still prevent a purchase. Metadata URIs are references, not proof that externally hosted content will remain unchanged.