@simplenft/api 0.1.0

package/contracts/simple_nft_collection_v2.tact

@@ -0,0 +1,304 @@
+import "@stdlib/deploy";
+import "./message.tact";
+import "./nft_item.tact";
+import "./sbt_item.tact";
+import "./buyer_profile.tact";
+
+const nftBalanceConst: Int = ton("0.05");
+const minPriceNoProfile: Int = ton("0.039");
+const whitelistUpdatePrice: Int = ton("0.009");
+const massUpdateMasterFee: Int = ton("0.01");
+const singleTransactionReserve: Int = ton("0.005");
+
+
+contract SimpleNftCollectionV2 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 as uint32 = 0;
+    price: Int = 0;
+    is_setup: Bool;
+    is_sbt: Int = 0;
+    mint_time_limit: Int as uint32 = 0;
+    enable_profile: Bool = false;
+    user_item_limit: Int as uint8 = 0;
+    enable_whitelist: Bool = false;
+
+    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.enable_profile = msg.enable_profile;
+        self.user_item_limit = msg.user_item_limit;
+        self.mint_time_limit = msg.mint_time_limit;
+        self.enable_whitelist = msg.enable_whitelist;
+    }
+    // Profile
+    get fun buyer_profile_address(owner: Address): Address{
+        return contractAddress(initOf BuyerProfile(myAddress(), owner));
+    }
+
+    receive("RequestWhitelist") {
+         require(self.enable_profile == true, "Profile not nessesary for this collection");
+         let init: StateInit = initOf BuyerProfile(myAddress(), sender());
+         send(SendParameters{
+            to: contractAddress(init),
+            body: SetupCollectionData{
+                collection_owner: self.owner_address,
+                collection_item_price: self.price,
+                enable_whitelist: self.enable_whitelist,
+                user_item_limit: self.user_item_limit
+            }.toCell(),
+            value: ton("0.02"),
+            mode: SendIgnoreErrors,
+            code: init.code,
+            data: init.data
+        });       
+    }
+    
+    // Classic for a free mint
+    receive("Mint"){
+        let ctx: Context = context(); // get sender Info
+        require(ctx.value >= self.price, "NFT creation underpriced");
+        require(self.enable_profile == false, "Another method for profiles");
+        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());
+    }
+
+    receive(msg: Withdraw) {
+        require(sender() == self.owner_address, "Not from owner");
+        send(SendParameters{
+            to: msg.to,
+            value: myBalance() - masterMinStorage,
+            bounce: false,
+            mode: SendIgnoreErrors
+        });
+    }
+
+    // Mint with whitelist support
+    receive(msg: MintTo) {
+        let ownerProfile = self.get_user_profile_init(msg.owner);
+        require(sender() == contractAddress(ownerProfile), "From profile only");
+        let ctx: Context = context();
+        let msgValue: Int = ctx.value;
+        let tonBalanceBeforeMsg: Int = myBalance() - msgValue;
+        let storageFee: Int = minTonsForStorage - min(tonBalanceBeforeMsg, minTonsForStorage);
+        msgValue = msgValue - (storageFee + gasConsumption);
+        
+        self.mint(msg.owner, msgValue);
+    }
+
+    // ===== Private Methods ===== //
+
+    fun mint(sender: Address, msgValue: Int) {
+        require(self.next_item_index >= 0, "non-sequential NFTs");
+        require(self.is_setup == true, "Collection settings is not setup");
+        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");
+        }
+        let nft_init: StateInit = self.getNftItemInit(self.next_item_index);
+        let noFeeConst = self.enable_profile ? nftBalanceConst : minPriceNoProfile;
+        let feeValue = msgValue  > noFeeConst ? msgValue - noFeeConst : 0;
+        send(SendParameters{
+                to: contractAddress(nft_init), 
+                value: msgValue - feeValue, 
+                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
+            });
+        if (feeValue > 0) {
+          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;
+    }
+
+    // -------------- Profile operations ----------------------- //
+    get fun get_buyer_profile_address (address: Address): Address {
+      let profile = self.get_user_profile_init(address);
+      return contractAddress(profile);
+    }
+
+    fun update_white_list(address: Address, add: Bool, value: Int) {
+      let profile = self.get_user_profile_init(address);
+      send(SendParameters{
+        to: contractAddress(profile),
+        body: AddToWhiteList {
+            add: add
+        }.toCell(),
+        value: value,
+        mode: SendIgnoreErrors
+      });  
+    }
+
+    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()
+        });        
+    }
+
+    receive(msg: UpdateWhiteList) {
+        require(sender() == self.owner_address, "Not a collection owner");
+        let ctx: Context = context();
+        self.update_white_list(msg.user, msg.whitelist, whitelistUpdatePrice); // ctx.value - singleTransactionReserve
+    }
+
+    receive(msg: MassUpdateWhiteList) {
+    require(sender() == self.owner_address, "Not a collection owner");
+    let cell = msg.addresses;
+    let slice = cell.beginParse();
+
+      while (true) {
+         let address = slice.loadAddress();
+         self.update_white_list(address, msg.add, msg.spendPerAddress);
+
+         if (slice.refs() > 0) {
+           slice = slice.loadRef().beginParse();
+         } else {
+           return;
+        }
+      }  
+      
+      send(SendParameters{
+           to: self.master_address,
+           value: massUpdateMasterFee,
+           bounce: false,
+           mode: SendIgnoreErrors 
+        });
+    }
+
+    get fun get_master_data_v2(): CollectionMasterDataV2 {
+        return CollectionMasterDataV2{
+            master: self.master_address,
+            mint_limit: self.mint_limit,
+            mint_time_limit: self.mint_time_limit,
+            is_sbt: self.is_sbt,
+            price: self.price,
+            enable_whitelist: self.enable_whitelist,
+            index_in_collection: self.collection_index,
+            user_item_limit: self.user_item_limit
+        }
+    }
+
+    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_user_profile_init(address: Address): StateInit {
+        return initOf BuyerProfile(myAddress(), address);
+    }
+    
+    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!!;
+    }
+}

package/contracts/simple_nft_master.tact

@@ -0,0 +1,102 @@
+import "@stdlib/deploy";
+import "./simple_nft_collection_v2";
+import "./message.tact";
+
+contract SimpleNftMaster with Deployable {
+
+    /* 
+      Root contract of SimpleNFT project
+      Powered by Vorpal team
+      https://github.com/VORPALTEAM
+      
+      Code by Yuriy Berland
+      https://github.com/YuriyBum
+    */
+    
+    owner: Address;
+    next_collection_index: Int = 0;
+    collection_creation_price: Int as uint32 = 0;
+
+    init(
+        owner: Address,
+        creation_price: Int,
+    ) {
+        self.owner = owner;
+        self.collection_creation_price = creation_price;
+    }
+
+    receive(msg: CollectionMintParams) {
+        require(self.next_collection_index >= 0, "non-sequential Collections");
+        let ctx: Context = context();
+        require(ctx.value >= self.collection_creation_price, "Creation underpriced");
+        let minPriceRequired = msg.enable_profile ? nftBalanceConst : minPriceNoProfile;
+        require(msg.nft_price >= minPriceRequired, "Token price too low");
+        if (msg.mint_time_limit > 0) {
+            require(msg.mint_time_limit > now(), "Collection must have time to mint");
+        }
+        let collection_init: StateInit = self.getCollectionItemInit(self.next_collection_index);
+        
+        send(SendParameters{
+                to: contractAddress(collection_init), 
+                value: masterMinStorage, 
+                bounce: false,
+                mode: SendIgnoreErrors,
+                body: CollectionSetupParams {
+                    owner_address: msg.owner_address,
+                    master_address: myAddress(),
+                    collection_content: msg.collection_content,
+                    nft_individual_content_url: msg.nft_individual_content_url,
+                    royalty_params: msg.royalty_params,
+                    mint_limit: msg.mint_limit,
+                    nft_price: msg.nft_price,
+                    mint_time_limit: msg.mint_time_limit,
+                    is_sbt: msg.is_sbt,
+                    enable_whitelist: msg.enable_whitelist,
+                    enable_profile: msg.enable_profile,
+                    user_item_limit: msg.user_item_limit
+                }.toCell(),
+                code: collection_init.code,
+                data: collection_init.data
+            });
+        self.next_collection_index = self.next_collection_index + 1;
+    }
+
+    receive(msg: Withdraw) {
+        require(sender() == self.owner, "Not from owner");
+        send(SendParameters{
+            to: msg.to,
+            value: myBalance() - masterMinStorage,
+            bounce: false,
+            mode: SendIgnoreErrors
+        });
+    }
+
+    receive(msg: TransferOwner) {
+        require(sender() == self.owner, "Not from owner");
+        self.owner = msg.new_owner;
+    }
+
+    receive() {}
+
+    get fun getCollectionItemInit(item_index: Int): StateInit {
+        return initOf SimpleNftCollectionV2(myAddress(), item_index);
+    }
+
+    get fun get_master_data (): MasterData {
+        return MasterData{
+            master: self.owner,
+            next_collection_index: self.next_collection_index,
+            collection_creation_price: self.collection_creation_price
+        }
+    }
+
+    get fun get_collection_address_by_index (collection_index: Int): Address? {
+        let initCode: StateInit = self.getCollectionItemInit(collection_index);
+        return contractAddress(initCode);
+    }
+
+    get fun get_next_collection_index (): Int {
+        return self.next_collection_index;
+    }
+
+}

package/dist/api.d.ts

@@ -0,0 +1,10 @@
+import type { ProjectServerResult } from './backend-types';
+export declare class ProjectServerError extends Error {
+    readonly url: string;
+    readonly status?: number;
+    constructor(url: string, message: string, status?: number);
+}
+export declare function normalizeHostname(hostname: string): string;
+export declare function buildUrl(hostname: string, path: string): string;
+export declare function getJson<T>(url: string): Promise<T>;
+export declare function getJsonResult<T>(url: string): Promise<ProjectServerResult<T>>;

package/dist/api.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectServerError = void 0;
+exports.normalizeHostname = normalizeHostname;
+exports.buildUrl = buildUrl;
+exports.getJson = getJson;
+exports.getJsonResult = getJsonResult;
+class ProjectServerError extends Error {
+    constructor(url, message, status) {
+        super(message);
+        this.name = 'ProjectServerError';
+        this.url = url;
+        this.status = status;
+    }
+}
+exports.ProjectServerError = ProjectServerError;
+function normalizeHostname(hostname) {
+    return hostname.replace(/\/+$/, '');
+}
+function buildUrl(hostname, path) {
+    const normalizedHost = normalizeHostname(hostname);
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    return `${normalizedHost}${normalizedPath}`;
+}
+async function getJson(url) {
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            Accept: 'application/json',
+        },
+    });
+    if (!response.ok) {
+        throw new ProjectServerError(url, response.statusText || `HTTP ${response.status}`, response.status);
+    }
+    return (await response.json());
+}
+async function getJsonResult(url) {
+    try {
+        const data = await getJson(url);
+        return {
+            ok: true,
+            status: 'ok',
+            url,
+            data,
+        };
+    }
+    catch (error) {
+        const serverError = error instanceof ProjectServerError ? error : undefined;
+        const httpStatus = serverError?.status;
+        return {
+            ok: false,
+            status: httpStatus === 404 ? 'not_found' : 'request_failed',
+            url,
+            error: error instanceof Error ? error.message : String(error),
+            httpStatus,
+        };
+    }
+}

package/dist/backend-service.d.ts

@@ -0,0 +1,13 @@
+import { Address } from '@ton/core';
+import type { ProjectCollectionData, ProjectItemData, ProjectServerResult } from './backend-types';
+export interface ProjectServerPaths {
+    collectionData?: (address: string) => string;
+    itemData?: (address: string) => string;
+}
+export declare class ProjectBackendService {
+    readonly hostname: string;
+    private readonly paths;
+    constructor(hostname: string, paths?: ProjectServerPaths);
+    collectionData(address: string | Address): Promise<ProjectServerResult<ProjectCollectionData>>;
+    itemData(address: string | Address): Promise<ProjectServerResult<ProjectItemData>>;
+}

package/dist/backend-service.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectBackendService = void 0;
+const api_1 = require("./api");
+const defaultPaths = {
+    collectionData: (address) => `/api/collection/${address}`,
+    itemData: (address) => `/api/item/${address}`,
+};
+function stringifyAddress(address) {
+    return typeof address === 'string' ? address : address.toString();
+}
+class ProjectBackendService {
+    constructor(hostname, paths = {}) {
+        this.hostname = hostname;
+        this.paths = {
+            ...defaultPaths,
+            ...paths,
+        };
+    }
+    collectionData(address) {
+        const stringAddress = stringifyAddress(address);
+        return (0, api_1.getJsonResult)((0, api_1.buildUrl)(this.hostname, this.paths.collectionData(stringAddress)));
+    }
+    itemData(address) {
+        const stringAddress = stringifyAddress(address);
+        return (0, api_1.getJsonResult)((0, api_1.buildUrl)(this.hostname, this.paths.itemData(stringAddress)));
+    }
+}
+exports.ProjectBackendService = ProjectBackendService;

package/dist/backend-types.d.ts

@@ -0,0 +1,60 @@
+export interface CollectionFileData {
+    name: string;
+    description: string;
+    social_links: string[];
+    imageUrl: string;
+    backgroundUrl: string;
+}
+export interface Attribute {
+    trait_type: string;
+    value: string;
+}
+export interface ItemFileData {
+    name?: string;
+    description?: string;
+    marketplace?: string;
+    image: string;
+    attributes: Attribute[];
+    content_type?: string;
+    content_url?: string;
+}
+export interface ProjectCollectionData {
+    owner: string;
+    address: string;
+    mint_limit: number;
+    price: number;
+    next_item_index?: number;
+    next_item_address?: string;
+    data_url: string;
+    item_data_url?: string;
+    is_sbt?: boolean;
+    mint_time_limit?: number;
+    is_hidden_by_owner?: boolean;
+    enable_whitelist?: boolean | null;
+    user_item_limit?: number;
+    stars?: number;
+    volume?: number;
+    experience?: number;
+}
+export interface ProjectItemData {
+    address: string;
+    collection: string;
+    data_url: string;
+    index_in_collection: string;
+    minter?: string;
+    metadata?: ItemFileData;
+}
+export type ProjectServerStatus = 'ok' | 'not_found' | 'request_failed' | 'invalid_response';
+export type ProjectServerResult<T> = {
+    ok: true;
+    status: 'ok';
+    url: string;
+    data: T;
+} | {
+    ok: false;
+    status: Exclude<ProjectServerStatus, 'ok'>;
+    url: string;
+    error: string;
+    httpStatus?: number;
+};
+export type DeploymentStatus = 'deployed_with_server_data' | 'deployed_server_data_unavailable' | 'deployment_not_confirmed';

package/dist/backend-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/content.d.ts

@@ -0,0 +1,3 @@
+import { Cell } from '@ton/core';
+export declare function encodeOffchainContent(content: string): Cell;
+export declare function normalizeContent(content: string | Cell): Cell;

package/dist/content.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeOffchainContent = encodeOffchainContent;
+exports.normalizeContent = normalizeContent;
+const core_1 = require("@ton/core");
+const OFFCHAIN_CONTENT_PREFIX = 0x01;
+function bufferToChunks(buffer, chunkSize) {
+    const chunks = [];
+    let remaining = buffer;
+    while (remaining.byteLength > 0) {
+        chunks.push(remaining.subarray(0, chunkSize));
+        remaining = remaining.subarray(chunkSize);
+    }
+    return chunks;
+}
+function encodeOffchainContent(content) {
+    const data = Buffer.concat([Buffer.from([OFFCHAIN_CONTENT_PREFIX]), Buffer.from(content)]);
+    const chunks = bufferToChunks(data, 127);
+    if (chunks.length === 0) {
+        return (0, core_1.beginCell)().endCell();
+    }
+    let current = (0, core_1.beginCell)().storeBuffer(chunks[chunks.length - 1]).endCell();
+    for (let i = chunks.length - 2; i >= 0; i -= 1) {
+        current = (0, core_1.beginCell)().storeBuffer(chunks[i]).storeRef(current).endCell();
+    }
+    return current;
+}
+function normalizeContent(content) {
+    return typeof content === 'string' ? encodeOffchainContent(content) : content;
+}