CollectionTemplateEditionNFTs.aes

@compiler >= 6

include "List.aes"
include "Option.aes"
include "Set.aes"
include "String.aes"
include "./core/utils.aes"
include "./core/IAEX141NFTReceiver.aes"

contract CollectionTemplateEditionNFTs =

    datatype event
        // aex141 default
        = Transfer(address, address, int) // from, to, token_id
        | Approval(address, address, int, string) // owner, approved_account, token_id, enabled ("true"/"false")
        | ApprovalForAll(address, address, string) // owner, operator, approved ("true"/"false")
        // mintable_templates extension
        | TemplateCreation(int) // template_id
        | TemplateDeletion(int) // template_id
        | TemplateMint(address, int, int, string) // to, template_id, token_id, edition_serial
        | EditionLimit(int, int) // template_id, limit
        | EditionLimitDecrease(int, int, int) // template_id, old_limit, new_limit
        // mintable_templates_limit extension
        | TemplateLimit(int) // limit
        | TemplateLimitDecrease(int, int) // old_limit, new_limit
        // mutable_attributes extension
        | MutableAttributesUpdate(int, string) // token_id, mutable_attributes
        // burnable extension
        | Burn(address, int) // owner, token_id

    // aex141 default
    datatype metadata_type = URL | OBJECT_ID | MAP
    datatype metadata = MetadataIdentifier(string) | MetadataMap(map(string, string))

    // mintable_templates_limit extension
    datatype template_metadata_type = T_URL | T_MAP

    // aex141 default
    record meta_info =
        { name: string
        , symbol: string
        , base_url: option(string)
        , metadata_type : metadata_type }

    // mintable_templates_limit extension
    record template =
        { immutable_metadata: metadata
        , edition_limit: option(int)
        , edition_supply: int }
    
    record state =
        { owner: address
        , meta_info: meta_info
        , template_metadata_type: template_metadata_type
        , templates: map(int, template)
        , template_counter: int
        , template_supply: int
        , template_limit: int
        , nft_counter: int
        , token_to_owners: map(int, address)
        , owners_to_tokens: map(address, Set.set(int))
        , balances: map(address, int)
        , approvals: map(int, address)
        , operators: map(address, map(address, bool))
        , metadata: map(int, metadata)
        , total_supply: int }

    stateful entrypoint init(name: string, symbol: string, template_limit: int) =
        require(String.length(name) >= 1, "STRING_TOO_SHORT_NAME")
        require(String.length(symbol) >= 1, "STRING_TOO_SHORT_SYMBOL")
        require(template_limit > 0, "TEMPLATE_LIMIT_INVALID")
        Chain.event(TemplateLimit(template_limit))
        { owner = Contract.creator,
          meta_info = { name = name, symbol = symbol, base_url = None, metadata_type = MAP },
          template_metadata_type = T_URL,
          templates = {},
          template_counter = 1,
          template_supply = 0,
          template_limit = template_limit,
          nft_counter = 1,
          token_to_owners = {},
          owners_to_tokens = {},
          balances = {},
          approvals = {},
          operators = {},
          metadata = {},
          total_supply = 0 }

    entrypoint aex141_extensions() : list(string) =
        ["mintable_templates", "mintable_templates_limit","mutable_attributes", "burnable"]

    entrypoint meta_info() : meta_info =
        state.meta_info

    entrypoint metadata(token_id: int) : option(metadata) =
        Map.lookup(token_id, state.metadata)

    entrypoint total_supply() : int =
        state.total_supply

    entrypoint balance(owner: address) : option(int) =
        Map.lookup(owner, state.balances)

    entrypoint owner(token_id: int) : option(address) =
        Map.lookup(token_id, state.token_to_owners)

    stateful entrypoint transfer(to: address, token_id: int, data: option(string)) =
        let from = require_authorized(token_id)
        require(from != to, "SENDER_MUST_NOT_BE_RECEIVER")
        remove_approval(token_id)
        put(state{ balances[from] @balance1 = balance1 - 1
            , balances[to = 0] @balance2 = balance2 + 1
            , token_to_owners[token_id] = to
            , owners_to_tokens[from] @from_tokens = Set.delete(token_id, from_tokens)
            , owners_to_tokens[to = Set.new()] @to_tokens = Set.insert(token_id, to_tokens) })
        switch(invoke_nft_receiver(Some(from), to, token_id, data))
            (true, false) => abort("SAFE_TRANSFER_FAILED")
            _ => Chain.event(Transfer(from, to, token_id))

    stateful entrypoint transfer_to_contract(token_id: int) =
        let to = Call.caller
        require(Address.is_contract(to), "CALLER_MUST_BE_A_CONTRACT")
        let from = require_authorized(token_id)
        require(from != to, "SENDER_MUST_NOT_BE_RECEIVER")
        remove_approval(token_id)
        put(state{ balances[from] @balance1 = balance1 - 1
            , balances[to = 0] @balance2 = balance2 + 1
            , token_to_owners[token_id] = to
            , owners_to_tokens[from] @from_tokens = Set.delete(token_id, from_tokens)
            , owners_to_tokens[to = Set.new()] @to_tokens = Set.insert(token_id, to_tokens) })
        Chain.event(Transfer(from, to, token_id))

    stateful entrypoint approve(approved: address, token_id: int, enabled: bool) =
        require_authorized(token_id)
        if(enabled)
            put(state{approvals[token_id] = approved})
        else
            remove_approval(token_id)
        Chain.event(Approval(Call.caller, approved, token_id, Utils.bool_to_string(enabled)))

    stateful entrypoint approve_all(operator: address, enabled: bool) =
        put(state{operators @ ops = ops{[Call.caller = {}] @ op = op{[operator] = enabled}}})
        Chain.event(ApprovalForAll(Call.caller, operator, Utils.bool_to_string(enabled)))

    entrypoint get_approved(token_id: int) : option(address) =
        Map.lookup(token_id, state.approvals)

    entrypoint is_approved(token_id: int, a: address) : bool =
        switch(Map.lookup(token_id, state.approvals))
            None => false
            Some(o) => o == a

    entrypoint is_approved_for_all(owner: address, operator: address) : bool =
        switch(Map.lookup(owner, state.operators))
            None => false
            Some(ops) =>
                switch(Map.lookup(operator, ops))
                    None => false
                    Some(v) => v

    // mintable_templates extension

    entrypoint template_metadata_type() : template_metadata_type =
        state.template_metadata_type

    entrypoint template(template_id: int) : option(template) =
        Map.lookup(template_id, state.templates)

    entrypoint template_supply() : int =
        state.template_supply

    stateful entrypoint create_template(immutable_metadata: metadata, edition_limit: option(int)) : int =
        require_contract_owner()
        switch(immutable_metadata)
            MetadataMap(_) => require(state.template_metadata_type == T_MAP, "METADATA_TYPE_NOT_ALLOWED")
            MetadataIdentifier(_) => require(state.template_metadata_type == T_URL, "METADATA_TYPE_NOT_ALLOWED")
        let template_id = state.template_counter
        Option.map((limit) =>
            require(limit > 0, "EDITION_LIMIT_INVALID")
            Chain.event(EditionLimit(template_id, limit)), edition_limit)
        if(state.template_limit == state.template_supply)
            abort("TEMPLATE_LIMIT_REACHED")
        put(state{ template_counter = state.template_counter + 1 
            , templates[template_id] =
                { immutable_metadata = immutable_metadata
                , edition_limit = edition_limit
                , edition_supply = 0 }
            , template_supply = state.template_supply + 1 })
        Chain.event(TemplateCreation(template_id))
        template_id

    stateful entrypoint delete_template(template_id: int) =
        require_contract_owner()
        let template = Option.force_msg(Map.lookup(template_id, state.templates), "TEMPLATE_ID_NOT_EXISTS")
        require(template.edition_supply == 0, "TEMPLATE_DELETION_NOT_ALLOWED")
        put(state{ template_supply = state.template_supply - 1
            , templates @ tp = Map.delete(template_id, tp) })
        Chain.event(TemplateDeletion(template_id))

    stateful entrypoint template_mint(to: address, template_id: int, data: option(string)) : int =
        require_contract_owner()
        let template = Option.force_msg(Map.lookup(template_id, state.templates), "TEMPLATE_ID_NOT_EXISTS")
        Option.map((limit) =>
            require(template.edition_supply < limit, "EDITION_LIMIT_EXCEEDED"), template.edition_limit)
        let edition_serial = template.edition_supply + 1
        let token_id = state.nft_counter
        put(state{ nft_counter = state.nft_counter + 1
            , total_supply = state.total_supply + 1
            , balances[to = 0] @balance = balance + 1
            , token_to_owners[token_id] = to
            , owners_to_tokens[to = Set.new()] @owners_tokens = Set.insert(token_id, owners_tokens)
            , metadata[token_id] = MetadataMap(Map.from_list([("template_id", Int.to_str(template_id)), ("edition_serial", Int.to_str(edition_serial))]))
            , templates[template_id] @tp = template {edition_supply = edition_serial } })
        switch(invoke_nft_receiver(None, to, token_id, data))
            (true, false) => abort("SAFE_TRANSFER_FAILED")
            _ => Chain.event(TemplateMint(to, template_id, token_id, Int.to_str(edition_serial)))
        token_id

    stateful entrypoint decrease_edition_limit(template_id: int, new_limit: int) =
        require_contract_owner()
        require(new_limit > 0, "EDITION_LIMIT_INVALID")
        let template = Option.force_msg(Map.lookup(template_id, state.templates), "TEMPLATE_ID_NOT_EXISTS")
        let old_limit = switch(template.edition_limit)
            None =>
                require(template.edition_supply =< new_limit, "MORE_EDITIONS_ALREADY_IN_EXISTENCE")
                put(state{templates[template_id] @tp = template {edition_limit = Some(new_limit) }})
                0
            Some(limit) =>
                if(new_limit > limit)
                    abort("EDITION_LIMIT_INCREASE_NOT_ALLOWED")
                if(new_limit == limit)
                    abort("NO_CHANGE_PROVIDED")
                if(new_limit < template.edition_supply)
                    abort("MORE_EDITIONS_ALREADY_IN_EXISTENCE")
                put(state{templates[template_id] @tp = template {edition_limit = Some(new_limit) }})
                limit
        Chain.event(EditionLimitDecrease(template_id, old_limit, new_limit))

    // mintable_templates_limit extension

    entrypoint template_limit() : int =
        state.template_limit

    stateful entrypoint decrease_template_limit(new_limit: int) =
        require(new_limit > 0, "TEMPLATE_LIMIT_INVALID")
        require_contract_owner()
        let old_limit = state.template_limit
        if(new_limit > old_limit)
            abort("TEMPLATE_LIMIT_INCREASE_NOT_ALLOWED")
        if(new_limit == old_limit)
            abort("NO_CHANGE_PROVIDED")
        if(new_limit < state.template_supply)
            abort("MORE_TEMPLATES_ALREADY_IN_EXISTENCE")
        put(state{template_limit = new_limit})
        Chain.event(TemplateLimitDecrease(old_limit, new_limit))

    // mutable_attributes extension

    stateful entrypoint update_mutable_attributes(token_id: int, mutable_attributes: string) =
        require_contract_owner()
        require(Map.member(token_id, state.token_to_owners), "TOKEN_NOT_EXISTS")
        switch(Map.lookup(token_id, state.metadata))
            None =>
                abort("FATAL_LOGICAL_ERROR_IN_CONTRACT")
            Some(v) =>
                let updated_metadata_map =
                    switch(v)
                        MetadataIdentifier(v) => abort("CORRUPT_METADATA")
                        MetadataMap(v) => MetadataMap(v{["mutable_attributes"] = mutable_attributes})
                put(state{metadata = state.metadata{[token_id] = updated_metadata_map}})
                Chain.event(MutableAttributesUpdate(token_id, mutable_attributes))

    // burnable extension

    stateful entrypoint burn(token_id: int) =
        let owner = require_authorized(token_id)
        remove_approval(token_id)
        put(state{ balances[owner] @balance = balance - 1
            , total_supply = state.total_supply - 1
            , token_to_owners = Map.delete(token_id, state.token_to_owners)
            , owners_to_tokens[owner] @owners_tokens = Set.delete(token_id, owners_tokens) })
        Chain.event(Burn(owner, token_id))

    // not part of AEX-141

    entrypoint get_owned_tokens(owner: address) : list(int) =
        Set.to_list(Map.lookup_default(owner, state.owners_to_tokens, Set.new()))

    // internal helper functions

    function require_contract_owner() =
        require(Call.caller == state.owner, "ONLY_CONTRACT_OWNER_CALL_ALLOWED")

    function require_authorized(token_id: int) : address =
        let owner = switch(owner(token_id))
            None => abort("TOKEN_NOT_EXISTS")
            Some(v) => v
        require(Call.caller == owner || is_approved(token_id, Call.caller) || is_approved_for_all(owner, Call.caller), "ONLY_OWNER_APPROVED_OR_OPERATOR_CALL_ALLOWED")
        owner

    function is_token_owner(token_id: int, a: address) : bool =
        switch(Map.lookup(token_id, state.token_to_owners))
            None => false
            Some(o) => o == a

    stateful function remove_approval(token_id: int) =
        if(Map.member(token_id, state.approvals))
            put(state{ approvals = Map.delete(token_id, state.approvals) })

    stateful function burn_internal(owner: address, token_id: int) =
        put(state{ balances[owner] @balance_owner = balance_owner - 1
            , total_supply = state.total_supply - 1
            , token_to_owners = Map.delete(token_id, state.token_to_owners)
            , owners_to_tokens[owner] @owners_tokens = Set.delete(token_id, owners_tokens) })

    function invoke_nft_receiver(from: option(address), to: address, token_id: int, data: option(string)) : (bool * bool) =
        if(Address.is_contract(to))
            let c = Address.to_contract(to)
            switch(c.on_aex141_received(from, token_id, data, protected = true) : option(bool))
                None => (true, false)
                Some(val) => (true, val)
        else
            (false, false)