@simplenft/api 0.1.0

package/contracts/packages/token/nft/NFTItem.tact

@@ -0,0 +1,190 @@
+/*
+    This file provides traits for NFT item which follows the TEP-0062 standard.
+    https://github.com/ton-blockchain/TEPs/blob/master/text/0062-nft-standard.md
+
+    Reference:
+    [Official Implementation](https://github.com/ton-blockchain/token-contract/blob/991bdb4925653c51b0b53ab212c53143f71f5476/nft/nft-item.fc#L17)
+    [NFT Template](https://github.com/howardpen9/nft-template-in-tact/blob/tutorial/sources/contract.tact)
+*/
+
+message(0x5fcc3d14) Transfer {
+    query_id: Int as uint64; // arbitrary request number
+    new_owner: Address; // new owner of the NFT item
+    response_destination: Address; // address where to send a response with confirmation of a successful transfer and the rest of the incoming message coins if not empty address
+    custom_payload: Cell?; // optional custom data
+    forward_amount: Int as coins; // the amount of nanotons to be sent to the new owner
+    forward_payload: Slice as remaining; // optional custom data that should be sent to the new owner
+}
+message(0x05138d91) OwnershipAssigned {
+    query_id: Int as uint64;
+    prev_owner: Address;
+    forward_payload: Slice as remaining;
+}
+message(0xd53276db) Excesses {
+    query_id: Int as uint64;
+}
+message(0x2fcb26a2) GetStaticData {
+    query_id: Int as uint64;
+}
+message(0x8b771735) ReportStaticData {
+    query_id: Int as uint64;
+    index: Int as uint256;
+    collection: Address;
+}
+struct NftData {
+    is_initialized: Bool; // it should be `init`, but it is a reserved keyword in tact. if not zero, then this NFT is fully initialized and ready for interaction.
+    index: Int; // numerical index of this NFT in the collection. For collection-less NFT - arbitrary but constant value.
+    collection_address: Address; // address of the smart contract of the collection to which this NFT belongs. For collection-less NFT this parameter should be addr_none
+    owner_address: Address; // address of the current owner of this NFT
+    individual_content: Cell; // if NFT has collection - individual NFT content in any format; if NFT has no collection - NFT content in format that complies with standard TEP-64
+}
+
+trait NFTItemStandard {
+    virtual const minTonsForStorage: Int = ton("0.05");
+    virtual const gasConsumption: Int = ton("0.05");
+    collection_address: Address;
+    index: Int;
+    owner: Address;
+    individual_content: Cell;
+    is_initialized: Bool;
+
+    //********************************************//
+    //                  Messages                  //
+    //********************************************//
+
+    receive(msg: Transfer){
+        dump("Inside transfer");
+        let ctx: Context = context();
+        let remain: Int = self._transfer_estimate_rest_value(ctx);
+        self._transfer_validate(ctx, msg, remain);
+        if (self.is_initialized == false) {
+            dump("Inside uniniti");
+            self.mint(ctx, msg);
+        } else {
+            dump("Inside correct");
+            self.transfer(ctx, msg, remain)
+        }
+    }
+
+    receive(msg: GetStaticData){
+        self._report_static_data(msg);
+    }
+
+    //********************************************//
+    //             Internal functions             //
+    //********************************************//
+
+    // @dev  _transfer_estimate_rest_value calculates the remain amount of nanotons that should be sent back to the old owner
+    inline fun _transfer_estimate_rest_value(ctx: Context): Int {
+        let remain: Int = ctx.value;
+        let tonBalanceBeforeMsg: Int = myBalance() - remain;
+        let storageFee: Int = self.minTonsForStorage - min(tonBalanceBeforeMsg, self.minTonsForStorage);
+        return remain - (storageFee + self.gasConsumption);
+    }
+
+    // @dev  _transfer_validate checks if the request is valid (e.g. the sender is the current owner of the NFT item)
+    //       throws error if the request is invalid
+    // @note one may override this function to implement custom validation logicTransferked
+
+    virtual inline fun _transfer_validate(ctx: Context, msg: Transfer, remain: Int) {
+        require(ctx.sender == self.owner || ctx.sender == self.collection_address,
+            "NFTItemStandard: Only the owner or collection can transfer the NFT item"
+        );
+        dump("validated succ");
+    }
+
+    // @dev  mint usually performs the minting of the NFT item
+    // @note one may override this function to implement custom minting logic
+
+    virtual inline fun mint(ctx: Context, msg: Transfer) {
+        require(ctx.sender == self.collection_address,
+            "NFTItemStandard: Only the collection can initialize the NFT item"
+        );
+        self.is_initialized = true;
+        self.owner = msg.new_owner;
+        send(SendParameters{
+                to: msg.response_destination,
+                value: 0,
+                mode: SendIgnoreErrors + SendRemainingValue,
+                body: Excesses{query_id: msg.query_id}.toCell()
+            }
+        );
+    }
+
+    // @dev  transfer performs the transfer of the NFT item
+    //      if available, it will send OwnershipAssigned message to the new owner
+    //      then, it will send Excesses message to the response_destination (old owner) if needed.
+    // @note one may override this function to implement custom transfer logic
+
+    virtual inline fun transfer(ctx: Context, msg: Transfer, remain: Int) {
+        self.owner = msg.new_owner;
+        if (msg.forward_amount > 0) {
+            send(SendParameters{
+                    to: msg.new_owner,
+                    value: msg.forward_amount,
+                    mode: SendIgnoreErrors,
+                    bounce: false,
+                    body: OwnershipAssigned{
+                        query_id: msg.query_id,
+                        prev_owner: ctx.sender,
+                        forward_payload: msg.forward_payload
+                    }.toCell()
+                }
+            );
+        }
+        remain = remain - ctx.readForwardFee();
+        if (msg.response_destination != newAddress(0, 0) && remain > msg.forward_amount) {
+            send(SendParameters{
+                    to: msg.response_destination,
+                    value: remain - msg.forward_amount,
+                    mode: SendPayGasSeparately,
+                    body: Excesses{query_id: msg.query_id}.toCell()
+                }
+            );
+        }
+    }
+
+    // @dev  _report_static_data sends a response with the static data of the NFT item
+
+    virtual inline fun _report_static_data(msg: GetStaticData) {
+        let ctx: Context = context();
+        send(SendParameters{
+                to: ctx.sender,
+                value: 0,
+                mode: SendRemainingValue,
+                bounce: false,
+                body: ReportStaticData{
+                    query_id: msg.query_id,
+                    index: self.index,
+                    collection: self.collection_address
+                }.toCell()
+            }
+        );
+    }
+
+    // @dev  _get_nft_data returns the NFT data in the format that complies with TEP-64
+
+    virtual inline fun _get_nft_data(): NftData {
+        let builder: StringBuilder = beginString();
+        let collectionData: String = self.individual_content.asSlice().asString();
+        builder.append(collectionData);
+        builder.append(self.index.toString());
+        builder.append(".json");
+        return
+            NftData{
+                is_initialized: self.is_initialized,
+                index: self.index,
+                collection_address: self.collection_address,
+                owner_address: self.owner,
+                individual_content: builder.toCell()
+            };
+    }
+
+    //*********************************//
+    //             Getters             //
+    //*********************************//
+
+    get fun get_nft_data(): NftData {
+        return self._get_nft_data();
+    }
+}

package/contracts/packages/token/nft/extensions/NFTEditable.tact

@@ -0,0 +1,3 @@
+trait NFTEditable {
+    
+}

package/contracts/packages/token/nft/extensions/NFTRoyalty.tact

@@ -0,0 +1,63 @@
+/*
+    This file provides traits for NFT royalty standard is TEP-0066
+    https://github.com/ton-blockchain/TEPs/blob/master/text/0066-nft-royalty-standard.md
+*/
+
+struct RoyaltyParams {
+    numerator: Int as uint16; // numerator to calculate royalty percentage
+    denominator: Int as uint16; // denominator to calculate royalty percentage
+    destination: Address; // Address to receive royalty
+}
+
+message(0x693d3950) GetRoyaltyParams {
+    query_id: Int as uint64; // arbitrary request number for sending ReportRoyaltyParams back with send mode 64
+}
+
+message(0xa8cb00ad) ReportRoyaltyParams {
+    query_id: Int as uint64; // corresponding request number
+    numerator:  Int as uint16; // numerator to calculate royalty percentage, maximum 65535
+    denominator: Int as uint16; // denominator to calculate royalty percentage, maximum 65535
+    destination: Address; // Address to receive royalty
+}
+
+trait NFTRoyaltyStandard {
+    royalty_params: RoyaltyParams;
+    owner_address: Address;
+
+    //********************************************//
+    //                  Messages                  //
+    //********************************************//
+
+    receive(msg: GetRoyaltyParams) {
+        self.report_royalty_params(msg);
+    }
+
+    //********************************************//
+    //             Internal functions             //
+    //********************************************//
+
+    virtual inline fun report_royalty_params(msg: GetRoyaltyParams) {
+        let ctx: Context = context();
+        send(SendParameters{
+            to: ctx.sender,
+            value: 0,
+            mode: SendRemainingValue, 
+            bounce: false,
+            body: ReportRoyaltyParams {
+                query_id: msg.query_id,
+                numerator:  self.royalty_params.numerator,
+                denominator: self.royalty_params.denominator,
+                destination: self.owner_address
+            }.toCell()
+        });
+    }
+
+
+    //*********************************//
+    //             Getters             //
+    //*********************************//
+
+    get fun royalty_params(): RoyaltyParams {
+        return self.royalty_params;
+    }
+}

package/contracts/packages/traits/taxable.tact

@@ -0,0 +1,31 @@
+
+const codeUnauthorized: Int = 51003;
+
+// SetStaticTax is the message that used to set the static tax fee.
+message(0x1509a420) SetStaticTax {
+    staticTax: Int as coins;
+}
+
+trait Taxable {
+    owner: Address;
+    staticTax: Int;
+
+    receive(msg: SetStaticTax) {
+        self.receiveSetStaticTax(msg);
+    }
+
+    get fun staticTax(): Int {
+        return self.staticTax;
+    }
+
+    virtual fun receiveSetStaticTax(msg: SetStaticTax) {
+        nativeThrowUnless(codeUnauthorized, sender() == self.owner);
+
+        self.staticTax = msg.staticTax;
+        let answer = beginString()
+            .concat("set static tax fee to ")
+            .concat(msg.staticTax.toString())
+            .toString();
+        self.reply(answer.asComment());
+    }
+}

package/contracts/packages/utils/Estimatable.tact

@@ -0,0 +1,11 @@
+trait Estimatable {
+    virtual const gasConsumption: Int = ton("0.05");
+    virtual const minTonsForStorage: Int = ton("0.05");
+
+    virtual fun estimate_rest_value(ctx: Context): Int {
+        let restValue: Int = ctx.value;
+        let tonBalanceBeforeMsg: Int = myBalance() - restValue;
+        let storageFee: Int = self.minTonsForStorage - min(tonBalanceBeforeMsg, self.minTonsForStorage);
+        return restValue - (storageFee + self.gasConsumption);
+    }
+}

package/contracts/packages/utils/Lockable.tact

@@ -0,0 +1,23 @@
+trait Lockable {
+    is_locked: Bool;
+
+    virtual inline fun lock() {
+        self.is_locked = true;
+    }
+
+    virtual inline fun unlock() {
+        self.is_locked = false;
+    }
+
+    virtual inline fun ensureLocked() {
+        require(self.is_locked, "Lockable: Object is not locked");
+    }
+
+    virtual inline fun ensureUnlocked() {
+        require(!self.is_locked, "Lockable: Object is locked");
+    }
+
+    get fun is_locked(): Bool {
+        return self.is_locked;
+    }
+}

package/contracts/sbt_item.tact

@@ -0,0 +1,70 @@
+import "@stdlib/deploy";
+import "./message.tact";
+
+contract SbtItem {
+    collection_address: Address;
+    item_index: Int as uint32; 
+    is_initialized: Bool;
+
+    owner: Address?;
+    individual_content: Cell?;
+
+    init(collection_address: Address, item_index: Int){
+        require(sender() == collection_address, "not from collection");
+        self.collection_address = collection_address;
+        self.item_index = item_index;
+        self.is_initialized = false;
+    }
+
+    receive(msg: Transfer){
+        let ctx: Context = context(); // Reference: https://docs.tact-lang.org/language/ref/common#context
+        let msgValue: Int = self.msgValue(ctx.value);
+        require(self.is_initialized == false, "Sbt transfer for init only");
+        require(ctx.sender == self.collection_address, "initialized tx need from collection");
+        self.is_initialized = true;
+            self.owner = msg.new_owner;
+            self.individual_content = msg.custom_payload;
+            send(SendParameters{
+                to: msg.response_destination!!,
+                value: msgValue,
+                mode: SendPayGasSeparately,
+                body: Excesses { query_id: msg.query_id }.toCell()
+            });
+    }
+    
+    receive(msg: GetStaticData){ 
+        let ctx: Context = context();
+        send(SendParameters {
+            to: ctx.sender,
+            value: 0,
+            mode: 64,  // (return msg amount except gas fees) 
+            bounce: true,
+            body: ReportStaticData{
+                query_id: msg.query_id,
+                index_id: self.item_index,
+                collection: self.collection_address
+            }.toCell()
+        });
+    }
+
+    fun msgValue(value: Int): Int {
+        let tonBalanceBeforeMsg: Int = myBalance() - value;
+        let storageFee: Int = minTonsForStorage - min(tonBalanceBeforeMsg, minTonsForStorage);
+        return value - (storageFee + gasConsumption);
+    }
+
+    // --------- Get Function  --------- //
+    get fun get_nft_data(): GetNftData {
+        let b: StringBuilder = beginString();
+        let collectionData: String = (self.individual_content!!).asSlice().asString();
+        b.append(collectionData);
+
+        return GetNftData {
+            is_initialized: self.is_initialized, 
+            index: self.item_index, 
+            collection_address: self.collection_address, 
+            owner_address: self.owner!!,
+            individual_content: b.toCell()
+        };
+    }
+}

package/contracts/simple_nft_collection.tact

@@ -0,0 +1,177 @@
+import "@stdlib/deploy";
+import "./message.tact";
+import "./nft_item.tact";
+import "./sbt_item.tact";
+
+const nftBalanceConst: Int = ton("0.1");
+
+contract SimpleNftCollection with Deployable {
+
+    next_item_index: Int as uint32 = 0;
+    collection_index: Int as uint32 = 0;
+    owner_address: Address?;
+    master_address: Address;
+    royalty_params: RoyaltyParams?;                      
+    collection_content: Cell?;   
+    individual_content_url: Cell?;
+    mint_limit: Int = 0;
+    price: Int = 0;
+    is_setup: Bool;
+    is_sbt: Int = 0;
+    mint_time_limit: Int = 0;
+
+    init(
+    master_address: Address,
+    collection_index: Int){
+        require(sender() == master_address, "Not from master");
+        self.collection_index = collection_index;
+        self.master_address = master_address;
+        self.is_setup = false;
+    }
+
+    receive(msg: CollectionSetupParams) {
+        require(sender() == self.master_address, "Not from master");
+        require(self.is_setup == false, "Collection settings is already setup");
+        self.price = msg.nft_price;
+        self.mint_limit = msg.mint_limit;
+        self.owner_address = msg.owner_address; // msg.owner_address;
+        self.royalty_params = msg.royalty_params;
+        self.collection_content = msg.collection_content;
+        self.individual_content_url = msg.nft_individual_content_url;
+        self.is_setup = true;
+        self.is_sbt = msg.is_sbt;
+        self.mint_time_limit = msg.mint_time_limit;
+    }
+
+    receive("Mint"){
+        require(self.is_setup == true, "Collection settings is not setup");
+        let ctx: Context = context(); // get sender Info
+        if (self.mint_limit > 0) {
+            require(self.next_item_index <= self.mint_limit, "Mint limit reached");
+        }
+        if (self.mint_time_limit > 0) {
+            require(now() <= self.mint_time_limit, "Mint time limit reached");
+        }
+        require(ctx.value >= self.price, "NFT creation underpriced");
+        let msgValue: Int = ctx.value;
+        let tonBalanceBeforeMsg: Int = myBalance() - msgValue;
+        let storageFee: Int = minTonsForStorage - min(tonBalanceBeforeMsg, minTonsForStorage);
+        msgValue = msgValue - (storageFee + gasConsumption);
+        
+        self.mint(ctx.sender, msgValue);
+
+        emit(LogEventMintRecord{ minter: sender(), item_id: self.next_item_index, generate_number: nativeRandom() }.toCell());
+    }
+
+    // ===== Private Methods ===== //
+
+        fun mint(sender: Address, msgValue: Int) {
+        require(self.next_item_index >= 0, "non-sequential NFTs");
+        let nft_init: StateInit = self.getNftItemInit(self.next_item_index);
+        let feeValue = msgValue - nftBalanceConst;
+        send(SendParameters{
+                to: contractAddress(nft_init), 
+                value: nftBalanceConst, 
+                bounce: false,
+                mode: SendIgnoreErrors,
+                body: Transfer {
+                    query_id: 0,
+                    new_owner: sender,
+                    response_destination: self.owner_address,
+                    custom_payload: self.individual_content_url,
+                    forward_amount: 0,
+                    forward_payload: emptySlice()
+                }.toCell(),
+                code: nft_init.code,
+                data: nft_init.data
+            });
+
+        send(SendParameters{
+            to: self.master_address,
+            value: (feeValue * 3) / 100,
+            bounce: false,
+            mode: SendIgnoreErrors 
+        });
+
+        // let balanceRemaining: Int = myBalance();
+        send(SendParameters{
+            to: self.owner_address!!,
+            value: (feeValue * 97) / 100, // (feeValue * 97) / 100,
+            bounce: false,
+            mode: SendIgnoreErrors 
+        }); 
+        dump(self.next_item_index); // Reference at: https://tact-by-example.org/03-emit
+        self.next_item_index = self.next_item_index + 1;
+    }
+
+    receive(msg: GetRoyaltyParams) {   
+        let ctx: Context = context(); // get sender Info
+        send(SendParameters{
+            to: ctx.sender,
+            value: 0,
+            mode: 64, 
+            bounce: false,
+            body: ReportRoyaltyParams {
+                query_id: msg.query_id,
+                numerator:  (self.royalty_params!!).numerator,
+                denominator: (self.royalty_params!!).denominator,
+                destination: (self.royalty_params!!).destination
+            }.toCell()
+        });        
+    }
+
+    get fun get_master_data(): CollectionMasterData {
+        return CollectionMasterData{
+            master: self.master_address,
+            mint_limit: self.mint_limit,
+            mint_time_limit: self.mint_time_limit,
+            is_sbt: self.is_sbt,
+            price: self.price,
+            index_in_collection: self.collection_index
+        }
+    }
+
+    // ------------------ Get Function  ------------------ //
+    get fun get_collection_data(): CollectionData {     
+        let b: StringBuilder = beginString();
+        let collectionDataString: String = (self.collection_content!!).asSlice().asString();
+        b.append(collectionDataString);
+        return CollectionData{
+            next_item_index: self.next_item_index, 
+            collection_content: b.toCell(), 
+            owner_address: self.owner_address!!
+        };
+    }
+
+    get fun get_nft_address_by_index(item_index: Int): Address?{      
+        let initCode: StateInit = self.getNftItemInit(item_index);
+        return contractAddress(initCode);
+    }
+
+    get fun getNftItemInit(item_index: Int): StateInit {
+        // return initOf NftItem(myAddress(), item_index);
+        if (self.is_sbt == 0) {
+            return initOf NftItem(myAddress(), item_index);
+        } else {
+            return initOf SbtItem(myAddress(), item_index);
+        }
+    }
+    
+    get fun get_nft_content(index: Int, individual_content: Cell): Cell { 
+        let b: StringBuilder = beginString();
+        let ic: String = individual_content.asSlice().asString();
+        b.append(ic);
+        return b.toCell();
+    }
+
+    get fun get_sample_nft_content (): Cell? {
+        let b: StringBuilder = beginString();
+        let ic: String = (self.individual_content_url!!).asSlice().asString();
+        b.append(ic);
+        return b.toCell();
+    }
+
+    get fun royalty_params(): RoyaltyParams {
+        return self.royalty_params!!;
+    }
+}