Something went wrong. Try again.
Monorepo for Aesthetic.Computer aesthetic.computer
Something went wrong. Try again.
Python
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505"""KidLisp Keeps FA2 v9 - Aesthetic Computer NFT Contract (AUTHOR-PERMITTED KEEP)
This contract is the v9 final production release with signed keep author permits.
v9 CHANGES from v8:- keep requires backend-issued signature (author permit)- keep signature binds: contract + owner + content_hash + deadline- keep still preserves v7 creator refresh metadata policy- immutable fields remain preserved: content_hash + royalties
v7/v6 features (preserved):- default fee: 2.5 XTZ (revenue enabled by default)- owner-only burn_keep- default royalty support- emergency pause/unpause and admin transfer"""
import smartpy as spfrom smartpy.templates import fa2_lib as fa2
main = fa2.main
@sp.moduledef keeps_module(): import main
KEEP_PERMIT_SIGNER = sp.key("edpktwf7pNMMfRcMoxHANoFtJLgGhJLwTsiSqaEMB2CnnSDTeLKoF6")
# Order of inheritance: [Admin], [<policy>], <base class>, [<other mixins>]. class KidLispKeepsFA2v9( main.Admin, main.Nft, main.OnchainviewBalanceOf, ): """ FA2 NFT contract for KidLisp Keeps (v9 - FINAL SIGNED-PERMIT PRODUCTION).
v9 changes from v8: - keep requires a valid backend signature ("keep permit") - keep permit is bound to owner + content_hash + contract + deadline - owner/creator edit_metadata model remains from v7 """
def __init__(self, admin_address, contract_metadata, ledger, token_metadata): # Initialize on-chain balance view main.OnchainviewBalanceOf.__init__(self)
# Initialize the NFT base class main.Nft.__init__(self, contract_metadata, ledger, token_metadata)
# Initialize administrative permissions main.Admin.__init__(self, admin_address)
# Additional storage for metadata locking self.data.metadata_locked = sp.cast( sp.big_map(), sp.big_map[sp.nat, sp.bool] )
# Track content hashes to prevent duplicate mints # Maps content_hash (bytes) -> token_id (nat) self.data.content_hashes = sp.cast( sp.big_map(), sp.big_map[sp.bytes, sp.nat] )
# Track original creator for each token (v3) # Maps token_id -> creator address (the first minter) self.data.token_creators = sp.cast( sp.big_map(), sp.big_map[sp.nat, sp.address] )
# Contract-level metadata lock flag self.data.contract_metadata_locked = False
# Mint fee configuration (admin-adjustable) # v5/v6/v7/v8/v9: Default fee set to 2.5 XTZ for revenue activation self.data.keep_fee = sp.mutez(2500000)
# v4: Emergency pause flag # When true, minting and metadata edits are disabled self.data.paused = False
# v4+: Default royalty configuration # Basis points: 1000 = 10%, 2500 = 25% (max) # Applied to all new mints unless overridden self.data.default_royalty_bps = 1000 # 10% default
@sp.entrypoint def keep(self, params): """ Mint a new Keep token with minimal on-chain metadata.
Full metadata lives in IPFS (via metadata_uri). On-chain stores only the essential fields needed for display and deduplication.
Two modes: 1. Admin calling: mints to specified owner (for server-side minting) 2. User calling: mints to sender, requires fee payment (default 2.5 XTZ)
All bytes parameters should be raw hex-encoded UTF-8 strings. """ sp.cast(params, sp.record( name=sp.bytes, symbol=sp.bytes, description=sp.bytes, artifactUri=sp.bytes, displayUri=sp.bytes, thumbnailUri=sp.bytes, decimals=sp.bytes, creators=sp.bytes, royalties=sp.bytes, content_hash=sp.bytes, metadata_uri=sp.bytes, owner=sp.address, permit_deadline=sp.timestamp, keep_permit=sp.signature ))
# Check if contract is paused assert not self.data.paused, "MINTING_PAUSED"
# Determine minting mode and owner is_admin = self.is_administrator_()
# Non-admin callers must pay the fee and can only mint to themselves if not is_admin: assert sp.amount >= self.data.keep_fee, "INSUFFICIENT_FEE" # User must mint to themselves (prevents delegated/spam flows) assert params.owner == sp.sender, "MUST_MINT_TO_SELF"
# Verify signed keep permit from backend authorizer. permit_payload = sp.record( contract=sp.self_address, owner=params.owner, content_hash=params.content_hash, permit_deadline=params.permit_deadline, ) sp.cast( permit_payload, sp.record( contract=sp.address, owner=sp.address, content_hash=sp.bytes, permit_deadline=sp.timestamp, ).layout(("contract", ("owner", ("content_hash", "permit_deadline")))) ) assert sp.now <= params.permit_deadline, "PERMIT_EXPIRED" assert sp.check_signature( KEEP_PERMIT_SIGNER, params.keep_permit, sp.pack(permit_payload) ), "INVALID_KEEP_PERMIT"
# Check for duplicate content hash assert not self.data.content_hashes.contains(params.content_hash), "DUPLICATE_CONTENT_HASH"
# Get next token ID from the library's counter token_id = self.data.next_token_id
# Minimal on-chain token_info — full metadata in IPFS via "" token_info = sp.cast({ "name": params.name, "symbol": params.symbol, "description": params.description, "artifactUri": params.artifactUri, "displayUri": params.displayUri, "thumbnailUri": params.thumbnailUri, "decimals": params.decimals, "creators": params.creators, "royalties": params.royalties, "content_hash": params.content_hash, "metadata_uri": params.metadata_uri, "": params.metadata_uri }, sp.map[sp.string, sp.bytes])
# Store token metadata self.data.token_metadata[token_id] = sp.record( token_id=token_id, token_info=token_info )
# Assign token to owner self.data.ledger[token_id] = params.owner
# Initialize as not locked self.data.metadata_locked[token_id] = False
# Store content hash to prevent duplicates self.data.content_hashes[params.content_hash] = token_id
# Track the original creator self.data.token_creators[token_id] = params.owner
# Increment token counter self.data.next_token_id = token_id + 1
@sp.entrypoint def mint(self, batch): """ Disable generic FA2 mint path. Keeps must be minted through `keep` so fee/dedup rules always apply. """ sp.cast( batch, sp.list[ sp.record( to_=sp.address, metadata=sp.map[sp.string, sp.bytes], ).layout(("to_", "metadata")) ], ) assert False, "MINT_DISABLED_USE_KEEP"
@sp.entrypoint def burn(self, batch): """ Disable generic FA2 burn path. Keeps must be burned through `burn_keep` so all indexes are cleaned. """ sp.cast( batch, sp.list[ sp.record( from_=sp.address, token_id=sp.nat, amount=sp.nat, ).layout(("from_", ("token_id", "amount"))) ], ) assert False, "BURN_DISABLED_USE_BURN_KEEP"
@sp.entrypoint def edit_metadata(self, params): """ Update metadata for an existing token.
Authorization: - Current token owner: full metadata edit - Original creator: refresh-only update path
Respects pause flag (cannot edit when paused). content_hash and royalties are immutable — always preserved from original mint. """ sp.cast(params, sp.record( token_id=sp.nat, token_info=sp.map[sp.string, sp.bytes] ))
# Check if contract is paused assert not self.data.paused, "EDITING_PAUSED"
assert self.data.token_metadata.contains(params.token_id), "FA2_TOKEN_UNDEFINED"
# Check authorization: owner or original creator is_owner = self.data.ledger.get(params.token_id, default=sp.address("tz1burnburnburnburnburnburnburjAYjjX")) == sp.sender is_creator = self.data.token_creators.get(params.token_id, default=sp.address("tz1burnburnburnburnburnburnburjAYjjX")) == sp.sender
assert is_owner or is_creator, "NOT_AUTHORIZED"
# Check if locked is_locked = self.data.metadata_locked.get(params.token_id, default=False) assert not is_locked, "METADATA_LOCKED"
# Preserve immutable content_hash + royalties from original metadata existing_info = self.data.token_metadata[params.token_id].token_info original_hash = existing_info.get("content_hash", default=sp.bytes("0x")) original_royalties = existing_info.get("royalties", default=sp.bytes("0x"))
# Owner can apply full metadata updates. if is_owner: self.data.token_metadata[params.token_id] = sp.record( token_id=params.token_id, token_info=params.token_info ) else: # Original creator refresh path: # only URI/presentation fields can change after transfer. refreshed_info = existing_info mutable_refresh_fields = [ "", "metadata_uri", "artifactUri", "displayUri", "thumbnailUri", "formats", "tags", "attributes", "rights", "content_type", "isBooleanAmount", "shouldPreferSymbol", ] for field in mutable_refresh_fields: if params.token_info.contains(field): refreshed_info[field] = params.token_info[field]
# Keep ""/metadata_uri aligned when either key is provided. if params.token_info.contains("metadata_uri"): refreshed_info[""] = params.token_info["metadata_uri"] if params.token_info.contains(""): refreshed_info["metadata_uri"] = params.token_info[""]
self.data.token_metadata[params.token_id] = sp.record( token_id=params.token_id, token_info=refreshed_info )
# Re-inject immutable fields (cannot be changed or removed via edit) self.data.token_metadata[params.token_id].token_info["content_hash"] = original_hash self.data.token_metadata[params.token_id].token_info["royalties"] = original_royalties
@sp.entrypoint def lock_metadata(self, token_id): """Permanently lock metadata for a token (admin or owner only).""" sp.cast(token_id, sp.nat)
assert self.data.token_metadata.contains(token_id), "FA2_TOKEN_UNDEFINED"
# Check authorization: admin or owner is_admin = self.is_administrator_() is_owner = self.data.ledger.get(token_id, default=sp.address("tz1burnburnburnburnburnburnburjAYjjX")) == sp.sender
assert is_admin or is_owner, "NOT_AUTHORIZED"
self.data.metadata_locked[token_id] = True
@sp.entrypoint def set_contract_metadata(self, params): """Update contract-level metadata (admin only, if not locked).""" sp.cast(params, sp.list[sp.record(key=sp.string, value=sp.bytes)])
assert self.is_administrator_(), "FA2_NOT_ADMIN" assert not self.data.contract_metadata_locked, "CONTRACT_METADATA_LOCKED"
for item in params: self.data.metadata[item.key] = item.value
@sp.entrypoint def lock_contract_metadata(self): """Permanently lock contract-level metadata (admin only).""" assert self.is_administrator_(), "FA2_NOT_ADMIN" self.data.contract_metadata_locked = True
@sp.entrypoint def set_keep_fee(self, new_fee): """ Set the keep fee required for minting. Admin only. Fee is in mutez (1 tez = 1,000,000 mutez). """ sp.cast(new_fee, sp.mutez) assert self.is_administrator_(), "FA2_NOT_ADMIN" self.data.keep_fee = new_fee
@sp.entrypoint def withdraw_fees(self, destination): """ Withdraw accumulated fees from the contract. Admin only. Sends entire contract balance to destination. """ sp.cast(destination, sp.address) assert self.is_administrator_(), "FA2_NOT_ADMIN" sp.send(destination, sp.balance)
@sp.entrypoint def burn_keep(self, token_id): """ Burn a token and remove its content_hash. This allows re-minting the same piece name. Owner only. """ sp.cast(token_id, sp.nat)
assert self.data.token_metadata.contains(token_id), "FA2_TOKEN_UNDEFINED" current_owner = self.data.ledger.get( token_id, default=sp.address("tz1burnburnburnburnburnburnburjAYjjX") ) assert current_owner == sp.sender, "NOT_TOKEN_OWNER"
# Get content_hash before burning token_info = self.data.token_metadata[token_id].token_info content_hash = token_info.get("content_hash", default=sp.bytes("0x"))
# Remove from registries if self.data.content_hashes.contains(content_hash): del self.data.content_hashes[content_hash]
if self.data.ledger.contains(token_id): del self.data.ledger[token_id]
del self.data.token_metadata[token_id]
if self.data.metadata_locked.contains(token_id): del self.data.metadata_locked[token_id]
if self.data.token_creators.contains(token_id): del self.data.token_creators[token_id]
# ===================================================================== # v4 ENTRYPOINTS (preserved in v5) # =====================================================================
@sp.entrypoint def pause(self): """ Emergency pause - stops minting and metadata edits. Admin only.
Use cases: - Security vulnerability discovered - IPFS infrastructure issues - Spam attack detected - Contract bug found
Note: Does NOT affect transfers (preserves FA2 composability) """ assert self.is_administrator_(), "FA2_NOT_ADMIN" self.data.paused = True
@sp.entrypoint def unpause(self): """ Resume normal operations after emergency pause. Admin only. """ assert self.is_administrator_(), "FA2_NOT_ADMIN" self.data.paused = False
@sp.entrypoint def set_default_royalty(self, bps): """ Set default royalty percentage for new mints. Admin only.
Args: bps: Basis points (100 = 1%, 1000 = 10%, 2500 = 25% max)
Example: set_default_royalty(1000) # 10% royalty """ sp.cast(bps, sp.nat) assert self.is_administrator_(), "FA2_NOT_ADMIN" assert bps <= 2500, "MAX_ROYALTY_25_PERCENT" self.data.default_royalty_bps = bps
@sp.entrypoint def admin_transfer(self, params): """Admin emergency transfer""" sp.cast(params, sp.record( token_id=sp.nat, from_=sp.address, to_=sp.address ))
assert self.is_administrator_(), "FA2_NOT_ADMIN" assert self.data.token_metadata.contains(params.token_id), "FA2_TOKEN_UNDEFINED"
current_owner = self.data.ledger.get(params.token_id, default=sp.address("tz1burnburnburnburnburnburnburjAYjjX")) assert current_owner == params.from_, "INVALID_CURRENT_OWNER"
self.data.ledger[params.token_id] = params.to_
def _get_balance(fa2_contract, args): """Utility function to call the contract's get_balance view.""" return sp.View(fa2_contract, "get_balance")(args)
def _total_supply(fa2_contract, args): """Utility function to call the contract's total_supply view.""" return sp.View(fa2_contract, "total_supply")(args)
@sp.add_test()def test(): """Minimal test to compile v9 contract.""" scenario = sp.test_scenario("KeepsFA2v9") scenario.h1("KidLisp Keeps FA2 v9 - Final Signed Permit Production Contract")
# Define test account admin = sp.test_account("Admin")
# Create empty initial state ledger = {} token_metadata = []
# Deploy contract contract = keeps_module.KidLispKeepsFA2v9( admin.address, sp.big_map(), ledger, token_metadata )
scenario += contract
scenario.p("v9: signed keep permits + owner self-mint enforcement") scenario.p("v7: owner full edit + creator refresh-only metadata updates") scenario.p("v6: owner-only burn_keep + royalties immutable after keep")