@simplenft/api 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,57 @@
+import { Address, Cell, toNano } from '@ton/core';
+import { TonClient } from '@ton/ton';
+import { ProjectBackendService } from './backend-service';
+import type { AddressLike, Coins, CollectionCreationData, CollectionInfo, CreateCollectionResult, MintNftInCollectionResult, NftData, SimpleNftNetwork, SimpleNftOptions } from './types';
+import type { ProjectCollectionData, ProjectItemData, ProjectServerResult } from './backend-types';
+export { Address, Cell, toNano };
+export type { AddressLike, Coins, CollectionCreationData, CollectionInfo, CreateCollectionResult, MintNftInCollectionResult, NftData, SimpleNftNetwork, SimpleNftOptions, };
+export type { Attribute, CollectionFileData, DeploymentStatus, ItemFileData, ProjectCollectionData, ProjectItemData, ProjectServerResult, ProjectServerStatus, } from './backend-types';
+export { ProjectBackendService } from './backend-service';
+export type { CollectionData, CollectionMasterData, CollectionMasterDataV2, CollectionMintParams, GetNftData, RoyaltyParams, } from './contracts/tact_SimpleNftMaster';
+export declare class SimpleNft {
+    readonly hostname: string;
+    readonly network: SimpleNftNetwork;
+    readonly client: TonClient;
+    readonly backend: ProjectBackendService;
+    private readonly mnemonic?;
+    private walletState?;
+    readonly getters: {
+        isDeploy: (contract: Address) => Promise<boolean>;
+        parseAddress: (address: AddressLike) => string | null;
+        blockchain: {
+            collectionData: (collection: Address) => Promise<CollectionInfo>;
+            collectiondata: (collection: Address) => Promise<CollectionInfo>;
+            nftData: (address: Address) => Promise<NftData>;
+        };
+        server: {
+            collectionData: (collection: AddressLike) => Promise<ProjectServerResult<ProjectCollectionData>>;
+            collectiondata: (collection: AddressLike) => Promise<ProjectServerResult<ProjectCollectionData>>;
+            itemData: (address: AddressLike) => Promise<ProjectServerResult<ProjectItemData>>;
+            itemdata: (address: AddressLike) => Promise<ProjectServerResult<ProjectItemData>>;
+            nftData: (address: AddressLike) => Promise<ProjectServerResult<ProjectItemData>>;
+        };
+        collectionData: (collection: Address) => Promise<CollectionInfo>;
+        collectiondata: (collection: Address) => Promise<CollectionInfo>;
+        nftData: (address: Address) => Promise<NftData>;
+    };
+    readonly transactions: {
+        createCollection: (data: CollectionCreationData) => Promise<CreateCollectionResult>;
+        mintNftInCollection: (collection: Address) => Promise<MintNftInCollectionResult>;
+    };
+    constructor(options?: SimpleNftOptions);
+    version(): string;
+    private wallet;
+    private isDeploy;
+    private parseAddress;
+    private blockchainCollectionData;
+    private getCollectionMasterData;
+    private getSampleNftContent;
+    private blockchainNftData;
+    private serverCollectionData;
+    private serverItemData;
+    private skippedServerData;
+    private deploymentStatus;
+    private createCollection;
+    private mintNftInCollection;
+}
+export default SimpleNft;

package/dist/index.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleNft = exports.ProjectBackendService = exports.toNano = exports.Cell = exports.Address = void 0;
+const core_1 = require("@ton/core");
+Object.defineProperty(exports, "Address", { enumerable: true, get: function () { return core_1.Address; } });
+Object.defineProperty(exports, "Cell", { enumerable: true, get: function () { return core_1.Cell; } });
+Object.defineProperty(exports, "toNano", { enumerable: true, get: function () { return core_1.toNano; } });
+const crypto_1 = require("@ton/crypto");
+const ton_1 = require("@ton/ton");
+const tact_SimpleNftMaster_1 = require("./contracts/tact_SimpleNftMaster");
+const tact_SimpleNftCollectionV2_1 = require("./contracts/tact_SimpleNftCollectionV2");
+const tact_NftItem_1 = require("./contracts/tact_NftItem");
+const backend_service_1 = require("./backend-service");
+const content_1 = require("./content");
+var backend_service_2 = require("./backend-service");
+Object.defineProperty(exports, "ProjectBackendService", { enumerable: true, get: function () { return backend_service_2.ProjectBackendService; } });
+const SDK_VERSION = '0.1.0';
+const DEFAULT_HOSTNAME = 'https://api.simplenft.io';
+const DEFAULT_NETWORK = 'mainnet';
+function endpointFor(network) {
+    return `https://${network === 'testnet' ? 'testnet.' : ''}toncenter.com/api/v2/jsonRPC`;
+}
+function normalizeMnemonic(mnemonic) {
+    if (!mnemonic) {
+        return undefined;
+    }
+    if (Array.isArray(mnemonic)) {
+        return mnemonic;
+    }
+    return mnemonic.trim().split(/\s+/).filter(Boolean);
+}
+function parseAddressOrThrow(address) {
+    return typeof address === 'string' ? core_1.Address.parse(address) : address;
+}
+function parseBigint(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    return BigInt(value);
+}
+function parseSbt(value) {
+    if (typeof value === 'boolean') {
+        return value ? 1n : 0n;
+    }
+    return parseBigint(value, 0n);
+}
+function parseCoins(value, fallback) {
+    return value === undefined ? (0, core_1.toNano)(fallback) : (0, core_1.toNano)(value);
+}
+async function waitForDeploy(client, address, attempts, intervalMs) {
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        if (await client.isContractDeployed(address)) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    return false;
+}
+class SimpleNft {
+    constructor(options = {}) {
+        this.getters = {
+            isDeploy: async (contract) => this.isDeploy(contract),
+            parseAddress: (address) => this.parseAddress(address),
+            blockchain: {
+                collectionData: async (collection) => this.blockchainCollectionData(collection),
+                collectiondata: async (collection) => this.blockchainCollectionData(collection),
+                nftData: async (address) => this.blockchainNftData(address),
+            },
+            server: {
+                collectionData: async (collection) => this.serverCollectionData(collection),
+                collectiondata: async (collection) => this.serverCollectionData(collection),
+                itemData: async (address) => this.serverItemData(address),
+                itemdata: async (address) => this.serverItemData(address),
+                nftData: async (address) => this.serverItemData(address),
+            },
+            collectionData: async (collection) => this.blockchainCollectionData(collection),
+            collectiondata: async (collection) => this.blockchainCollectionData(collection),
+            nftData: async (address) => this.blockchainNftData(address),
+        };
+        this.transactions = {
+            createCollection: async (data) => this.createCollection(data),
+            mintNftInCollection: async (collection) => this.mintNftInCollection(collection),
+        };
+        this.hostname = options.hostname ?? DEFAULT_HOSTNAME;
+        this.network = options.network ?? DEFAULT_NETWORK;
+        this.mnemonic = normalizeMnemonic(options.mnemonic);
+        this.client = new ton_1.TonClient({ endpoint: endpointFor(this.network) });
+        this.backend = new backend_service_1.ProjectBackendService(this.hostname, options.serverPaths);
+    }
+    version() {
+        return SDK_VERSION;
+    }
+    async wallet() {
+        if (!this.mnemonic) {
+            throw new Error('Mnemonic is required for transaction methods');
+        }
+        if (!this.walletState) {
+            this.walletState = (async () => {
+                const keyPair = await (0, crypto_1.mnemonicToPrivateKey)(this.mnemonic);
+                const wallet = this.client.open(ton_1.WalletContractV5R1.create({
+                    workchain: 0,
+                    publicKey: keyPair.publicKey,
+                }));
+                return {
+                    wallet,
+                    secretKey: keyPair.secretKey,
+                };
+            })();
+        }
+        return this.walletState;
+    }
+    async isDeploy(contract) {
+        return this.client.isContractDeployed(contract);
+    }
+    parseAddress(address) {
+        try {
+            return parseAddressOrThrow(address).toString({ bounceable: true, urlSafe: true });
+        }
+        catch {
+            return null;
+        }
+    }
+    async blockchainCollectionData(collection) {
+        const contract = this.client.open(tact_SimpleNftCollectionV2_1.SimpleNftCollectionV2.fromAddress(collection));
+        const collectionData = await contract.getGetCollectionData();
+        const masterData = await this.getCollectionMasterData(contract);
+        const sampleNftContent = await this.getSampleNftContent(contract);
+        return {
+            collectionData,
+            masterData,
+            sampleNftContent,
+        };
+    }
+    async getCollectionMasterData(contract) {
+        try {
+            return await contract.getGetMasterDataV2();
+        }
+        catch {
+            return contract.getGetMasterData();
+        }
+    }
+    async getSampleNftContent(contract) {
+        try {
+            return await contract.getGetSampleNftContent();
+        }
+        catch {
+            return null;
+        }
+    }
+    async blockchainNftData(address) {
+        const contract = this.client.open(tact_NftItem_1.NftItem.fromAddress(address));
+        return contract.getGetNftData();
+    }
+    async serverCollectionData(collection) {
+        return this.backend.collectionData(parseAddressOrThrow(collection));
+    }
+    async serverItemData(address) {
+        return this.backend.itemData(parseAddressOrThrow(address));
+    }
+    skippedServerData(address, resource) {
+        return {
+            ok: false,
+            status: 'request_failed',
+            url: `${this.hostname}/${resource}/${address?.toString() ?? 'unknown'}`,
+            error: 'Deployment was not confirmed; server data was not requested',
+        };
+    }
+    deploymentStatus(serverData, deployed) {
+        if (!deployed) {
+            return 'deployment_not_confirmed';
+        }
+        return serverData.ok ? 'deployed_with_server_data' : 'deployed_server_data_unavailable';
+    }
+    async createCollection(data) {
+        const { wallet, secretKey } = await this.wallet();
+        const master = this.client.open(tact_SimpleNftMaster_1.SimpleNftMaster.fromAddress(parseAddressOrThrow(data.master)));
+        if (!(await this.client.isContractDeployed(master.address))) {
+            throw new Error(`Master contract is not deployed: ${master.address.toString()}`);
+        }
+        const nextIndex = await master.getGetNextCollectionIndex();
+        const collectionAddress = await master.getGetCollectionAddressByIndex(nextIndex);
+        if (!collectionAddress) {
+            throw new Error(`Unable to resolve collection address for index ${nextIndex.toString()}`);
+        }
+        const owner = data.owner ? parseAddressOrThrow(data.owner) : wallet.address;
+        const royaltyDestination = data.royaltyParams?.destination ?? owner;
+        await master.send(wallet.sender(secretKey), {
+            value: parseCoins(data.value, '0.25'),
+        }, {
+            $$type: 'CollectionMintParams',
+            queryId: parseBigint(data.queryId, 0n),
+            owner_address: owner,
+            collection_content: (0, content_1.normalizeContent)(data.collectionContent),
+            nft_individual_content_url: (0, content_1.normalizeContent)(data.nftIndividualContent),
+            royalty_params: {
+                $$type: 'RoyaltyParams',
+                numerator: data.royaltyParams?.numerator ?? 100n,
+                denominator: data.royaltyParams?.denominator ?? 1000n,
+                destination: parseAddressOrThrow(royaltyDestination),
+            },
+            mint_limit: parseBigint(data.mintLimit, 100n),
+            mint_time_limit: parseBigint(data.mintTimeLimit, 1900000000n),
+            is_sbt: parseSbt(data.isSbt),
+            nft_price: parseCoins(data.nftPrice, '0.2'),
+            enable_profile: data.enableProfile ?? false,
+            enable_whitelist: data.enableWhitelist ?? false,
+            user_item_limit: parseBigint(data.userItemLimit, 0n),
+        });
+        const deployed = data.waitForDeploy ?? true
+            ? await waitForDeploy(this.client, collectionAddress, data.waitAttempts ?? 30, data.waitIntervalMs ?? 3000)
+            : await this.client.isContractDeployed(collectionAddress);
+        const blockchainData = deployed ? await this.blockchainCollectionData(collectionAddress) : null;
+        const serverData = deployed
+            ? await this.serverCollectionData(collectionAddress)
+            : this.skippedServerData(collectionAddress, 'api/collection');
+        return {
+            address: collectionAddress,
+            deployed,
+            status: this.deploymentStatus(serverData, deployed),
+            blockchainData,
+            serverData,
+        };
+    }
+    async mintNftInCollection(collection) {
+        const { wallet, secretKey } = await this.wallet();
+        const contract = this.client.open(tact_SimpleNftCollectionV2_1.SimpleNftCollectionV2.fromAddress(collection));
+        if (!(await this.client.isContractDeployed(collection))) {
+            throw new Error(`Collection contract is not deployed: ${collection.toString()}`);
+        }
+        const collectionData = await contract.getGetCollectionData();
+        const masterData = await this.getCollectionMasterData(contract);
+        const nftAddress = await contract.getGetNftAddressByIndex(collectionData.next_item_index);
+        await contract.send(wallet.sender(secretKey), {
+            value: masterData.price,
+        }, 'Mint');
+        const deployed = nftAddress
+            ? await waitForDeploy(this.client, nftAddress, 30, 3000)
+            : false;
+        const blockchainData = deployed && nftAddress ? await this.blockchainNftData(nftAddress) : null;
+        const serverData = deployed && nftAddress
+            ? await this.serverItemData(nftAddress)
+            : this.skippedServerData(nftAddress, 'api/item');
+        return {
+            address: nftAddress,
+            collection,
+            deployed,
+            status: this.deploymentStatus(serverData, deployed),
+            blockchainData,
+            serverData,
+        };
+    }
+}
+exports.SimpleNft = SimpleNft;
+exports.default = SimpleNft;

package/dist/types.d.ts

@@ -0,0 +1,53 @@
+import type { Address, Cell } from '@ton/core';
+import type { CollectionData, CollectionMasterData, CollectionMasterDataV2, GetNftData, RoyaltyParams } from './contracts/tact_SimpleNftMaster';
+import type { DeploymentStatus, ProjectCollectionData, ProjectItemData, ProjectServerResult } from './backend-types';
+import type { ProjectServerPaths } from './backend-service';
+export type SimpleNftNetwork = 'mainnet' | 'testnet';
+export type AddressLike = string | Address;
+export type Coins = bigint | number | string;
+export interface SimpleNftOptions {
+    hostname?: string;
+    mnemonic?: string | string[];
+    network?: SimpleNftNetwork;
+    serverPaths?: ProjectServerPaths;
+}
+export interface CollectionCreationData {
+    master: AddressLike;
+    owner?: AddressLike;
+    collectionContent: string | Cell;
+    nftIndividualContent: string | Cell;
+    royaltyParams?: Omit<RoyaltyParams, '$$type'> | RoyaltyParams;
+    mintLimit?: bigint | number | string;
+    mintTimeLimit?: bigint | number | string;
+    isSbt?: boolean | bigint | number | string;
+    nftPrice?: Coins;
+    enableProfile?: boolean;
+    enableWhitelist?: boolean;
+    userItemLimit?: bigint | number | string;
+    queryId?: bigint | number | string;
+    value?: Coins;
+    waitForDeploy?: boolean;
+    waitAttempts?: number;
+    waitIntervalMs?: number;
+}
+export interface CollectionInfo {
+    collectionData: CollectionData;
+    masterData: CollectionMasterData | CollectionMasterDataV2;
+    sampleNftContent: Cell | null;
+}
+export type NftData = GetNftData;
+export interface CreateCollectionResult {
+    address: Address;
+    deployed: boolean;
+    status: DeploymentStatus;
+    blockchainData: CollectionInfo | null;
+    serverData: ProjectServerResult<ProjectCollectionData>;
+}
+export interface MintNftInCollectionResult {
+    address: Address | null;
+    collection: Address;
+    deployed: boolean;
+    status: DeploymentStatus;
+    blockchainData: NftData | null;
+    serverData: ProjectServerResult<ProjectItemData>;
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@simplenft/api",
+  "version": "0.1.0",
+  "description": "SimpleNFT contracts SDK",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/index.js",
+    "dist/index.d.ts",
+    "dist/content.js",
+    "dist/content.d.ts",
+    "dist/types.js",
+    "dist/types.d.ts",
+    "dist/api.js",
+    "dist/api.d.ts",
+    "dist/backend-service.js",
+    "dist/backend-service.d.ts",
+    "dist/backend-types.js",
+    "dist/backend-types.d.ts",
+    "dist/contracts",
+    "src",
+    "contracts",
+    "blueprint.config.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@ton/core": "0.57.0",
+    "@ton/crypto": "3.3.0",
+    "@ton/ton": "15.0.0"
+  },
+  "devDependencies": {
+    "@ton/blueprint": "0.22.0",
+    "typescript": "5.5.3"
+  },
+  "keywords": [
+    "ton",
+    "nft",
+    "simplenft"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Yuriy Berland"
+}

package/src/api.ts

@@ -0,0 +1,62 @@
+import type { ProjectServerResult } from './backend-types';
+
+export class ProjectServerError extends Error {
+    public readonly url: string;
+    public readonly status?: number;
+
+    constructor(url: string, message: string, status?: number) {
+        super(message);
+        this.name = 'ProjectServerError';
+        this.url = url;
+        this.status = status;
+    }
+}
+
+export function normalizeHostname(hostname: string): string {
+    return hostname.replace(/\/+$/, '');
+}
+
+export function buildUrl(hostname: string, path: string): string {
+    const normalizedHost = normalizeHostname(hostname);
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    return `${normalizedHost}${normalizedPath}`;
+}
+
+export async function getJson<T>(url: string): Promise<T> {
+    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()) as T;
+}
+
+export async function getJsonResult<T>(url: string): Promise<ProjectServerResult<T>> {
+    try {
+        const data = await getJson<T>(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/src/backend-service.ts

@@ -0,0 +1,40 @@
+import { Address } from '@ton/core';
+import { buildUrl, getJsonResult } from './api';
+import type { ProjectCollectionData, ProjectItemData, ProjectServerResult } from './backend-types';
+
+export interface ProjectServerPaths {
+    collectionData?: (address: string) => string;
+    itemData?: (address: string) => string;
+}
+
+const defaultPaths: Required<ProjectServerPaths> = {
+    collectionData: (address) => `/api/collection/${address}`,
+    itemData: (address) => `/api/item/${address}`,
+};
+
+function stringifyAddress(address: string | Address): string {
+    return typeof address === 'string' ? address : address.toString();
+}
+
+export class ProjectBackendService {
+    public readonly hostname: string;
+    private readonly paths: Required<ProjectServerPaths>;
+
+    constructor(hostname: string, paths: ProjectServerPaths = {}) {
+        this.hostname = hostname;
+        this.paths = {
+            ...defaultPaths,
+            ...paths,
+        };
+    }
+
+    public collectionData(address: string | Address): Promise<ProjectServerResult<ProjectCollectionData>> {
+        const stringAddress = stringifyAddress(address);
+        return getJsonResult<ProjectCollectionData>(buildUrl(this.hostname, this.paths.collectionData(stringAddress)));
+    }
+
+    public itemData(address: string | Address): Promise<ProjectServerResult<ProjectItemData>> {
+        const stringAddress = stringifyAddress(address);
+        return getJsonResult<ProjectItemData>(buildUrl(this.hostname, this.paths.itemData(stringAddress)));
+    }
+}

package/src/backend-types.ts

@@ -0,0 +1,72 @@
+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/src/content.ts

@@ -0,0 +1,36 @@
+import { beginCell, Cell } from '@ton/core';
+
+const OFFCHAIN_CONTENT_PREFIX = 0x01;
+
+function bufferToChunks(buffer: Buffer, chunkSize: number): Buffer[] {
+    const chunks: Buffer[] = [];
+    let remaining = buffer;
+
+    while (remaining.byteLength > 0) {
+        chunks.push(remaining.subarray(0, chunkSize));
+        remaining = remaining.subarray(chunkSize);
+    }
+
+    return chunks;
+}
+
+export function encodeOffchainContent(content: string): Cell {
+    const data = Buffer.concat([Buffer.from([OFFCHAIN_CONTENT_PREFIX]), Buffer.from(content)]);
+    const chunks = bufferToChunks(data, 127);
+
+    if (chunks.length === 0) {
+        return beginCell().endCell();
+    }
+
+    let current = beginCell().storeBuffer(chunks[chunks.length - 1]).endCell();
+
+    for (let i = chunks.length - 2; i >= 0; i -= 1) {
+        current = beginCell().storeBuffer(chunks[i]).storeRef(current).endCell();
+    }
+
+    return current;
+}
+
+export function normalizeContent(content: string | Cell): Cell {
+    return typeof content === 'string' ? encodeOffchainContent(content) : content;
+}