@pizzaton/ton 0.0.0-stage → 0.1.0

package/dist/jetton/index.mjs

@@ -0,0 +1,92 @@
+import { invariant } from "../core/errors.mjs";
+import { MAX_TON_COINS, assertTonAmount, parseUnits } from "../core/amount.mjs";
+import { JETTON_IMPLEMENTATION_PROFILES, getJettonImplementationProfile } from "./versions.mjs";
+import { SendMode, TupleBuilder, beginCell } from "@ton/core";
+import { JettonMaster, JettonMaster as JettonMasterContract, JettonWallet, JettonWallet as JettonWallet$1 } from "@ton/ton";
+//#region src/jetton/index.ts
+const JETTON_OPCODES = {
+	transfer: 260734629,
+	burn: 1499400124,
+	excesses: 3576854235,
+	internalTransfer: 395134233,
+	transferNotification: 1935855772
+};
+var JettonWalletContract = class JettonWalletContract {
+	address;
+	official;
+	constructor(address) {
+		this.official = JettonWallet$1.create(address);
+		this.address = this.official.address;
+	}
+	static create(address) {
+		return new JettonWalletContract(address);
+	}
+	async getBalance(provider) {
+		return this.official.getBalance(provider);
+	}
+	async getWalletData(provider) {
+		const { stack } = await provider.get("get_wallet_data", []);
+		return {
+			balance: stack.readBigNumber(),
+			owner: stack.readAddress(),
+			master: stack.readAddress(),
+			walletCode: stack.readCell()
+		};
+	}
+	async sendTransfer(provider, via, input, value) {
+		assertTonAmount(value, "Jetton transfer value");
+		await provider.internal(via, {
+			value,
+			body: buildJettonTransferBody(input),
+			sendMode: SendMode.PAY_GAS_SEPARATELY
+		});
+	}
+	async sendBurn(provider, via, input, value) {
+		assertTonAmount(value, "Jetton burn value");
+		await provider.internal(via, {
+			value,
+			body: buildJettonBurnBody(input),
+			sendMode: SendMode.PAY_GAS_SEPARATELY
+		});
+	}
+};
+function buildJettonTransferBody(input) {
+	assertAmount(input.amount);
+	assertQueryId(input.queryId);
+	const forwardAmount = input.forwardAmount ?? 0n;
+	invariant(forwardAmount >= 0n && forwardAmount <= MAX_TON_COINS, "INVALID_AMOUNT", "Forward amount is outside the TON coin range");
+	const builder = beginCell().storeUint(JETTON_OPCODES.transfer, 32).storeUint(input.queryId ?? 0n, 64).storeCoins(input.amount).storeAddress(input.destination).storeAddress(input.responseDestination).storeMaybeRef(input.customPayload).storeCoins(forwardAmount);
+	if (input.forwardPayload) builder.storeBit(1).storeRef(input.forwardPayload);
+	else builder.storeBit(0);
+	return builder.endCell();
+}
+function buildJettonBurnBody(input) {
+	assertAmount(input.amount);
+	assertQueryId(input.queryId);
+	return beginCell().storeUint(JETTON_OPCODES.burn, 32).storeUint(input.queryId ?? 0n, 64).storeCoins(input.amount).storeAddress(input.responseDestination).storeMaybeRef(input.customPayload).endCell();
+}
+function buildJettonExcessesBody(queryId = 0n) {
+	assertQueryId(queryId);
+	return beginCell().storeUint(JETTON_OPCODES.excesses, 32).storeUint(queryId, 64).endCell();
+}
+function buildJettonGetWalletAddressArgs(owner) {
+	const tuple = new TupleBuilder();
+	tuple.writeAddress(owner);
+	return tuple;
+}
+async function resolveJettonWalletAddress(provider, master, owner) {
+	const result = await provider.runGetMethod(master, "get_wallet_address", buildJettonGetWalletAddressArgs(owner).build());
+	invariant(result.exitCode === void 0 || result.exitCode === 0, "PROVIDER_ERROR", `Jetton wallet address getter failed with exit code ${result.exitCode}`, { exitCode: result.exitCode });
+	return result.stack.readAddress();
+}
+function parseJettonAmount(value, decimals) {
+	return parseUnits(value, decimals);
+}
+function assertAmount(value) {
+	invariant(value >= 0n && value <= MAX_TON_COINS, "INVALID_AMOUNT", "Jetton amount is out of range");
+}
+function assertQueryId(value) {
+	if (value !== void 0) invariant(value >= 0n && value < 2n ** 64n, "INVALID_TRANSACTION", "Query id is out of range");
+}
+//#endregion
+export { JETTON_IMPLEMENTATION_PROFILES, JETTON_OPCODES, JettonMaster, JettonMasterContract, JettonWallet, JettonWalletContract, buildJettonBurnBody, buildJettonExcessesBody, buildJettonGetWalletAddressArgs, buildJettonTransferBody, getJettonImplementationProfile, parseJettonAmount, resolveJettonWalletAddress };

package/dist/jetton/versions.d.mts

@@ -0,0 +1,12 @@
+//#region src/jetton/versions.d.ts
+export type JettonImplementationVersion = "jetton-1.0" | "discoverable" | "stablecoin" | "notcoin" | "mintless" | "jetton-2.0";
+export interface JettonImplementationProfile {
+  readonly version: JettonImplementationVersion;
+  readonly supportsWalletDiscovery: boolean;
+  readonly supportsBurn: boolean;
+  readonly supportsCustomTransferPayload: boolean;
+  readonly optimizedWalletSharding: boolean;
+}
+export declare const JETTON_IMPLEMENTATION_PROFILES: Readonly<Record<JettonImplementationVersion, JettonImplementationProfile>>;
+export declare function getJettonImplementationProfile(version: JettonImplementationVersion): JettonImplementationProfile;
+//#endregion

package/dist/jetton/versions.mjs

@@ -0,0 +1,50 @@
+//#region src/jetton/versions.ts
+const JETTON_IMPLEMENTATION_PROFILES = Object.freeze({
+	"jetton-1.0": {
+		version: "jetton-1.0",
+		supportsWalletDiscovery: false,
+		supportsBurn: true,
+		supportsCustomTransferPayload: true,
+		optimizedWalletSharding: false
+	},
+	discoverable: {
+		version: "discoverable",
+		supportsWalletDiscovery: true,
+		supportsBurn: true,
+		supportsCustomTransferPayload: true,
+		optimizedWalletSharding: false
+	},
+	stablecoin: {
+		version: "stablecoin",
+		supportsWalletDiscovery: true,
+		supportsBurn: false,
+		supportsCustomTransferPayload: true,
+		optimizedWalletSharding: false
+	},
+	notcoin: {
+		version: "notcoin",
+		supportsWalletDiscovery: true,
+		supportsBurn: true,
+		supportsCustomTransferPayload: true,
+		optimizedWalletSharding: false
+	},
+	mintless: {
+		version: "mintless",
+		supportsWalletDiscovery: true,
+		supportsBurn: true,
+		supportsCustomTransferPayload: true,
+		optimizedWalletSharding: false
+	},
+	"jetton-2.0": {
+		version: "jetton-2.0",
+		supportsWalletDiscovery: true,
+		supportsBurn: true,
+		supportsCustomTransferPayload: true,
+		optimizedWalletSharding: true
+	}
+});
+function getJettonImplementationProfile(version) {
+	return JETTON_IMPLEMENTATION_PROFILES[version];
+}
+//#endregion
+export { JETTON_IMPLEMENTATION_PROFILES, getJettonImplementationProfile };

package/dist/nft/collection.d.mts

@@ -0,0 +1,57 @@
+import { NftContent, RoyaltyParameters } from "./content.mjs";
+import { Address, Cell, Contract, ContractProvider, Sender } from "@ton/core";
+//#region src/nft/collection.d.ts
+export declare const NFT_COLLECTION_OPCODES: {
+  readonly deployItem: 1;
+  readonly batchDeployItem: 2;
+  readonly changeOwner: 3;
+  readonly getRoyaltyParams: 1765620048;
+};
+export interface NftCollectionConfig {
+  readonly admin: Address;
+  readonly content: NftContent | Cell;
+  readonly commonContent: string;
+  readonly itemCode: Cell;
+  readonly royalty: RoyaltyParameters;
+}
+export interface NewNftItem {
+  readonly owner: Address;
+  readonly content: NftContent | Cell;
+}
+export interface NftCollectionData {
+  readonly nextItemIndex: bigint;
+  readonly collectionContent: Cell;
+  readonly owner: Address;
+}
+export declare function collectionConfigToCell(config: NftCollectionConfig): Cell;
+export declare function buildNftDeployItemBody(item: NewNftItem, index: bigint | number, forwardAmount: bigint, queryId?: bigint | number): Cell;
+export declare function buildNftChangeOwnerBody(newOwner: Address, queryId?: bigint | number): Cell;
+export declare function buildNftBatchDeployBody(items: readonly {
+  readonly index: bigint | number;
+  readonly item: NewNftItem;
+  readonly forwardAmount: bigint;
+}[], queryId?: bigint | number): Cell;
+export declare function buildNftRoyaltyParamsBody(queryId?: bigint | number): Cell;
+export declare class NftCollectionContract implements Contract {
+  readonly init?: {
+    readonly code: Cell;
+    readonly data: Cell;
+  } | undefined;
+  readonly address: Address;
+  private constructor();
+  static createFromAddress(address: Address): NftCollectionContract;
+  static createFromConfig(config: NftCollectionConfig, code: Cell, workchain?: number): NftCollectionContract;
+  sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+  sendDeployItem(provider: ContractProvider, via: Sender, item: NewNftItem, index: bigint | number, forwardAmount?: bigint, value?: bigint, queryId?: bigint | number): Promise<void>;
+  sendChangeOwner(provider: ContractProvider, via: Sender, newOwner: Address, value?: bigint, queryId?: bigint | number): Promise<void>;
+  sendDeployBatch(provider: ContractProvider, via: Sender, items: readonly {
+    readonly item: NewNftItem;
+    readonly index: bigint | number;
+    readonly forwardAmount: bigint;
+  }[], value: bigint, queryId?: bigint | number): Promise<void>;
+  sendGetRoyaltyParams(provider: ContractProvider, via: Sender, value?: bigint, queryId?: bigint | number): Promise<void>;
+  getNftAddressByIndex(provider: ContractProvider, index: bigint | number): Promise<Address>;
+  getCollectionData(provider: ContractProvider): Promise<NftCollectionData>;
+  getNftContent(provider: ContractProvider, index: bigint | number, content: Cell): Promise<Cell>;
+}
+//#endregion

package/dist/nft/collection.mjs

@@ -0,0 +1,148 @@
+import { invariant } from "../core/errors.mjs";
+import { MAX_TON_COINS, assertTonAmount } from "../core/amount.mjs";
+import { nftContentToCell, royaltyParamsToCell } from "./content.mjs";
+import { Cell, Dictionary, SendMode, beginCell, contractAddress, toNano } from "@ton/core";
+//#region src/nft/collection.ts
+const NFT_COLLECTION_OPCODES = {
+	deployItem: 1,
+	batchDeployItem: 2,
+	changeOwner: 3,
+	getRoyaltyParams: 1765620048
+};
+function collectionConfigToCell(config) {
+	return beginCell().storeAddress(config.admin).storeUint(0, 64).storeRef(beginCell().storeRef(config.content instanceof Cell ? config.content : nftContentToCell(config.content)).storeRef(beginCell().storeStringTail(config.commonContent).endCell()).endCell()).storeRef(config.itemCode).storeRef(royaltyParamsToCell(config.royalty)).endCell();
+}
+function assertQueryId(queryId) {
+	invariant(typeof queryId === "bigint" || Number.isSafeInteger(queryId), "INVALID_TRANSACTION", "Query id must be a safe integer");
+	const value = BigInt(queryId);
+	invariant(value >= 0n && value < 2n ** 64n, "INVALID_TRANSACTION", "Query id is out of range");
+	return value;
+}
+function assertIndex(index) {
+	invariant(typeof index === "bigint" || Number.isSafeInteger(index), "INVALID_TRANSACTION", "NFT index must be a safe integer");
+	const value = BigInt(index);
+	invariant(value >= 0n && value < 2n ** 64n, "INVALID_TRANSACTION", "NFT index is out of range");
+	return value;
+}
+function buildNftDeployItemBody(item, index, forwardAmount, queryId = 0n) {
+	invariant(forwardAmount >= 0n && forwardAmount <= MAX_TON_COINS, "INVALID_AMOUNT", "Forward amount is outside the TON coin range");
+	return beginCell().storeUint(NFT_COLLECTION_OPCODES.deployItem, 32).storeUint(assertQueryId(queryId), 64).storeUint(assertIndex(index), 64).storeCoins(forwardAmount).storeRef(beginCell().storeAddress(item.owner).storeRef(item.content instanceof Cell ? item.content : nftContentToCell(item.content)).endCell()).endCell();
+}
+function buildNftChangeOwnerBody(newOwner, queryId = 0n) {
+	return beginCell().storeUint(NFT_COLLECTION_OPCODES.changeOwner, 32).storeUint(assertQueryId(queryId), 64).storeAddress(newOwner).endCell();
+}
+function batchDeployValue() {
+	return {
+		parse(slice) {
+			const content = slice.loadRef().beginParse();
+			return {
+				forwardAmount: slice.loadCoins(),
+				owner: content.loadAddress(),
+				content: content.loadRef()
+			};
+		},
+		serialize(value, builder) {
+			invariant(value.forwardAmount >= 0n && value.forwardAmount <= MAX_TON_COINS, "INVALID_AMOUNT", "Forward amount is outside the TON coin range");
+			builder.storeCoins(value.forwardAmount).storeRef(beginCell().storeAddress(value.owner).storeRef(value.content instanceof Cell ? value.content : nftContentToCell(value.content)).endCell());
+		}
+	};
+}
+function buildNftBatchDeployBody(items, queryId = 0n) {
+	const dictionary = Dictionary.empty(Dictionary.Keys.BigUint(64), batchDeployValue());
+	for (const entry of items) {
+		invariant(entry.forwardAmount >= 0n && entry.forwardAmount <= MAX_TON_COINS, "INVALID_AMOUNT", "Forward amount is outside the TON coin range");
+		dictionary.set(assertIndex(entry.index), {
+			...entry.item,
+			forwardAmount: entry.forwardAmount
+		});
+	}
+	return beginCell().storeUint(NFT_COLLECTION_OPCODES.batchDeployItem, 32).storeUint(assertQueryId(queryId), 64).storeDict(dictionary).endCell();
+}
+function buildNftRoyaltyParamsBody(queryId = 0n) {
+	return beginCell().storeUint(NFT_COLLECTION_OPCODES.getRoyaltyParams, 32).storeUint(assertQueryId(queryId), 64).endCell();
+}
+var NftCollectionContract = class NftCollectionContract {
+	init;
+	address;
+	constructor(address, init) {
+		this.init = init;
+		this.address = address;
+	}
+	static createFromAddress(address) {
+		return new NftCollectionContract(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: collectionConfigToCell(config)
+		};
+		return new NftCollectionContract(contractAddress(workchain, init), init);
+	}
+	async sendDeploy(provider, via, value) {
+		assertTonAmount(value, "NFT deployment value");
+		await provider.internal(via, {
+			value,
+			sendMode: SendMode.PAY_GAS_SEPARATELY,
+			body: beginCell().endCell()
+		});
+	}
+	async sendDeployItem(provider, via, item, index, forwardAmount = toNano("0.06"), value = toNano("0.07"), queryId = 0n) {
+		assertTonAmount(value, "NFT item deployment value");
+		await provider.internal(via, {
+			value,
+			body: buildNftDeployItemBody(item, index, forwardAmount, queryId),
+			sendMode: SendMode.PAY_GAS_SEPARATELY
+		});
+	}
+	async sendChangeOwner(provider, via, newOwner, value = toNano("0.05"), queryId = 0n) {
+		assertTonAmount(value, "NFT owner change value");
+		await provider.internal(via, {
+			value,
+			body: buildNftChangeOwnerBody(newOwner, queryId),
+			sendMode: SendMode.PAY_GAS_SEPARATELY
+		});
+	}
+	async sendDeployBatch(provider, via, items, value, queryId = 0n) {
+		assertTonAmount(value, "NFT batch deployment value");
+		await provider.internal(via, {
+			value,
+			body: buildNftBatchDeployBody(items, queryId),
+			sendMode: SendMode.PAY_GAS_SEPARATELY
+		});
+	}
+	async sendGetRoyaltyParams(provider, via, value = toNano("0.05"), queryId = 0n) {
+		assertTonAmount(value, "NFT royalty request value");
+		await provider.internal(via, {
+			value,
+			body: buildNftRoyaltyParamsBody(queryId),
+			sendMode: SendMode.PAY_GAS_SEPARATELY
+		});
+	}
+	async getNftAddressByIndex(provider, index) {
+		const { stack } = await provider.get("get_nft_address_by_index", [{
+			type: "int",
+			value: assertIndex(index)
+		}]);
+		return stack.readAddress();
+	}
+	async getCollectionData(provider) {
+		const { stack } = await provider.get("get_collection_data", []);
+		return {
+			nextItemIndex: stack.readBigNumber(),
+			collectionContent: stack.readCell(),
+			owner: stack.readAddress()
+		};
+	}
+	async getNftContent(provider, index, content) {
+		const { stack } = await provider.get("get_nft_content", [{
+			type: "int",
+			value: assertIndex(index)
+		}, {
+			type: "cell",
+			cell: content
+		}]);
+		return stack.readCell();
+	}
+};
+//#endregion
+export { NFT_COLLECTION_OPCODES, NftCollectionContract, buildNftBatchDeployBody, buildNftChangeOwnerBody, buildNftDeployItemBody, buildNftRoyaltyParamsBody, collectionConfigToCell };

package/dist/nft/content.d.mts

@@ -0,0 +1,34 @@
+import { Builder, Cell, Slice } from "@ton/core";
+//#region src/nft/content.d.ts
+export declare const NFT_ONCHAIN_CONTENT_KEYS: readonly ["uri", "name", "description", "image", "image_data", "symbol", "decimals", "amount_style", "render_type", "currency", "game"];
+export type NftOnchainContentKey = (typeof NFT_ONCHAIN_CONTENT_KEYS)[number];
+export interface NftContentOffchain {
+  readonly type: "offchain";
+  readonly uri: string;
+}
+export interface NftContentOnchain {
+  readonly type: "onchain";
+  readonly data: Partial<Record<NftOnchainContentKey, string>>;
+}
+export type NftContent = NftContentOffchain | NftContentOnchain;
+export interface RoyaltyParameters {
+  readonly address: import("@ton/core").Address;
+  readonly royaltyFactor: bigint | number;
+  readonly royaltyBase: bigint | number;
+}
+export declare function nftContentToCell(content: NftContent): Cell;
+/**
+ * Build TEP-64 on-chain metadata for protocol-specific keys.
+ *
+ * Standard NFT metadata exposes a curated key union above. Some audited
+ * protocol contracts add namespaced keys of their own; this helper keeps the
+ * same canonical SHA-256 key/value encoding without weakening the standard
+ * parser's typed surface.
+ */
+export declare function buildOnchainMetadata(data: Readonly<Record<string, string>>): Cell;
+export declare function nftContentFromCell(cell: Cell): NftContent;
+export declare function royaltyParamsToCell(royalty: RoyaltyParameters): Cell;
+export declare function assertCell(value: Cell | unknown, message: string): asserts value is Cell;
+export declare function storeNftContent(builder: Builder, content: NftContent | Cell): Builder;
+export declare function parseNftContentSlice(slice: Slice): NftContent;
+//#endregion

package/dist/nft/content.mjs

@@ -0,0 +1,142 @@
+import { invariant } from "../core/errors.mjs";
+import { Cell, Dictionary, beginCell } from "@ton/core";
+import { sha256_sync } from "@ton/crypto";
+//#region src/nft/content.ts
+const NFT_ONCHAIN_CONTENT_KEYS = [
+	"uri",
+	"name",
+	"description",
+	"image",
+	"image_data",
+	"symbol",
+	"decimals",
+	"amount_style",
+	"render_type",
+	"currency",
+	"game"
+];
+function onchainStringValue() {
+	return {
+		serialize(value, builder) {
+			const bytes = Buffer.from(value, "utf8");
+			if (bytes.length <= 126) {
+				builder.storeRef(beginCell().storeUint(0, 8).storeBuffer(bytes));
+				return;
+			}
+			const chunkDictionary = Dictionary.empty(Dictionary.Keys.Uint(32), Dictionary.Values.Cell());
+			for (const [index, chunk] of splitBytes(bytes, 127).entries()) chunkDictionary.set(index, snakeBytesCell(chunk));
+			builder.storeRef(beginCell().storeUint(1, 8).storeDict(chunkDictionary).endCell());
+		},
+		parse(slice) {
+			const value = slice.loadRef().beginParse();
+			const tag = value.loadUint(8);
+			if (tag === 0) return loadSnakeString(value);
+			if (tag === 1) {
+				const chunks = Dictionary.load(Dictionary.Keys.Uint(32), Dictionary.Values.Cell(), value);
+				return Buffer.concat(chunks.values().map((chunk) => loadSnakeBytesCell(chunk))).toString("utf8");
+			}
+			throw new Error(`Unsupported on-chain metadata string prefix: ${tag}`);
+		}
+	};
+}
+function splitBytes(value, chunkSize) {
+	const chunks = [];
+	for (let offset = 0; offset < value.length; offset += chunkSize) chunks.push(value.subarray(offset, offset + chunkSize));
+	return chunks;
+}
+function snakeBytesCell(value) {
+	const chunks = splitBytes(value, 127);
+	let next;
+	for (let index = chunks.length - 1; index >= 1; index -= 1) {
+		const chunk = chunks[index];
+		if (!chunk) continue;
+		const builder = beginCell().storeBuffer(Buffer.from(chunk));
+		if (next) builder.storeRef(next);
+		next = builder.endCell();
+	}
+	const builder = beginCell().storeBuffer(Buffer.from(chunks[0] ?? /* @__PURE__ */ new Uint8Array()));
+	if (next) builder.storeRef(next);
+	return builder.endCell();
+}
+function loadSnakeBytesCell(cell) {
+	return loadSnakeBytes(cell.beginParse());
+}
+function loadSnakeString(slice) {
+	return loadSnakeBytes(slice).toString("utf8");
+}
+function loadSnakeBytes(slice) {
+	const parts = [];
+	let current = slice;
+	let cellCount = 0;
+	while (current) {
+		cellCount += 1;
+		invariant(cellCount <= 1e4, "INVALID_METADATA", "Metadata snake exceeds the cell limit");
+		invariant(current.remainingBits % 8 === 0, "INVALID_METADATA", "Metadata snake contains a partial byte");
+		parts.push(current.loadBuffer(current.remainingBits / 8));
+		invariant(current.remainingRefs <= 1, "INVALID_METADATA", "Metadata snake contains multiple continuation cells");
+		current = current.remainingRefs > 0 ? current.loadRef().beginParse() : void 0;
+	}
+	return Buffer.concat(parts);
+}
+function nftContentToCell(content) {
+	if (content.type === "offchain") {
+		const bytes = Buffer.from(content.uri, "utf8");
+		const first = bytes.subarray(0, 126);
+		const builder = beginCell().storeUint(1, 8).storeBuffer(first);
+		if (bytes.length > first.length) builder.storeRef(snakeBytesCell(bytes.subarray(first.length)));
+		return builder.endCell();
+	}
+	const allowedKeys = new Set(NFT_ONCHAIN_CONTENT_KEYS);
+	const dictionary = Dictionary.empty(Dictionary.Keys.Buffer(32), onchainStringValue());
+	for (const [key, value] of Object.entries(content.data)) if (value !== void 0 && allowedKeys.has(key)) dictionary.set(sha256_sync(key), value);
+	return beginCell().storeUint(0, 8).storeDict(dictionary).endCell();
+}
+/**
+* Build TEP-64 on-chain metadata for protocol-specific keys.
+*
+* Standard NFT metadata exposes a curated key union above. Some audited
+* protocol contracts add namespaced keys of their own; this helper keeps the
+* same canonical SHA-256 key/value encoding without weakening the standard
+* parser's typed surface.
+*/
+function buildOnchainMetadata(data) {
+	const dictionary = Dictionary.empty(Dictionary.Keys.Buffer(32), onchainStringValue());
+	for (const [key, value] of Object.entries(data)) dictionary.set(sha256_sync(key), value);
+	return beginCell().storeUint(0, 8).storeDict(dictionary).endCell();
+}
+function nftContentFromCell(cell) {
+	const slice = cell.beginParse();
+	const tag = slice.loadUint(8);
+	if (tag === 1) return {
+		type: "offchain",
+		uri: loadSnakeString(slice)
+	};
+	if (tag !== 0) throw new Error(`Unsupported NFT metadata content prefix: ${tag}`);
+	const dictionary = Dictionary.load(Dictionary.Keys.Buffer(32), onchainStringValue(), slice);
+	const keyByHash = new Map(NFT_ONCHAIN_CONTENT_KEYS.map((key) => [Buffer.from(sha256_sync(key)).toString("hex"), key]));
+	const data = {};
+	for (const [hash, value] of dictionary) {
+		const key = keyByHash.get(Buffer.from(hash).toString("hex"));
+		if (key) data[key] = value;
+	}
+	return {
+		type: "onchain",
+		data
+	};
+}
+function royaltyParamsToCell(royalty) {
+	invariant(royalty.royaltyFactor >= 0 && royalty.royaltyFactor < 2n ** 16n, "INVALID_TRANSACTION", "NFT royalty factor must fit in 16 bits");
+	invariant(royalty.royaltyBase > 0 && royalty.royaltyBase < 2n ** 16n, "INVALID_TRANSACTION", "NFT royalty base must fit in 16 bits and be positive");
+	return beginCell().storeUint(royalty.royaltyFactor, 16).storeUint(royalty.royaltyBase, 16).storeAddress(royalty.address).endCell();
+}
+function assertCell(value, message) {
+	invariant(value instanceof Cell, "INVALID_METADATA", message);
+}
+function storeNftContent(builder, content) {
+	return builder.storeRef(content instanceof Cell ? content : nftContentToCell(content));
+}
+function parseNftContentSlice(slice) {
+	return nftContentFromCell(slice.loadRef());
+}
+//#endregion
+export { NFT_ONCHAIN_CONTENT_KEYS, assertCell, buildOnchainMetadata, nftContentFromCell, nftContentToCell, parseNftContentSlice, royaltyParamsToCell, storeNftContent };

package/dist/nft/index.d.mts

@@ -0,0 +1,35 @@
+import { NFT_ONCHAIN_CONTENT_KEYS, NftContent, NftContentOffchain, NftContentOnchain, NftOnchainContentKey, RoyaltyParameters, assertCell, buildOnchainMetadata, nftContentFromCell, nftContentToCell, parseNftContentSlice, royaltyParamsToCell, storeNftContent } from "./content.mjs";
+import { NFT_COLLECTION_OPCODES, NewNftItem, NftCollectionConfig, NftCollectionContract, NftCollectionData, buildNftBatchDeployBody, buildNftChangeOwnerBody, buildNftDeployItemBody, buildNftRoyaltyParamsBody, collectionConfigToCell } from "./collection.mjs";
+import { NFT_IMPLEMENTATION_PROFILES, NftCollectionImplementationVersion, NftImplementationProfile, NftItemImplementationVersion } from "./versions.mjs";
+import { Address, Cell, ContractProvider, Sender } from "@ton/core";
+//#region src/nft/index.d.ts
+export declare const NFT_OPCODES: {
+  readonly transfer: 1607220500;
+  readonly ownershipAssigned: 85167505;
+  readonly getStaticData: 801842850;
+};
+export interface NftTransferInput {
+  readonly newOwner: Address;
+  readonly responseDestination: Address;
+  readonly queryId?: bigint;
+  readonly forwardAmount?: bigint;
+  readonly customPayload?: Cell;
+  readonly forwardPayload?: Cell;
+}
+export interface NftItemData {
+  readonly initialized: boolean;
+  readonly index: bigint;
+  readonly collection: Address;
+  readonly owner: Address | null;
+  readonly content: Cell | null;
+}
+export declare class NftItemContract {
+  readonly address: Address;
+  private constructor();
+  static create(address: Address): NftItemContract;
+  getData(provider: ContractProvider): Promise<NftItemData>;
+  sendTransfer(provider: ContractProvider, via: Sender, input: NftTransferInput, value: bigint): Promise<void>;
+}
+export declare function buildNftTransferBody(input: NftTransferInput): Cell;
+//#endregion
+export { NFT_COLLECTION_OPCODES, NFT_IMPLEMENTATION_PROFILES, NFT_ONCHAIN_CONTENT_KEYS, NewNftItem, NftCollectionConfig, NftCollectionContract, NftCollectionData, NftCollectionImplementationVersion, NftContent, NftContentOffchain, NftContentOnchain, NftImplementationProfile, NftItemImplementationVersion, NftOnchainContentKey, RoyaltyParameters, assertCell, buildNftBatchDeployBody, buildNftChangeOwnerBody, buildNftDeployItemBody, buildNftRoyaltyParamsBody, buildOnchainMetadata, collectionConfigToCell, nftContentFromCell, nftContentToCell, parseNftContentSlice, royaltyParamsToCell, storeNftContent };

package/dist/nft/index.mjs

@@ -0,0 +1,51 @@
+import { invariant } from "../core/errors.mjs";
+import { MAX_TON_COINS, assertTonAmount } from "../core/amount.mjs";
+import { NFT_ONCHAIN_CONTENT_KEYS, assertCell, buildOnchainMetadata, nftContentFromCell, nftContentToCell, parseNftContentSlice, royaltyParamsToCell, storeNftContent } from "./content.mjs";
+import { NFT_COLLECTION_OPCODES, NftCollectionContract, buildNftBatchDeployBody, buildNftChangeOwnerBody, buildNftDeployItemBody, buildNftRoyaltyParamsBody, collectionConfigToCell } from "./collection.mjs";
+import { NFT_IMPLEMENTATION_PROFILES } from "./versions.mjs";
+import { SendMode, beginCell } from "@ton/core";
+//#region src/nft/index.ts
+const NFT_OPCODES = {
+	transfer: 1607220500,
+	ownershipAssigned: 85167505,
+	getStaticData: 801842850
+};
+var NftItemContract = class NftItemContract {
+	address;
+	constructor(address) {
+		this.address = address;
+	}
+	static create(address) {
+		return new NftItemContract(address);
+	}
+	async getData(provider) {
+		const { stack } = await provider.get("get_nft_data", []);
+		return {
+			initialized: stack.readBigNumber() !== 0n,
+			index: stack.readBigNumber(),
+			collection: stack.readAddress(),
+			owner: stack.readAddressOpt(),
+			content: stack.readCellOpt()
+		};
+	}
+	async sendTransfer(provider, via, input, value) {
+		assertTonAmount(value, "NFT transfer value");
+		await provider.internal(via, {
+			value,
+			body: buildNftTransferBody(input),
+			sendMode: SendMode.PAY_GAS_SEPARATELY
+		});
+	}
+};
+function buildNftTransferBody(input) {
+	const queryId = input.queryId ?? 0n;
+	const forwardAmount = input.forwardAmount ?? 0n;
+	invariant(queryId >= 0n && queryId < 2n ** 64n, "INVALID_TRANSACTION", "Query id is out of range");
+	invariant(forwardAmount >= 0n && forwardAmount <= MAX_TON_COINS, "INVALID_AMOUNT", "Forward amount is outside the TON coin range");
+	const builder = beginCell().storeUint(NFT_OPCODES.transfer, 32).storeUint(queryId, 64).storeAddress(input.newOwner).storeAddress(input.responseDestination).storeMaybeRef(input.customPayload).storeCoins(forwardAmount);
+	if (input.forwardPayload) builder.storeBit(1).storeRef(input.forwardPayload);
+	else builder.storeBit(0);
+	return builder.endCell();
+}
+//#endregion
+export { NFT_COLLECTION_OPCODES, NFT_IMPLEMENTATION_PROFILES, NFT_ONCHAIN_CONTENT_KEYS, NFT_OPCODES, NftCollectionContract, NftItemContract, assertCell, buildNftBatchDeployBody, buildNftChangeOwnerBody, buildNftDeployItemBody, buildNftRoyaltyParamsBody, buildNftTransferBody, buildOnchainMetadata, collectionConfigToCell, nftContentFromCell, nftContentToCell, parseNftContentSlice, royaltyParamsToCell, storeNftContent };

package/dist/nft/versions.d.mts

@@ -0,0 +1,11 @@
+//#region src/nft/versions.d.ts
+export type NftCollectionImplementationVersion = "default" | "compressed";
+export type NftItemImplementationVersion = "default" | "sbt" | "single";
+export interface NftImplementationProfile {
+  readonly version: NftCollectionImplementationVersion | NftItemImplementationVersion;
+  readonly transferable: boolean;
+  readonly supportsCollectionIndexing: boolean;
+  readonly supportsMerkleSelfDeployment: boolean;
+}
+export declare const NFT_IMPLEMENTATION_PROFILES: Readonly<Record<NftImplementationProfile["version"], NftImplementationProfile>>;
+//#endregion

package/dist/nft/versions.mjs

@@ -0,0 +1,29 @@
+//#region src/nft/versions.ts
+const NFT_IMPLEMENTATION_PROFILES = Object.freeze({
+	default: {
+		version: "default",
+		transferable: true,
+		supportsCollectionIndexing: true,
+		supportsMerkleSelfDeployment: false
+	},
+	compressed: {
+		version: "compressed",
+		transferable: true,
+		supportsCollectionIndexing: true,
+		supportsMerkleSelfDeployment: true
+	},
+	sbt: {
+		version: "sbt",
+		transferable: false,
+		supportsCollectionIndexing: true,
+		supportsMerkleSelfDeployment: false
+	},
+	single: {
+		version: "single",
+		transferable: true,
+		supportsCollectionIndexing: false,
+		supportsMerkleSelfDeployment: false
+	}
+});
+//#endregion
+export { NFT_IMPLEMENTATION_PROFILES };