module launchpad_addr::launchpad { use std::option::{Self, Option}; use std::signer; use std::string::{Self, String}; use std::vector; use aptos_std::table::{Self, Table}; use aptos_framework::aptos_account; use aptos_framework::event; use aptos_framework::fungible_asset::{Self, Metadata}; use aptos_framework::object::{Self, Object, ObjectCore}; use aptos_framework::primary_fungible_store; /// Only admin can update creator const EONLY_ADMIN_CAN_UPDATE_CREATOR: u64 = 1; /// Only admin can set pending admin const EONLY_ADMIN_CAN_SET_PENDING_ADMIN: u64 = 2; /// Sender is not pending admin const ENOT_PENDING_ADMIN: u64 = 3; /// Only admin can update mint fee collector const EONLY_ADMIN_CAN_UPDATE_MINT_FEE_COLLECTOR: u64 = 4; /// No mint limit const ENO_MINT_LIMIT: u64 = 5; /// Mint limit reached const EMINT_LIMIT_REACHED: u64 = 6; /// Default to mint 0 amount to creator when creating FA const DEFAULT_PRE_MINT_AMOUNT: u64 = 0; /// Default mint fee per smallest unit of FA denominated in oapt (smallest unit of APT, i.e. 1e-8 APT) const DEFAULT_mint_fee_per_smallest_unit_of_fa: u64 = 0; #[event] struct CreateFAEvent has store, drop { creator_addr: address, fa_owner_obj: Object, fa_obj: Object, max_supply: Option, name: String, symbol: String, decimals: u8, icon_uri: String, project_uri: String, mint_fee_per_smallest_unit_of_fa: u64, pre_mint_amount: u64, mint_limit_per_addr: Option, } #[event] struct MintFAEvent has store, drop { fa_obj: Object, amount: u64, recipient_addr: address, total_mint_fee: u64, } /// Unique per FA /// We need this object to own the FA object instead of contract directly owns the FA object /// This helps us avoid address collision when we create multiple FAs with same name struct FAOwnerObjConfig has key { // Only thing it stores is the link to FA object fa_obj: Object } /// Unique per FA struct FAController has key { mint_ref: fungible_asset::MintRef, burn_ref: fungible_asset::BurnRef, transfer_ref: fungible_asset::TransferRef, } /// Unique per FA struct MintLimit has store { limit: u64, mint_tracker: Table, } /// Unique per FA struct FAConfig has key { // Mint fee per FA denominated in oapt (smallest unit of APT, i.e. 1e-8 APT) mint_fee_per_smallest_unit_of_fa: u64, mint_limit: Option, fa_owner_obj: Object, } /// Global per contract struct Registry has key { fa_objects: vector>, } /// Global per contract struct Config has key { // admin can set pending admin, accept admin, update mint fee collector admin_addr: address, pending_admin_addr: Option

, mint_fee_collector_addr: address, } /// If you deploy the module under an object, sender is the object's signer /// If you deploy the moduelr under your own account, sender is your account's signer fun init_module(sender: &signer) { move_to(sender, Registry { fa_objects: vector::empty() }); move_to(sender, Config { admin_addr: signer::address_of(sender), pending_admin_addr: option::none(), mint_fee_collector_addr: signer::address_of(sender), }); } // ================================= Entry Functions ================================= // /// Set pending admin of the contract, then pending admin can call accept_admin to become admin public entry fun set_pending_admin(sender: &signer, new_admin: address) acquires Config { let sender_addr = signer::address_of(sender); let config = borrow_global_mut(@launchpad_addr); assert!(is_admin(config, sender_addr), EONLY_ADMIN_CAN_SET_PENDING_ADMIN); config.pending_admin_addr = option::some(new_admin); } /// Accept admin of the contract public entry fun accept_admin(sender: &signer) acquires Config { let sender_addr = signer::address_of(sender); let config = borrow_global_mut(@launchpad_addr); assert!(config.pending_admin_addr == option::some(sender_addr), ENOT_PENDING_ADMIN); config.admin_addr = sender_addr; config.pending_admin_addr = option::none(); } /// Update mint fee collector address public entry fun update_mint_fee_collector(sender: &signer, new_mint_fee_collector: address) acquires Config { let sender_addr = signer::address_of(sender); let config = borrow_global_mut(@launchpad_addr); assert!(is_admin(config, sender_addr), EONLY_ADMIN_CAN_UPDATE_MINT_FEE_COLLECTOR); config.mint_fee_collector_addr = new_mint_fee_collector; } /// Create a fungible asset, only admin or creator can create FA public entry fun create_fa( sender: &signer, max_supply: Option, name: String, symbol: String, // Number of decimal places, i.e. APT has 8 decimal places, so decimals = 8, 1 APT = 1e-8 oapt decimals: u8, icon_uri: String, project_uri: String, // Mint fee per smallest unit of FA denominated in oapt (smallest unit of APT, i.e. 1e-8 APT) mint_fee_per_smallest_unit_of_fa: Option, // Amount in smallest unit of FA pre_mint_amount: Option, // Limit of minting per address in smallest unit of FA mint_limit_per_addr: Option, ) acquires Registry, FAController { let sender_addr = signer::address_of(sender); let fa_owner_obj_constructor_ref = &object::create_object(@launchpad_addr); let fa_owner_obj_signer = &object::generate_signer(fa_owner_obj_constructor_ref); let fa_obj_constructor_ref = &object::create_named_object( fa_owner_obj_signer, *string::bytes(&name), ); let fa_obj_signer = &object::generate_signer(fa_obj_constructor_ref); primary_fungible_store::create_primary_store_enabled_fungible_asset( fa_obj_constructor_ref, max_supply, name, symbol, decimals, icon_uri, project_uri ); let fa_obj = object::object_from_constructor_ref(fa_obj_constructor_ref); move_to(fa_owner_obj_signer, FAOwnerObjConfig { fa_obj, }); let fa_owner_obj = object::object_from_constructor_ref(fa_owner_obj_constructor_ref); let mint_ref = fungible_asset::generate_mint_ref(fa_obj_constructor_ref); let burn_ref = fungible_asset::generate_burn_ref(fa_obj_constructor_ref); let transfer_ref = fungible_asset::generate_transfer_ref(fa_obj_constructor_ref); move_to(fa_obj_signer, FAController { mint_ref, burn_ref, transfer_ref, }); move_to(fa_obj_signer, FAConfig { mint_fee_per_smallest_unit_of_fa: *option::borrow_with_default(&mint_fee_per_smallest_unit_of_fa, &DEFAULT_mint_fee_per_smallest_unit_of_fa), mint_limit: if (option::is_some(&mint_limit_per_addr)) { option::some(MintLimit { limit: *option::borrow(&mint_limit_per_addr), mint_tracker: table::new() }) } else { option::none() }, fa_owner_obj, }); let registry = borrow_global_mut(@launchpad_addr); vector::push_back(&mut registry.fa_objects, fa_obj); event::emit(CreateFAEvent { creator_addr: sender_addr, fa_owner_obj, fa_obj, max_supply, name, symbol, decimals, icon_uri, project_uri, mint_fee_per_smallest_unit_of_fa: *option::borrow_with_default(&mint_fee_per_smallest_unit_of_fa, &DEFAULT_mint_fee_per_smallest_unit_of_fa), pre_mint_amount: *option::borrow_with_default(&pre_mint_amount, &DEFAULT_PRE_MINT_AMOUNT), mint_limit_per_addr, }); if (*option::borrow_with_default(&pre_mint_amount, &DEFAULT_PRE_MINT_AMOUNT) > 0) { let amount = *option::borrow(&pre_mint_amount); mint_fa_internal(sender, fa_obj, amount, 0); } } /// Mint fungible asset, anyone with enough mint fee and has not reached mint limit can mint FA public entry fun mint_fa( sender: &signer, fa_obj: Object, amount: u64 ) acquires FAController, FAConfig, Config { let sender_addr = signer::address_of(sender); check_mint_limit_and_update_mint_tracker(sender_addr, fa_obj, amount); let total_mint_fee = get_mint_fee(fa_obj, amount); pay_for_mint(sender, total_mint_fee); mint_fa_internal(sender, fa_obj, amount, total_mint_fee); } // ================================= View Functions ================================== // #[view] /// Get contract admin public fun get_admin(): address acquires Config { let config = borrow_global(@launchpad_addr); config.admin_addr } #[view] /// Get contract pending admin public fun get_pendingadmin(): Option

acquires Config { let config = borrow_global(@launchpad_addr); config.pending_admin_addr } #[view] /// Get mint fee collector address public fun get_mint_fee_collector(): address acquires Config { let config = borrow_global(@launchpad_addr); config.mint_fee_collector_addr } #[view] /// Get all fungible assets created using this contract public fun get_registry(): vector> acquires Registry { let registry = borrow_global(@launchpad_addr); registry.fa_objects } #[view] /// Get fungible asset metadata public fun get_fa_objects_metadatas( collection_obj: Object ): (String, String, u8) { let name = fungible_asset::name(collection_obj); let symbol = fungible_asset::symbol(collection_obj); let decimals = fungible_asset::decimals(collection_obj); (symbol, name, decimals) } #[view] /// Get mint limit per address public fun get_mint_limit( fa_obj: Object, ): Option acquires FAConfig { let fa_config = borrow_global(object::object_address(&fa_obj)); if (option::is_some(&fa_config.mint_limit)) { option::some(option::borrow(&fa_config.mint_limit).limit) } else { option::none() } } #[view] /// Get current minted amount by an address public fun get_current_minted_amount( fa_obj: Object, addr: address ): u64 acquires FAConfig { let fa_config = borrow_global(object::object_address(&fa_obj)); assert!(option::is_some(&fa_config.mint_limit), ENO_MINT_LIMIT); let mint_limit = option::borrow(&fa_config.mint_limit); let mint_tracker = &mint_limit.mint_tracker; *table::borrow_with_default(mint_tracker, addr, &0) } #[view] /// Get mint fee denominated in oapt (smallest unit of APT, i.e. 1e-8 APT) public fun get_mint_fee( fa_obj: Object, // Amount in smallest unit of FA amount: u64, ): u64 acquires FAConfig { let fa_config = borrow_global(object::object_address(&fa_obj)); amount * fa_config.mint_fee_per_smallest_unit_of_fa } // ================================= Helper Functions ================================== // /// Check if sender is admin or owner of the object when package is published to object fun is_admin(config: &Config, sender: address): bool { if (sender == config.admin_addr) { true } else { if (object::is_object(@launchpad_addr)) { let obj = object::address_to_object(@launchpad_addr); object::is_owner(obj, sender) } else { false } } } /// Check mint limit and update mint tracker fun check_mint_limit_and_update_mint_tracker( sender: address, fa_obj: Object, amount: u64, ) acquires FAConfig { let mint_limit = get_mint_limit(fa_obj); if (option::is_some(&mint_limit)) { let old_amount = get_current_minted_amount(fa_obj, sender); assert!( old_amount + amount <= *option::borrow(&mint_limit), EMINT_LIMIT_REACHED, ); let fa_config = borrow_global_mut(object::object_address(&fa_obj)); let mint_limit = option::borrow_mut(&mut fa_config.mint_limit); table::upsert(&mut mint_limit.mint_tracker, sender, old_amount + amount) } } /// ACtual implementation of minting FA fun mint_fa_internal( sender: &signer, fa_obj: Object, amount: u64, total_mint_fee: u64, ) acquires FAController { let sender_addr = signer::address_of(sender); let fa_obj_addr = object::object_address(&fa_obj); let fa_controller = borrow_global(fa_obj_addr); primary_fungible_store::mint(&fa_controller.mint_ref, sender_addr, amount); event::emit(MintFAEvent { fa_obj, amount, recipient_addr: sender_addr, total_mint_fee, }); } /// Pay for mint fun pay_for_mint( sender: &signer, total_mint_fee: u64 ) acquires Config { if (total_mint_fee > 0) { let config = borrow_global(@launchpad_addr); aptos_account::transfer(sender, config.mint_fee_collector_addr, total_mint_fee) } } // ================================= Uint Tests ================================== // #[test_only] use aptos_framework::aptos_coin; #[test_only] use aptos_framework::coin; #[test_only] use aptos_framework::account; #[test(aptos_framework = @0x1, sender = @launchpad_addr)] fun test_happy_path( aptos_framework: &signer, sender: &signer, ) acquires Registry, FAController, Config, FAConfig { let (burn_cap, mint_cap) = aptos_coin::initialize_for_test(aptos_framework); let sender_addr = signer::address_of(sender); init_module(sender); // create first FA create_fa( sender, option::some(1000), string::utf8(b"FA1"), string::utf8(b"FA1"), 2, string::utf8(b"icon_url"), string::utf8(b"project_url"), option::none(), option::none(), option::some(500) ); let registry = get_registry(); let fa_1 = *vector::borrow(®istry, vector::length(®istry) - 1); assert!(fungible_asset::supply(fa_1) == option::some(0), 1); mint_fa(sender, fa_1, 20); assert!(fungible_asset::supply(fa_1) == option::some(20), 2); assert!(primary_fungible_store::balance(sender_addr, fa_1) == 20, 3); // create second FA create_fa( sender, option::some(1000), string::utf8(b"FA2"), string::utf8(b"FA2"), 3, string::utf8(b"icon_url"), string::utf8(b"project_url"), option::some(1), option::none(), option::some(500) ); let registry = get_registry(); let fa_2 = *vector::borrow(®istry, vector::length(®istry) - 1); assert!(fungible_asset::supply(fa_2) == option::some(0), 4); account::create_account_for_test(sender_addr); coin::register(sender); let mint_fee = get_mint_fee(fa_2, 300); aptos_coin::mint(aptos_framework, sender_addr, mint_fee); mint_fa(sender, fa_2, 300); assert!(fungible_asset::supply(fa_2) == option::some(300), 5); assert!(primary_fungible_store::balance(sender_addr, fa_2) == 300, 6); coin::destroy_burn_cap(burn_cap); coin::destroy_mint_cap(mint_cap); } }

Fungible Asset (ERC-20) Launchpad