@simplenft/api 0.1.0

package/contracts/jetton_eq.tact

@@ -0,0 +1,79 @@
+import "@stdlib/deploy";
+import "./packages/token/jetton/JettonMaster";
+import "./packages/token/jetton/JettonWallet";
+
+contract EqJettonWallet with JettonWallet {
+    balance: Int as coins = 0;
+    owner: Address;
+    jetton_master: Address;
+
+    init(owner: Address, jetton_master: Address) {
+        self.owner = owner;
+        self.jetton_master = jetton_master;
+    }
+
+    override inline fun calculate_jetton_wallet_init(owner_address: Address): StateInit {
+        return initOf EqJettonWallet(owner_address, self.jetton_master);
+    }
+}
+
+contract EqJettonMaster with JettonMaster, Deployable {
+    total_supply: Int as coins = 0;
+    mintable: Bool = true;
+    owner: Address;
+    jetton_content: Cell;
+
+    // Fixed calculated value
+    init(owner: Address, jetton_content: Cell, total_supply: Int){
+        let ctx: Context = context();
+        self.owner = owner;
+        self.total_supply = total_supply;
+        self.jetton_content = jetton_content;
+        let msg: JettonMint = JettonMint{
+            origin: ctx.sender,
+            receiver: ctx.sender,
+            amount: total_supply,
+            custom_payload: emptyCell(),
+            forward_ton_amount: 0,
+            forward_payload: emptySlice()
+        };
+        self._mint(ctx, msg);
+    }
+
+    /* receive("Mint:1") {
+        let ctx: Context = context();
+        let msg: JettonMint = JettonMint{
+            origin: ctx.sender,
+            receiver: ctx.sender,
+            amount: ton("1"),
+            custom_payload: emptyCell(),
+            forward_ton_amount: 0,
+            forward_payload: emptySlice()
+        };
+        self._mint_validate(ctx, msg);
+        self._mint(ctx, msg);
+    }
+
+    receive("Mint:Grand") {
+        let ctx: Context = context();
+        let msg: JettonMint = JettonMint{
+            origin: ctx.sender,
+            receiver: ctx.sender,
+            amount: ton("1000"),
+            custom_payload: emptyCell(),
+            forward_ton_amount: 0,
+            forward_payload: emptySlice()
+        };
+        self._mint(ctx, msg);
+    } */
+
+    override inline fun _mint_validate(ctx: Context, msg: JettonMint) {
+        require(self.mintable, "JettonMaster: Jetton is not mintable");
+    }
+
+    override inline fun calculate_jetton_wallet_init(owner_address: Address): StateInit {
+        return initOf EqJettonWallet(owner_address, myAddress());
+    }
+
+
+}

package/contracts/message.tact

@@ -0,0 +1,189 @@
+message LogEventMintRecord {
+    minter: Address;
+    item_id: Int;
+    generate_number: Int;
+}
+
+
+message(0x693d3950) GetRoyaltyParams {
+    query_id: Int as uint64;
+}
+
+message GetProfile {
+    query_id: Int as uint64;
+}
+
+message(0xa8cb00ad) ReportRoyaltyParams {
+    query_id: Int as uint64;
+    numerator: Int as uint16;
+    denominator: Int as uint16;
+    destination: Address;
+}
+
+struct CollectionData {
+    next_item_index: Int;
+    collection_content: Cell;
+    owner_address: Address;
+}
+struct RoyaltyParams {
+    numerator: Int;
+    denominator: Int;
+    destination: Address;
+}
+message CollectionSetupParams {
+    owner_address: Address;
+    master_address: Address;
+    collection_content: Cell; 
+    nft_individual_content_url: Cell;
+    royalty_params: RoyaltyParams;
+    mint_limit: Int;
+    nft_price: Int;
+    mint_time_limit: Int;
+    is_sbt: Int;
+    enable_profile: Bool;
+    enable_whitelist: Bool;
+    user_item_limit: Int;
+}
+
+message UpdateWhiteList {
+    user: Address;
+    whitelist: Bool;
+}
+
+message AddToWhiteList {
+    add: Bool;
+}
+
+message CollectionMintParams {
+    queryId: Int;
+    owner_address: Address;
+    collection_content: Cell; 
+    nft_individual_content_url: Cell;
+    royalty_params: RoyaltyParams;
+    mint_limit: Int;
+    mint_time_limit: Int;
+    is_sbt: Int;
+    nft_price: Int;
+    enable_profile: Bool;
+    enable_whitelist: Bool;
+    user_item_limit: Int;
+}
+
+message ProfileData {
+    query_id: Int as uint64;
+    user: Address;
+    is_whitelisted: Bool;
+    is_blacklisted: Bool;
+}
+
+message(0x5fcc3d14) Transfer {
+    query_id: Int as uint64;
+    new_owner: Address;
+    response_destination: Address?;
+    custom_payload: Cell?;
+    forward_amount: Int as coins;
+    forward_payload: Slice as remaining;
+}
+
+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_id: Int;
+    collection: Address;
+}
+struct GetNftData {
+    is_initialized: Bool;
+    index: Int;
+    collection_address: Address;
+    owner_address: Address;
+    individual_content: Cell;
+}
+
+struct CollectionMasterData {
+    master: Address;
+    mint_limit: Int;
+    price: Int;
+    mint_time_limit: Int;
+    is_sbt: Int;
+    index_in_collection: Int;
+}
+
+struct CollectionMasterDataV2 {
+    master: Address;
+    mint_limit: Int;
+    price: Int;
+    mint_time_limit: Int;
+    is_sbt: Int;
+    index_in_collection: Int;
+    enable_whitelist: Bool;
+    user_item_limit: Int;
+}
+
+/* 
+
+            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
+*/
+
+message MintTo{
+    owner: Address;
+}
+
+message MassUpdateWhiteList {
+    addresses: Cell;
+    add: Bool;
+    spendPerAddress: Int as uint64;
+}
+
+message SetupCollectionData{
+    collection_owner: Address?;
+    collection_item_price: Int;
+    user_item_limit: Int;
+    enable_whitelist: Bool;
+}
+
+message CompleteTodo{
+    seqno: Int as uint256;
+}
+
+message InternalComplete{
+    excess: Address;
+}
+
+
+message InternalAdd{
+    amount: Int as coins;
+    origin: Address;
+}
+
+message TransferOwner {
+    new_owner: Address;
+}
+
+message Withdraw {
+    to: Address;
+}
+
+struct MasterData {
+    master: Address;
+    next_collection_index: Int;
+    collection_creation_price: Int;
+}
+
+const masterMinStorage: Int = ton("0.05");
+const minTonsForStorage: Int = ton("0.005");
+const gasConsumption: Int = ton("0.012");

package/contracts/nft_item.tact

@@ -0,0 +1,98 @@
+import "@stdlib/deploy";
+import "./message.tact";
+
+contract NftItem {
+    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);
+        
+        if (self.is_initialized == false) {  // Initial Transfer, aka the "Minting" of the NFT
+            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()
+            });
+        } else {
+            require(ctx.sender == self.owner!!, "not owner");
+            // require(self.is_sbt == 0, "Sbt cannot be transferred");
+            self.owner = msg.new_owner;  // change current owner to the new_owner
+            if (msg.forward_amount > 0) {
+                send(SendParameters{
+                    to: msg.new_owner,
+                    value: msg.forward_amount,
+                    mode: SendPayGasSeparately, 
+                    body: OwnershipAssigned{
+                        query_id: msg.query_id,
+                        prev_owner: ctx.sender,
+                        forward_payload: msg.forward_payload
+                    }.toCell()
+                }); 
+            }
+
+            msgValue = msgValue - ctx.readForwardFee(); 
+            if (msg.response_destination != null) { 
+                send(SendParameters{ 
+                    to: msg.response_destination!!,
+                    value: msgValue - msg.forward_amount,
+                    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/nft_item_free.tact

@@ -0,0 +1,98 @@
+import "@stdlib/deploy";
+import "./message.tact";
+
+contract NftItem {
+    collection_address: Address;
+    item_index: Int; 
+    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);
+        
+        if (self.is_initialized == false) {  // Initial Transfer, aka the "Minting" of the NFT
+            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.new_owner, // Above paid contract
+                value: msgValue,
+                mode: SendPayGasSeparately,
+                body: Excesses { query_id: msg.query_id }.toCell()
+            });
+        } else {
+            require(ctx.sender == self.owner!!, "not owner");
+            // require(self.is_sbt == 0, "Sbt cannot be transferred");
+            self.owner = msg.new_owner;  // change current owner to the new_owner
+            if (msg.forward_amount > 0) {
+                send(SendParameters{
+                    to: msg.new_owner,
+                    value: msg.forward_amount,
+                    mode: SendIgnoreErrors + SendRemainingValue, 
+                    body: OwnershipAssigned{
+                        query_id: msg.query_id,
+                        prev_owner: ctx.sender,
+                        forward_payload: msg.forward_payload
+                    }.toCell()
+                }); 
+            }
+
+            msgValue = msgValue - ctx.readForwardFee(); 
+            if (msg.response_destination != null) { 
+                send(SendParameters{ 
+                    to: msg.response_destination!!,
+                    value: msgValue - msg.forward_amount,
+                    mode: SendIgnoreErrors + SendRemainingValue,
+                    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/packages/math/float.fc

@@ -0,0 +1,95 @@
+;; Title: Func functions for floating point operation 
+;; Description: This file contains the functions for floating point operation
+;; Author: @alan890104
+;; Version: 0.1
+
+const ERROR_INTEGER_OVERFLOW = 4;
+
+;; requireInt128 function is used to check if the value is in the range of 128 bit integer
+int requireInt128(int) asm "128 FITS";
+
+;; requireFloat function is used to check if the value is compatible with fixed point float (128 bit integer + 64 bit decimal)
+int requireFloat(int) asm "192 FITS";
+
+;; toFloat function convert a 128 bit integer to fixed point float
+;; the precision is about log10(2^64) = 19.2659
+;; the integer part is 128 bit, the decimal part is 64 bit
+int toFloat(int value) inline_ref {
+    value.requireInt128();
+    return value << 64;
+}
+
+;; add function is used to add two fixed point float
+;; this function will not check if the value is compatible with fixed point float
+;; it is an alias function for "+" operator
+int add(int floatA, int floatB) inline_ref {
+    return floatA + floatB;
+}
+
+;; sub function is used to subtract two fixed point float
+;; this function will not check if the value is compatible with fixed point float
+;; it is equivalent to "-" operator
+int sub(int floatA, int floatB) inline_ref {
+    return floatA - floatB;
+}
+
+;; mul function is used to multiply two fixed point float
+;; WARNING: the internal result may exceed 256 bit (196 bit * 196 bit = 392 bit)
+int mul(int floatA, int floatB) inline_ref {
+    return (floatA * floatB) >> 64;
+}
+
+;; div function is used to divide two fixed point float
+;; the internal result is 192 bit + 64 bit = 256 bit, so it will not overflow
+;; this function ignores checking if the value is compatible with fixed point float and division by zero
+int div(int floatA, int floatB) inline_ref {
+    return (floatA << 64) / floatB;
+}
+
+;; safeAdd function is used to add two fixed point float
+;; it will check if the value is compatible with fixed point float, if not, it will throw an error
+int safeAdd(int floatA, int floatB) inline_ref {
+    floatA.requireFloat();
+    floatB.requireFloat();
+    return floatA + floatB;
+}
+
+
+;; safeSub function is used to subtract two fixed point float
+;; it will check if the value is compatible with fixed point float, if not, it will throw an error
+int safeSub(int floatA, int floatB) inline_ref {
+    floatA.requireFloat();
+    floatB.requireFloat();
+    return floatA - floatB;
+}
+
+;; safeMul function is used to multiply two fixed point float
+;; it will check if the value is compatible with fixed point float, if not, it will throw an error
+int safeMul(int floatA, int floatB) inline_ref {
+    floatA.requireFloat();
+    floatB.requireFloat();
+    return (floatA * floatB) >> 64;
+}
+
+;; safeDiv function is used to divide two fixed point float
+;; it will check if the value is compatible with fixed point float, if not, it will throw an error
+int safeDiv(int floatA, int floatB) inline_ref {
+    throw_if(ERROR_INTEGER_OVERFLOW, floatB == 0);
+    floatA.requireFloat();
+    floatB.requireFloat();
+    return (floatA << 64) / floatB;
+}
+
+;; sqrtFloat function is used to calculate the square root of a fixed point float
+;; used newton's method to approximate the square root, since the precision is 64 bit, we need to shift 32 bit back
+int sqrtFloat(int x) inline_ref {
+    int z = (x + 1) / 2;
+    int y = x;
+    while (z < y) {
+        y = z;
+        z = (x / z + z) / 2;
+    }
+    ;; y << (self.precision // 2)
+    ;; The precision of fixed point float is 64 bit, so we need to shift 32 bit back
+    return y << 32;
+}