@simplenft/api 0.1.0

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

@@ -0,0 +1,226 @@
+/*
+    This file provides traits for the NFT Auction contract, allowing users to bid on NFTs. 
+    When the auction ends, the NFT goes to the highest bidder and the seller receives the bid amount. 
+
+    Reference:
+    [Official Implementation](https://github.com/ton-blockchain/token-contract/blob/991bdb4925653c51b0b53ab212c53143f71f5476/nft/nft-marketplace.fc)
+    [Official Implementation](https://github.com/ton-blockchain/token-contract/blob/991bdb4925653c51b0b53ab212c53143f71f5476/nft/nft-sale.fc)
+    [NFT Auction Template](https://github.com/avolabs-io/nft-auction)
+*/
+
+trait NFTAuctionStandard {
+    virtual const minTonsForStorage: Int = ton("0.03");
+    virtual const gasConsumption: Int = ton("0.03");
+
+    owner: Address;
+    nftAddress: Address;
+    seller: Address;
+    auctionInfo: AuctionInfo;
+    auctionBidPeriod: Int;
+    isInitialized: Int;
+    auctionEndTime: Int;
+
+    //********************************************//
+    //                  Messages                  //
+    //********************************************//
+
+    // @dev Default receive function to receive funds
+    receive() {}
+
+    // @dev Initializes the auction when called by the owner
+    receive(msg: BuildNftAuction) {
+        let ctx: Context = context();
+        require(ctx.sender == self.owner, "Only owner can build nft auction contract");
+        require(self.isInitialized == 0, "Contract is already initialized");
+        require(msg.auctionInfo.buyNowPrice > msg.auctionInfo.reservePrice, "BuyNowPrice must be greater than reservePrice");
+        self.auctionInfo = msg.auctionInfo;
+        self.isInitialized = 1;
+        self.auctionBidPeriod = 0;
+        self.auctionEndTime = 0;
+    }
+
+    // @dev Accepts bids for the NFT as long as the auction is active
+    receive("Bid") {
+        // Check if auction is still active.
+        require(now() < self.auctionEndTime || self.auctionEndTime == 0, "Auction ended");
+        require(self.isInitialized == 1, "Contract is not initialized");
+        require(now() < self.auctionBidPeriod | self.auctionBidPeriod ==0, "Auction bid period ended");
+
+        let ctx: Context = context();
+        let buyer: Address = ctx.sender;
+        require(buyer != self.auctionInfo.nftSeller, "NFT Seller cannot bid");
+        let bidValue: Int = ctx.value;
+        let buyNowPrice: Int = self.auctionInfo.buyNowPrice;
+        if(bidValue >= buyNowPrice) {
+            self.auctionInfo.nftHighestBid = bidValue;
+            // Pay winning bid amount to seller.
+            self._send_winning_bid_amount();
+            // Transfer NFT to buyer
+            self._transfer_nft(buyer);
+            self.isInitialized = 0;
+            return;
+        }
+
+        let bidIncreaseAmount: Int = (self.auctionInfo.nftHighestBid * (10000 + self.auctionInfo.bidIncreasePercentage)) / 10000;
+        require(bidValue > bidIncreaseAmount, "Bid doesn't meet the minimum increase requirement");
+        // Send back previous highest bid to previous highest bidder.
+        let prevNftHighestBidder: Address = self.auctionInfo.nftHighestBidder;
+        let prevNftHighestBid: Int = self.auctionInfo.nftHighestBid;
+        let paybackTon: Int = max(prevNftHighestBid - self.minTonsForStorage - self.gasConsumption,0);
+        send(SendParameters{
+            to: prevNftHighestBidder,
+            value: paybackTon, 
+            mode: SendPayGasSeparately, 
+            bounce: false,
+            body: "Pay bid money back to the prevNftHighestBidder".asComment()
+        });
+        // Update highest bid and Transfer ton back to previous highest bidder.
+        self.auctionInfo.nftHighestBidder = ctx.sender;
+        self.auctionInfo.nftHighestBid = bidValue;
+        // If bid value is greater than reserve price, then the auction is being started.
+        if(bidValue > self.auctionInfo.reservePrice) {
+            self._update_auction_bid_period();
+            if(self.auctionEndTime == 0) { 
+                // If the auction start, then set the auction end time.
+                self._update_auction_end_time();
+            }
+        }
+    }
+
+    // @dev Settles the auction, transferring the NFT to the highest bidder and the funds to the seller
+    receive("settleAuction") {
+        require(now() >= self.auctionBidPeriod, "Auction not yet ended");
+        // Pay winning bid amount to seller.
+        self._send_winning_bid_amount();
+
+        // Transfer NFT to buyer
+        let buyer: Address = self.auctionInfo.nftHighestBidder;
+        self._transfer_nft(buyer);
+        self.isInitialized = 0;
+    }
+
+    // @dev Allows owner to adjust auction's reserve or buy-now prices.
+    receive(msg: ReviseAuction) {
+        let ctx: Context = context();
+        require(ctx.sender == self.owner, "Only owner can revise auction contract");
+        require(self.auctionInfo.reservePrice == msg.reviseAuctionInfo.reservePrice || msg.reviseAuctionInfo.buyNowPrice == self.auctionInfo.buyNowPrice, "Cannot update reserve price and buy now price at the same time.");
+
+        // Update the reserve price of the auction.
+        // This can only be done if no bid has been made that already exceeds the original minimum price.
+        if(self.auctionEndTime == 0 && self.auctionInfo.reservePrice != msg.reviseAuctionInfo.reservePrice && msg.reviseAuctionInfo.reservePrice < self.auctionInfo.buyNowPrice) {
+
+            self.auctionInfo.reservePrice = msg.reviseAuctionInfo.reservePrice;
+            if(self.auctionInfo.nftHighestBid > self.auctionInfo.reservePrice) {
+                self._update_auction_bid_period();
+                self._update_auction_end_time();
+            }
+        }
+        // Update the buy now price of the auction.
+        // This can only be done if no bid has been made that already exceeds the original minimum price.
+        if(self.auctionEndTime == 0 && msg.reviseAuctionInfo.buyNowPrice != self.auctionInfo.buyNowPrice && msg.reviseAuctionInfo.buyNowPrice > self.auctionInfo.reservePrice) {
+            self.auctionInfo.buyNowPrice = msg.reviseAuctionInfo.buyNowPrice;
+        }
+    }
+
+    // @dev Ends the auction and transfers the NFT to the highest bidder or back to the seller(If autcion not started)
+    receive("EndAuction") {
+        // If this auction started, it will transfer NFT to highest bidder.
+        // Else, it will transfer NFT to seller.
+        if(self.auctionEndTime > 0) {
+            // Pay royalty to the creator of the NFT
+            // TODO: Implement royalty payment
+            
+            // Pay winning bid amount to seller.
+            self._send_winning_bid_amount();
+            // Transfer NFT to buyer
+            let buyer: Address = self.auctionInfo.nftHighestBidder;
+            self._transfer_nft(buyer);
+            self.isInitialized = 0;
+        }
+        else {
+            // Transfer NFT to seller
+            let seller: Address = self.auctionInfo.nftSeller;
+            self._transfer_nft(seller);
+            self.isInitialized = 0;
+        }
+    }
+
+    //********************************************//
+    //             Internal functions             //
+    //********************************************//
+
+    // @dev Updates the auction bid period time based on the latest bid and the defined auction bid period
+    virtual inline fun _update_auction_bid_period() {
+        self.auctionBidPeriod = now() + self.auctionInfo.auctionBidPeriod;
+    }
+
+    // @dev Updates the auction end time
+    virtual inline fun _update_auction_end_time() {
+        self.auctionEndTime = now() + self.auctionInfo.auctionPeriod;
+    }
+
+    // @dev Transfer the NFT to the highest bidder
+    // @note If you want change msg value, you should make sure that is enough for NFT Auction market contract to transfer NFT.
+    virtual inline fun _transfer_nft(buyer: Address) {
+        send(SendParameters{
+            to: self.owner, 
+            value: ton("0.06"), 
+            bounce: true,
+            mode: SendPayGasSeparately,
+            body: TransferNFT {
+                nftAddress: self.nftAddress,
+                seller: self.auctionInfo.nftSeller,
+                query_id: 0,
+                new_owner: buyer,
+                response_destination: buyer,
+                custom_payload: emptyCell(),
+                forward_amount: 0,
+                forward_payload: emptySlice()
+            }.toCell()
+        });
+    }
+
+    // @dev Transfers the highest bid amount to the seller
+    virtual inline fun _send_winning_bid_amount() {
+        let seller: Address = self.auctionInfo.beneficiary;
+        let winningBidAmount: Int = self.auctionInfo.nftHighestBid;
+        send(SendParameters{
+            to: seller,
+            value: winningBidAmount - ton("0.06"), 
+            mode: SendPayGasSeparately, 
+            bounce: false,
+            body: "Pay winning bid amount".asComment()
+        });
+    }
+
+    // @dev Initializes the auction end time to 0, allowing the seller to auction the NFT again in the future
+    virtual inline fun _init_auction_end() {
+        let ctx: Context = context();
+        require(ctx.sender == self.owner, "Only owner can init auction end time.");
+        self.auctionBidPeriod = 0;
+    }
+
+    //*********************************//
+    //             Getters             //
+    //*********************************//
+
+    // @dev Returns the current auction information
+    get fun get_auctin_info(): AuctionInfo {
+        return self.auctionInfo;
+    }
+
+    // @dev Checks if the auction is initialized and returns the state (1 for initialized, 0 otherwise)
+    get fun get_is__initialized(): Int {
+        return self.isInitialized;
+    }
+
+    // @dev Returns the end time of the auction
+    get fun get_auction_end(): Int {
+        return self.auctionEndTime;
+    }
+
+    // @dev Retruns the auction bid period
+    get fun get_auction_bid_period(): Int {
+        return self.auctionBidPeriod;
+    }
+}

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

@@ -0,0 +1,302 @@
+/*
+    This file provides traits for NFT auction market which can be easily used in a permissionless and flexible manner to auction (or simply buy/sell) NFTs. 
+    Sellers and bidders are able to make customized auctions and bids that allow for a holistic NFT auction/sale mechanism.
+
+    Reference:
+    [Official Implementation](https://github.com/ton-blockchain/token-contract/blob/991bdb4925653c51b0b53ab212c53143f71f5476/nft/nft-marketplace.fc)
+    [Official Implementation](https://github.com/ton-blockchain/token-contract/blob/991bdb4925653c51b0b53ab212c53143f71f5476/nft/nft-sale.fc)
+    [NFT Auction Template](https://github.com/avolabs-io/nft-auction)
+*/
+import "./NFTItem";
+
+message SetUpAuction {
+    nftAddress: Address;            // NFT address to be auctioned
+    reservePrice: Int as coins;     // minimum bid price to start the auction timer
+    buyNowPrice: Int as coins;      // price at which the NFT can be directly bought
+    auctionPeriod: Int as uint256;  // time when the auction ends after it starts
+    beneficiary: Address?;           // the address of the beneficiary
+}
+
+message ReviseSetUpAuction {
+    nftAddress: Address;            // NFT address to be auctioned
+    reservePrice: Int as coins;     // minimum bid price to start the auction timer
+    buyNowPrice: Int as coins;      // price at which the NFT can be directly bought
+    auctionPeriod: Int as uint256;  // time when the auction ends after it starts
+    beneficiary: Address?;           // the address of the beneficiary
+    // TODO: beneficiary: Address?;           // the address of the beneficiary
+}
+
+message ReviseAuction {
+    reviseAuctionInfo: AuctionInfo;
+}
+
+message BuildNftAuction {
+    auctionInfo: AuctionInfo;
+}
+
+message EndAuction {
+    nftAddress: Address;    
+}
+
+// @dev This message is used to ask NFT auction market contract to transfer NFT to the new owner
+message TransferNFT {
+    nftAddress: Address;
+    seller: Address;
+    query_id: Int as uint64;            
+    new_owner: Address; 
+    response_destination: Address; 
+    custom_payload: Cell?; 
+    forward_amount: Int as coins; 
+    forward_payload: Slice as remaining;  
+}
+
+// @dev This struct is used to store auction information
+// @note If you want to use custom auction parameters or logic, consider overriding this struct and setUpAuction function in a derived contract
+struct AuctionInfo {
+    bidIncreasePercentage: Int as uint256;  // the minimum percentage by which a new bid must exceed the current highest bid
+    auctionBidPeriod: Int as uint256;       // increments the length of time the auction is open in which a new bid can be made after each bid
+    auctionPeriod: Int as uint256;          // the time at which the auction will end
+    reservePrice: Int as coins;             // the minimum price that must be paid for the NFT
+    buyNowPrice: Int as coins;              // the price that must be paid for the NFT if the buyer chooses to buy it now
+    nftHighestBid: Int as coins;            // the highest bid that has been made so far
+    nftHighestBidder: Address;              // the address of the bidder who has made the highest bid so far
+    nftSeller: Address;                     // the address of the seller
+    whitelistedBuyer: Address;              // the seller can specify a whitelisted address for a sale (this is effectively a direct sale)
+    nftRecipient: Address;                  // the bidder can specify a recipient for the NFT if their bid is successful
+    beneficiary: Address;                  // the address of the beneficiary
+}
+
+trait NFTAuctionMarketStandard {
+    owner: Address;
+    // Check whether nft is transfered to NFT Auction Market Contract
+    auctionTransferCheck: map<Int, Int>; // key => hash(sellerAddress and nftAddress), vlaue => 1: set, 0: not set
+    // Check whether nft auction is over or not
+    auctionOverCheck: map<Address, Address>;  // key => nft auction contract address, value => 1: not over, 0: over
+
+    // @dev Default parameters for setting up an NFT auction
+    virtual const defaultBidIncreasePercentage: Int = 100;
+    virtual const defaultAuctionBidPeriod: Int = 86400; // 1 day
+    virtual const minimumSettableIncreasePercentage: Int = 100;
+    virtual const maximumMinPricePercentage: Int = 8000;
+
+    //********************************************//
+    //                  Messages                  //
+    //********************************************//
+
+    // Default receive function to receive funds
+    receive() {}
+    
+    // @dev Processes the OwnershipAssigned message and updates auction mappings,
+    //      and confirms NFT transfer to the Auction Market.
+    receive(msg: OwnershipAssigned) {
+        let ctx: Context = context();
+        let prev_owner: Address = msg.prev_owner; // Seller Address
+        let nftAddress: Address = ctx.sender;
+        let hashSellerNftAddress: Int = self.get_hash_seller_nft_address(prev_owner, nftAddress);
+        // Set nft transfer checking to 1
+        self.auctionTransferCheck.set(hashSellerNftAddress, 1);
+        let payload: Slice = msg.forward_payload;
+        
+        if(payload.empty() == false) {  
+            self._parse_forward_payload(prev_owner, nftAddress, payload);
+        }
+    }
+
+    // @dev Handles the receipt of a SetUpAuction message.
+    //      First, it verifies if the NFT has been transferred to the NFT Auction Market Contract.
+    //      Upon successful validation, it sets up the auction for the specified NFT and deploys 
+    //      a new NFT Auction Contract instance for it.
+    receive(msg: SetUpAuction) {
+        let ctx: Context = context();
+        let sellerAddress: Address = ctx.sender;
+        let hashSellerNftAddress: Int = self.get_hash_seller_nft_address(sellerAddress, msg.nftAddress);
+        self._auction_transfer_validate(hashSellerNftAddress);
+        if(msg.beneficiary == null) {
+            msg.beneficiary = sellerAddress;
+        }
+        // Set up auction info
+        let auctionInfo: AuctionInfo = self._set_up_auction(sellerAddress, msg.nftAddress, msg.reservePrice, msg.buyNowPrice, msg.auctionPeriod, msg.beneficiary!!); // set up auction
+        self._set_price_validate(msg.buyNowPrice, msg.reservePrice);
+        let nftAuctionInit: StateInit = self._nft_auction_init(msg.nftAddress, sellerAddress);
+        let nftAuctionAddress: Address = self.get_nft_auction_address(msg.nftAddress, sellerAddress);
+        self._auction_set_validate(nftAuctionAddress);
+        self.auctionOverCheck.set(nftAuctionAddress, msg.nftAddress);
+
+        // Deploy a new NFT Auction Contract
+        self._build_auction(nftAuctionAddress, auctionInfo, nftAuctionInit);
+    }
+
+    // @dev Handles the TransferNFT message and facilitates NFT transfer to the auction's winning bidder.
+    receive(msg: TransferNFT) {
+        let ctx: Context = context();
+        let nftAuctionAddress: Address = ctx.sender;
+        self._auction_not_set_validate(nftAuctionAddress);
+        send(SendParameters{
+            to: msg.nftAddress, 
+            value: 0, 
+            bounce: false,
+            mode: SendRemainingValue,
+            body: Transfer {
+                query_id: msg.query_id,
+                new_owner: msg.new_owner,
+                response_destination: msg.response_destination,
+                custom_payload: msg.custom_payload,
+                forward_amount: msg.forward_amount,
+                forward_payload: msg.forward_payload
+            }.toCell()
+        });
+        self.auctionOverCheck.set(ctx.sender, null);
+        let hashSellerNftAddress: Int = self.get_hash_seller_nft_address(msg.seller, msg.nftAddress);
+        self.auctionTransferCheck.set(hashSellerNftAddress, null);
+    }
+
+    // @dev Updates auction details after verifying NFT transfer and previous auction setup, then communicates the update to the nftAuctionAddress.
+    receive(msg: ReviseSetUpAuction) {
+        let ctx: Context = context();
+        let sellerAddress: Address = ctx.sender;
+        let hashSellerNftAddress: Int = self.get_hash_seller_nft_address(sellerAddress, msg.nftAddress);
+        self._auction_transfer_validate(hashSellerNftAddress);
+        // Get nft auction address
+        let nftAuctionAddress: Address = self.get_nft_auction_address(msg.nftAddress, sellerAddress);
+        self._auction_not_set_validate(nftAuctionAddress);
+        if(msg.beneficiary == null) {
+            msg.beneficiary = sellerAddress;
+        }
+        // Set up auction info
+        let auctionInfo: AuctionInfo = self._set_up_auction(sellerAddress, msg.nftAddress, msg.reservePrice, msg.buyNowPrice, msg.auctionPeriod, msg.beneficiary!!); // set up auction
+        self.auctionOverCheck.set(nftAuctionAddress, msg.nftAddress);
+        let newAuctionInfo: AuctionInfo = self._set_up_auction(sellerAddress, msg.nftAddress, msg.reservePrice, msg.buyNowPrice, msg.auctionPeriod, msg.beneficiary!!); // set up auction
+        send(SendParameters{
+                to: nftAuctionAddress,
+                value: 0,
+                mode: SendRemainingValue,
+                bounce: false,
+                body: ReviseAuction {
+                    reviseAuctionInfo: newAuctionInfo
+                }.toCell()
+            }
+        );
+    }
+
+    // @dev Allows the seller to terminate an auction. 
+    //      It verifies if the auction was previously set and then sends a message to the nftAuctionAddress to conclude the auction.
+    //      It will transfer the NFT to the highest bidder or back to the seller(If autcion not started).
+    receive(msg: EndAuction) {
+        // Seller can end auction.
+        let ctx: Context = context();
+        let sellerAddress: Address = ctx.sender;
+        let hashSellerNftAddress: Int = self.get_hash_seller_nft_address(sellerAddress, msg.nftAddress);
+        let nftAuctionAddress: Address = self.get_nft_auction_address(msg.nftAddress, sellerAddress);
+        self._auction_not_set_validate(nftAuctionAddress);
+        send(SendParameters{
+                to: nftAuctionAddress,
+                value: 0,
+                mode: SendRemainingValue,
+                bounce: false,
+                body: "EndAuction".asComment()
+            }
+        );
+    }
+
+    //********************************************//
+    //             Internal functions             //
+    //********************************************//
+
+    virtual inline fun _parse_forward_payload(seller: Address, nftAddress: Address, payload: Slice) {
+        // Parse payload
+        let beneficiary: Address = payload.loadAddress();
+        let reservePrice: Int = payload.loadCoins();
+        let buyNowPrice: Int = payload.loadCoins();
+        let auctionPeriod: Int = payload.loadUint(256);
+
+        // Set up auction info
+        let auctionInfo: AuctionInfo = self._set_up_auction(seller, nftAddress, reservePrice, buyNowPrice, auctionPeriod, beneficiary); // set up auction
+        self._set_price_validate(buyNowPrice, reservePrice);
+        let nftAuctionInit: StateInit = self._nft_auction_init(nftAddress, seller);
+        let nftAuctionAddress: Address = self.get_nft_auction_address(nftAddress, seller);
+        self._auction_set_validate(nftAuctionAddress);
+        self.auctionOverCheck.set(nftAuctionAddress, nftAddress);
+
+        // Deploy a new NFT Auction Contract
+        self._build_auction(nftAuctionAddress, auctionInfo, nftAuctionInit);
+    }
+
+    virtual inline fun _build_auction(nftAuctionAddress: Address, auctionInfo: AuctionInfo, nftAuctionInit: StateInit) {
+        send(SendParameters{
+                to: nftAuctionAddress,
+                value: 0,
+                mode: SendRemainingValue,
+                bounce: false,
+                body: BuildNftAuction {
+                    auctionInfo: auctionInfo
+                }.toCell(),
+                code: nftAuctionInit.code, 
+                data: nftAuctionInit.data
+            }
+        );
+    }
+    
+    virtual inline fun _set_price_validate(buyNowPrice: Int, reservePrice: Int) {
+        require(buyNowPrice > reservePrice, "BuyNowPrice must be greater than reservePrice.");
+    }
+
+    virtual inline fun _auction_set_validate(nftAuctionAddress: Address) {
+        require(self.auctionOverCheck.get(nftAuctionAddress) == null, "Auction was already set for this NFT.");
+    }
+
+    virtual inline fun _auction_not_set_validate(nftAuctionAddress: Address) {
+        require(self.auctionOverCheck.get(nftAuctionAddress) != null, "Auction was not set before.");
+    }
+
+    virtual inline fun _auction_transfer_validate(hashSellerNftAddress: Int) {
+        require(self.get_is_auction_transfer_check(hashSellerNftAddress) == 1, "This NFT didn't transfer to NFT Auction Market Contract yet.");
+    }
+
+    // @dev Initializes an auction for a specified NFT with given parameters such as reserve price, buy now price, and auction duration.
+    // @note If you want to use custom auction parameters or logic, consider overriding this function and AuctionInfo struct in a derived contract.
+    virtual inline fun _set_up_auction(sellerAddress: Address, nftAddress: Address, reservePrice: Int, buyNowPrice: Int, auctionPeriod: Int, beneficiary: Address): AuctionInfo {
+        let hashSellerNftAddress: Int = self.get_hash_seller_nft_address(sellerAddress, nftAddress);
+        return AuctionInfo {
+            bidIncreasePercentage: self.defaultBidIncreasePercentage,
+            auctionBidPeriod: self.defaultAuctionBidPeriod,
+            auctionPeriod: auctionPeriod,
+            reservePrice: reservePrice,
+            buyNowPrice: buyNowPrice,
+            nftHighestBid: 0,
+            nftHighestBidder: sellerAddress,
+            nftSeller: sellerAddress,
+            whitelistedBuyer: sellerAddress,
+            nftRecipient: sellerAddress,
+            beneficiary: beneficiary
+        };
+    }
+
+    // @dev Retrieves the initial state for the NFT auction contract.
+    // @note one MUST override this function to provide NFT Auction initCode
+    abstract fun _nft_auction_init(nftAddress: Address, seller: Address): StateInit;
+
+    //*********************************//
+    //             Getters             //
+    //*********************************//
+
+    // @dev Determines the NFT auction contract address.
+    get fun get_nft_auction_address(nftAddress: Address, seller: Address): Address {
+        let nftAuctionInit: StateInit = self._nft_auction_init(nftAddress, seller);
+        return contractAddress(nftAuctionInit);
+    }
+
+    // @dev Generates a hash value based on the seller and NFT address.
+    get fun get_hash_seller_nft_address(seller: Address, nftAddress: Address): Int {
+        return beginCell().storeAddress(seller).storeAddress(nftAddress).endCell().asSlice().hash();
+    }
+
+    // @dev Checks if the auction transfer for a given hash is valid.
+    get fun get_is_auction_transfer_check(hashSellerNftAddress: Int): Int {
+        if(self.auctionTransferCheck.get(hashSellerNftAddress) == null) {
+            return 0;
+        }
+        else {
+            return 1;
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+/*
+    This file provides traits for NFT collections which follows the TEP-0062 standard.
+    https://github.com/ton-blockchain/TEPs/blob/master/text/0062-nft-standard.md
+*/
+
+
+struct CollectionData {
+    next_item_index: Int;     // collection should issue NFT with sequential indexes starting from 1. -1 value implies non-sequential collections.
+    collection_content: Cell; // collection content format should comply with TEP64 
+    owner_address: Address;   // collection owner address, zero address if no owner
+}
+
+trait NFTCollectionStandard {
+    virtual const NFT_COLLECTION_STANDARD_METADATA: String = "meta.json";
+
+    next_item_index: Int;
+    collection_content: Cell;
+    owner_address: Address;
+
+    //********************************************//
+    //             Internal functions             //
+    //********************************************//
+
+    // @dev _get_nft_item_state_init calculates init code for NFT item contract by item index
+    // @note one MUST override this function to provide custom NFT item initCode
+    abstract inline fun _get_nft_item_state_init(index: Int): StateInit;
+
+    // @dev _get_nft_content gets the serial number of the NFT item of this collection and the individual content of this NFT item.
+    //      returns the full content of the NFT item in format that complies with standard TEP-64.
+    // @note one MUST override this function to provide full NFT item content
+    virtual inline fun _get_nft_content(index: Int, individual_content: Cell): Cell {
+        let builder: StringBuilder = beginString();
+        let idvStr: String = individual_content.asSlice().asString();
+        builder.append(idvStr);
+        return builder.toCell();
+    }
+
+    // @dev get_collection_data returns nft collection data
+    virtual inline fun _get_collection_data(): CollectionData {
+        let builder: StringBuilder = beginString();
+        let urlPrefix: String = self.collection_content.asSlice().asString();
+        builder.append(urlPrefix);
+        builder.append(self.NFT_COLLECTION_STANDARD_METADATA);
+        return CollectionData {
+            next_item_index: self.next_item_index,
+            collection_content: builder.toCell(),
+            owner_address: self.owner_address
+        };
+    }
+
+    //*********************************//
+    //             Getters             //
+    //*********************************//
+    
+    get fun get_collection_data(): CollectionData {
+        return self._get_collection_data();
+    }
+
+    // @dev get_nft_address_by_index gets the serial number of NFT item of this collection and returns its address
+    get fun get_nft_address_by_index(index: Int): Address {
+        let initCode: StateInit = self._get_nft_item_state_init(index);
+        return contractAddress(initCode);
+    }
+
+    // @dev get_nft_content calls _get_nft_content and returns the full content of the NFT item in format that complies with standard TEP-64.
+    get fun get_nft_content(index: Int, individual_content: Cell): Cell {
+        return self._get_nft_content(index, individual_content);
+    }
+}