# v0.2.17 # { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } from genlayer import * from genlayer.gl.vm import UserError import json import time @gl.evm.contract_interface class NativeRecipient: class View: pass class Write: pass class GenesisLaunchpad(gl.Contract): """ GENESIS Launchpad contract for GenLayer. Option B architecture: - One NFT collection contract is deployed per collection. - This launchpad stores the drop/payment state for each collection_id. - Each launch is linked to a deployed NFT collection contract address. - Paid/free mints record deterministic mint entitlements/token assignments. - The NFT delivery step should be fulfilled by the linked NFT collection contract using its authorised minter flow. - Mint phases may be manually controlled or time-based. When phase configs include start_time/end_time, minting resolves the effective active phase from the current runtime timestamp. IMPORTANT PAYMENT UNIT: - All prices and payment values are stored in wei. - GenLayer native GEN uses 18 decimals: 1 GEN = 10^18 wei. - config_json.price should be sent as a decimal-free string. Storage model: - launches: collection_id -> JSON launch object - launch_ids: numeric index -> collection_id - mint_records: collection_id:wallet:mint_index -> JSON mint record """ owner: str launches: TreeMap[str, str] launch_ids: TreeMap[str, str] mint_records: TreeMap[str, str] total_launches: u256 def __init__(self) -> None: self.owner = str(gl.message.sender_address) self.launches = TreeMap() self.launch_ids = TreeMap() self.mint_records = TreeMap() self.total_launches = u256(0) # --------------------------------------------------------------------- # Writes # --------------------------------------------------------------------- @gl.public.write def create_launch(self, collection_id: str) -> str: """ Backwards-compatible launch creation. For Option B production flow, call create_launch_for_collection so the launch is immediately linked to the deployed NFT collection contract. """ return self.create_launch_internal(collection_id, "") @gl.public.write def create_launch_for_collection(self, collection_id: str, nft_collection_address: str, fulfilment_wallet: str = "") -> str: self.require_text(nft_collection_address, "nft_collection_address") return self.create_launch_internal(collection_id, nft_collection_address, fulfilment_wallet) @gl.public.write def set_nft_collection(self, collection_id: str, nft_collection_address: str) -> str: self.require_text(nft_collection_address, "nft_collection_address") launch = self.require_launch(collection_id) self.require_creator(launch) if int(launch.get("minted", 0)) > 0: raise UserError("Cannot change NFT collection after minting") launch["nft_collection_address"] = nft_collection_address self.launches[collection_id] = self.dumps(launch) return self.dumps(launch) @gl.public.write def set_fulfilment_wallet(self, collection_id: str, fulfilment_wallet: str) -> str: """Allow the creator to register or update the fulfilment wallet for a launch.""" launch = self.require_launch(collection_id) self.require_creator(launch) launch["fulfilment_wallet"] = fulfilment_wallet self.launches[collection_id] = self.dumps(launch) return self.dumps(launch) @gl.public.write def set_base_token_uri(self, collection_id: str, base_token_uri: str) -> str: self.require_text(base_token_uri, "base_token_uri") launch = self.require_launch(collection_id) self.require_creator(launch) launch["base_token_uri"] = base_token_uri self.launches[collection_id] = self.dumps(launch) return self.dumps(launch) @gl.public.write def configure_phase(self, collection_id: str, phase: str, config_json: str) -> str: self.require_allowed_phase(phase) if phase in ("sold_out", "ended", "paused", "flagged"): raise UserError("Cannot configure terminal or control phase") launch = self.require_launch(collection_id) self.require_creator(launch) config = self.loads(config_json) if not isinstance(config, dict): raise UserError("config_json must encode an object") price = self.non_negative_amount(config.get("price", "0"), "price") mint_limit = self.positive_int(config.get("mint_limit_per_wallet", 1), "mint_limit_per_wallet") max_supply = self.positive_int(config.get("max_supply", 1), "max_supply") start_time = self.non_negative_amount(config.get("start_time", 0), "start_time") end_time = self.non_negative_amount(config.get("end_time", 0), "end_time") whitelist = config.get("whitelist", []) if start_time > 0 and end_time > 0 and end_time < start_time: raise UserError("end_time must be greater than or equal to start_time") if not isinstance(whitelist, list): raise UserError("whitelist must be a list") normalized_whitelist = [] for wallet in whitelist: if isinstance(wallet, str) and wallet.strip() != "": normalized_whitelist.append(wallet) normalized_config = { "price": str(price), "mint_limit_per_wallet": mint_limit, "max_supply": max_supply, "whitelist": normalized_whitelist, "start_time": int(start_time), "end_time": int(end_time), } configured_phases = launch.get("configured_phases", {}) configured_phases[phase] = normalized_config launch["configured_phases"] = configured_phases if max_supply > int(launch.get("max_supply", 0)): launch["max_supply"] = max_supply self.launches[collection_id] = self.dumps(launch) return self.dumps(launch) @gl.public.write def start_launch(self, collection_id: str) -> str: launch = self.require_launch(collection_id) self.require_creator(launch) if str(launch.get("nft_collection_address", "")) == "": raise UserError("NFT collection contract is not linked") configured_phases = launch.get("configured_phases", {}) if "private_whitelist" in configured_phases: launch["phase"] = "private_whitelist" elif "allowlist" in configured_phases: launch["phase"] = "allowlist" elif "public" in configured_phases: launch["phase"] = "public" elif "free_mint" in configured_phases: launch["phase"] = "free_mint" else: raise UserError("Launch has no configured mint phase") launch["manual_phase_override"] = False self.launches[collection_id] = self.dumps(launch) return self.dumps(launch) @gl.public.write def set_phase(self, collection_id: str, phase: str) -> str: self.require_allowed_phase(phase) launch = self.require_launch(collection_id) self.require_creator(launch) configured_phases = launch.get("configured_phases", {}) if phase in ("private_whitelist", "allowlist", "public", "free_mint"): if phase not in configured_phases: raise UserError("Phase is not configured") launch["phase"] = phase launch["manual_phase_override"] = True self.launches[collection_id] = self.dumps(launch) return self.dumps(launch) @gl.public.write def clear_phase_override(self, collection_id: str) -> str: """Return the launch to automatic time-based phase resolution.""" launch = self.require_launch(collection_id) self.require_creator(launch) launch["manual_phase_override"] = False self.launches[collection_id] = self.dumps(launch) return self.dumps(launch) @gl.public.write def pause_launch(self, collection_id: str) -> str: launch = self.require_launch(collection_id) self.require_creator(launch) launch["phase"] = "paused" launch["manual_phase_override"] = True self.launches[collection_id] = self.dumps(launch) return self.dumps(launch) @gl.public.write.payable def public_mint(self, collection_id: str, quantity: int) -> str: return self.mint_internal(collection_id, "public", quantity, True) @gl.public.write.payable def whitelist_mint(self, collection_id: str, quantity: int, proof_json: str) -> str: launch = self.require_launch(collection_id) active_phase = self.get_effective_phase_internal(launch) if active_phase not in ("private_whitelist", "allowlist"): raise UserError("Whitelist mint is not active") configured_phases = launch.get("configured_phases", {}) config = configured_phases.get(active_phase, {}) wallet = str(gl.message.sender_address) proof = self.loads(proof_json) if not isinstance(proof, list): raise UserError("proof_json must encode a list") whitelist = config.get("whitelist", []) if wallet not in whitelist and wallet not in proof: raise UserError("Wallet is not whitelisted") return self.mint_internal(collection_id, active_phase, quantity, True) @gl.public.write def free_mint(self, collection_id: str, quantity: int) -> str: return self.mint_internal(collection_id, "free_mint", quantity, False) @gl.public.write def reveal(self, collection_id: str, base_uri: str) -> str: self.require_text(base_uri, "base_uri") launch = self.require_launch(collection_id) self.require_creator(launch) launch["revealed"] = True launch["base_uri"] = base_uri if str(launch.get("base_token_uri", "")) == "": launch["base_token_uri"] = base_uri self.launches[collection_id] = self.dumps(launch) return self.dumps(launch) @gl.public.write def mark_mint_fulfilled(self, collection_id: str, wallet: str, mint_index: int) -> str: """ Marks a Launchpad mint entitlement as fulfilled after tokens are minted in the linked GenesisNFTCollection contract. Callable by the launch creator OR the registered fulfilment_wallet so that the off-chain fulfilment daemon can mark records complete using its own key without requiring the creator's private key on the server. """ self.require_text(wallet, "wallet") launch = self.require_launch(collection_id) self.require_creator_or_fulfilment_wallet(launch) key = self.mint_record_key(collection_id, wallet, mint_index) record = self.require_mint_record_by_key(key) record["status"] = "fulfilled" self.mint_records[key] = self.dumps(record) return self.dumps(record) @gl.public.write def withdraw_funds(self, collection_id: str) -> str: launch = self.require_launch(collection_id) self.require_creator(launch) amount = self.non_negative_amount(launch.get("funds", "0"), "funds") if amount <= 0: raise UserError("No funds to withdraw") creator = str(launch.get("creator", "")) self.require_text(creator, "creator") launch["funds"] = "0" self.launches[collection_id] = self.dumps(launch) self.transfer_native(creator, amount) receipt = { "collection_id": collection_id, "creator": creator, "amount": str(amount), "currency": "GEN", "status": "withdrawn", } return self.dumps(receipt) # --------------------------------------------------------------------- # Views # --------------------------------------------------------------------- @gl.public.view def get_launch(self, collection_id: str) -> str: return self.dumps(self.require_launch(collection_id)) @gl.public.view def get_total_launches(self) -> int: return int(self.total_launches) @gl.public.view def get_launch_id(self, index: int) -> str: if index < 0 or index >= int(self.total_launches): raise UserError("Launch index out of range") return self.launch_ids[str(index)] @gl.public.view def get_creator(self, collection_id: str) -> str: launch = self.require_launch(collection_id) return str(launch.get("creator", "")) @gl.public.view def get_phase(self, collection_id: str) -> str: launch = self.require_launch(collection_id) return str(launch.get("phase", "")) @gl.public.view def get_effective_phase(self, collection_id: str) -> str: launch = self.require_launch(collection_id) return self.get_effective_phase_internal(launch) @gl.public.view def get_current_time(self) -> int: return self.current_timestamp() @gl.public.view def get_minted(self, collection_id: str) -> int: launch = self.require_launch(collection_id) return int(launch.get("minted", 0)) @gl.public.view def get_wallet_minted(self, collection_id: str, wallet: str) -> int: self.require_text(wallet, "wallet") launch = self.require_launch(collection_id) mints_by_wallet = launch.get("mints_by_wallet", {}) return int(mints_by_wallet.get(wallet, 0)) @gl.public.view def get_mint_record(self, collection_id: str, wallet: str, mint_index: int) -> str: self.require_text(wallet, "wallet") return self.dumps(self.require_mint_record_by_key(self.mint_record_key(collection_id, wallet, mint_index))) # --------------------------------------------------------------------- # Internal helpers # --------------------------------------------------------------------- def create_launch_internal(self, collection_id: str, nft_collection_address: str, fulfilment_wallet: str = "") -> str: self.require_text(collection_id, "collection_id") if self.launch_exists(collection_id): raise UserError("Launch already exists") creator = str(gl.message.sender_address) launch = { "collection_id": collection_id, "creator": creator, "nft_collection_address": nft_collection_address, "fulfilment_wallet": fulfilment_wallet, "phase": "draft", "manual_phase_override": False, "configured_phases": {}, "max_supply": 0, "minted": 0, "funds": "0", "revealed": False, "base_uri": "", "base_token_uri": "", "next_token_id": 1, "mints_by_wallet": {}, "mint_records_by_wallet": {}, } self.launches[collection_id] = self.dumps(launch) self.launch_ids[str(int(self.total_launches))] = collection_id self.total_launches = u256(int(self.total_launches) + 1) return self.dumps(launch) def mint_internal(self, collection_id: str, expected_phase: str, quantity: int, paid: bool) -> str: launch = self.require_launch(collection_id) qty = self.positive_int(quantity, "quantity") if str(launch.get("nft_collection_address", "")) == "": raise UserError("NFT collection contract is not linked") current_phase = self.get_effective_phase_internal(launch) if current_phase in ("paused", "flagged", "ended", "sold_out", "draft", "scheduled_inactive"): raise UserError("Launch is not mintable") if current_phase != expected_phase: raise UserError("Requested mint phase is not active") configured_phases = launch.get("configured_phases", {}) config = configured_phases.get(expected_phase, None) if config is None: raise UserError("Phase is not configured") current_minted = int(launch.get("minted", 0)) max_supply = int(config.get("max_supply", 0)) if current_minted + qty > max_supply: raise UserError("Mint exceeds max supply") wallet = str(gl.message.sender_address) mints_by_wallet = launch.get("mints_by_wallet", {}) wallet_minted = int(mints_by_wallet.get(wallet, 0)) wallet_limit = int(config.get("mint_limit_per_wallet", 0)) if wallet_minted + qty > wallet_limit: raise UserError("Mint exceeds wallet limit") unit_price = self.non_negative_amount(config.get("price", "0"), "price") required_value = unit_price * qty if paid else 0 self.require_exact_payment(required_value) start_token_id = int(launch.get("next_token_id", 1)) assigned_tokens = [] token_uris = [] base_token_uri = str(launch.get("base_token_uri", "")) for offset in range(qty): token_number = start_token_id + offset token_id = str(token_number) assigned_tokens.append(token_id) if base_token_uri != "": token_uris.append(base_token_uri + token_id) else: token_uris.append("") launch["next_token_id"] = start_token_id + qty launch["minted"] = current_minted + qty mints_by_wallet[wallet] = wallet_minted + qty launch["mints_by_wallet"] = mints_by_wallet mint_records_by_wallet = launch.get("mint_records_by_wallet", {}) wallet_record_count = int(mint_records_by_wallet.get(wallet, 0)) + 1 mint_records_by_wallet[wallet] = wallet_record_count launch["mint_records_by_wallet"] = mint_records_by_wallet mint_record = { "collection_id": collection_id, "nft_collection_address": str(launch.get("nft_collection_address", "")), "wallet": wallet, "mint_index": wallet_record_count, "phase": expected_phase, "quantity": qty, "token_ids": assigned_tokens, "metadata_uris": token_uris, "paid": paid, "value": str(required_value), "status": "pending_fulfilment", } self.mint_records[self.mint_record_key(collection_id, wallet, wallet_record_count)] = self.dumps(mint_record) if paid: current_funds = self.non_negative_amount(launch.get("funds", "0"), "funds") launch["funds"] = str(current_funds + required_value) if int(launch["minted"]) == max_supply: launch["phase"] = "sold_out" self.launches[collection_id] = self.dumps(launch) return self.dumps(mint_record) def get_effective_phase_internal(self, launch: dict) -> str: stored_phase = str(launch.get("phase", "")) # Control/terminal phases always override schedule-based minting. if stored_phase in ("draft", "paused", "flagged", "sold_out", "ended"): return stored_phase # Explicit creator override remains available for emergencies/manual QA. if bool(launch.get("manual_phase_override", False)): return stored_phase configured_phases = launch.get("configured_phases", {}) if not isinstance(configured_phases, dict): return stored_phase any_scheduled = False now = self.current_timestamp() for phase in ["private_whitelist", "allowlist", "public", "free_mint"]: config = configured_phases.get(phase, None) if not isinstance(config, dict): continue start_time = self.non_negative_amount(config.get("start_time", 0), "start_time") end_time = self.non_negative_amount(config.get("end_time", 0), "end_time") if start_time > 0 or end_time > 0: any_scheduled = True starts_ok = start_time <= 0 or now >= start_time ends_ok = end_time <= 0 or now <= end_time if starts_ok and ends_ok: return phase # Backwards compatibility: old launches/configs with no time windows # continue using the manually stored active phase. if not any_scheduled: return stored_phase return "scheduled_inactive" def current_timestamp(self) -> int: try: return int(time.time()) except Exception: return 0 def require_exact_payment(self, expected_value: int) -> int: if expected_value < 0: raise UserError("expected payment value cannot be negative") actual_value = self.message_value(expected_value) if actual_value != expected_value: raise UserError("Incorrect payment value: expected " + str(expected_value) + ", received " + str(actual_value)) return actual_value def message_value(self, expected_value: int) -> int: candidates = ["value", "amount", "transaction_value"] for field in candidates: try: raw_value = getattr(gl.message, field) return self.non_negative_amount(raw_value, "message value") except Exception: pass if expected_value == 0: return 0 raise UserError("Native transaction value is not available in this GenLayer runtime") def transfer_native(self, recipient: str, amount: int) -> None: if amount <= 0: raise UserError("transfer amount must be positive") self.require_text(recipient, "recipient") NativeRecipient(Address(recipient)).emit_transfer(value=u256(amount)) def require_launch(self, collection_id: str) -> dict: self.require_text(collection_id, "collection_id") if not self.launch_exists(collection_id): raise UserError("Unknown launch") parsed = self.loads(self.launches[collection_id]) if not isinstance(parsed, dict): raise UserError("Stored launch is invalid") return parsed def launch_exists(self, collection_id: str) -> bool: try: value = self.launches[collection_id] return isinstance(value, str) and value != "" except Exception: return False def mint_record_key(self, collection_id: str, wallet: str, mint_index: int) -> str: return collection_id + ":" + wallet + ":" + str(mint_index) def require_mint_record_by_key(self, key: str) -> dict: try: value = self.mint_records[key] except Exception: raise UserError("Unknown mint record") if not isinstance(value, str) or value == "": raise UserError("Unknown mint record") parsed = self.loads(value) if not isinstance(parsed, dict): raise UserError("Stored mint record is invalid") return parsed def require_creator(self, launch: dict) -> None: if str(gl.message.sender_address) != str(launch.get("creator", "")): raise UserError("Only launch creator can perform this action") def require_creator_or_fulfilment_wallet(self, launch: dict) -> None: caller = str(gl.message.sender_address) creator = str(launch.get("creator", "")) fulfilment = str(launch.get("fulfilment_wallet", "")) if caller != creator and (not fulfilment or caller != fulfilment): raise UserError("Only launch creator or registered fulfilment wallet can perform this action") def require_text(self, value: str, label: str) -> None: if not isinstance(value, str) or value.strip() == "": raise UserError(label + " is required") def require_allowed_phase(self, phase: str) -> None: self.require_text(phase, "phase") allowed = ["draft", "private_whitelist", "allowlist", "public", "free_mint", "paused", "flagged", "sold_out", "ended"] if phase not in allowed: raise UserError("Invalid launch phase") def positive_int(self, value, label: str) -> int: try: parsed = int(value) except Exception: raise UserError(label + " must be an integer") if parsed <= 0: raise UserError(label + " must be a positive integer") return int(parsed) def non_negative_amount(self, value, label: str) -> int: try: parsed = int(value) except Exception: raise UserError(label + " must be an integer amount") if parsed < 0: raise UserError(label + " must be a non-negative amount") return int(parsed) def loads(self, value: str): try: parsed = json.loads(value) except Exception: raise UserError("Invalid JSON") if not isinstance(parsed, dict) and not isinstance(parsed, list): raise UserError("JSON must encode an object or list") return parsed def dumps(self, value) -> str: return json.dumps(value, sort_keys=True, separators=(",", ":"))