@pizzaton/ton 0.0.0-stage → 0.1.0

package/dist/emulator/index.d.mts

@@ -0,0 +1,20 @@
+import { Address, Cell, Contract, ContractProvider, Message, Sender, StateInit } from "@ton/core";
+import { Blockchain, BlockchainConfig, BlockchainTransaction, SandboxContract, SendMessageResult, TreasuryContract } from "@ton/sandbox";
+//#region src/emulator/index.d.ts
+export interface TonEmulator {
+  readonly blockchain: Blockchain;
+  readonly now: number | undefined;
+  setTime(timestamp: number): void;
+  openContract<T extends Contract>(contract: T): SandboxContract<T>;
+  provider(address: Address, init?: StateInit | null): ContractProvider;
+  sender(address: Address): Sender;
+  treasury(seed: string): Promise<SandboxContract<TreasuryContract>>;
+  sendMessage(message: Message | Cell): Promise<SendMessageResult>;
+  sendMessageIter(message: Message | Cell): Promise<AsyncIterator<BlockchainTransaction> & AsyncIterable<BlockchainTransaction>>;
+  snapshot(): ReturnType<Blockchain["snapshot"]>;
+  loadFrom(snapshot: ReturnType<Blockchain["snapshot"]>): Promise<void>;
+}
+export declare function createTonEmulator(options?: {
+  readonly config?: BlockchainConfig;
+}): Promise<TonEmulator>;
+//#endregion

package/dist/emulator/index.mjs

@@ -0,0 +1,24 @@
+import { Blockchain } from "@ton/sandbox";
+//#region src/emulator/index.ts
+async function createTonEmulator(options) {
+	const blockchain = await Blockchain.create(options);
+	return {
+		blockchain,
+		get now() {
+			return blockchain.now;
+		},
+		setTime(timestamp) {
+			blockchain.now = timestamp;
+		},
+		openContract: (contract) => blockchain.openContract(contract),
+		provider: (address, init) => blockchain.provider(address, init),
+		sender: (address) => blockchain.sender(address),
+		treasury: (seed) => blockchain.treasury(seed),
+		sendMessage: (message) => blockchain.sendMessage(message),
+		sendMessageIter: (message) => blockchain.sendMessageIter(message),
+		snapshot: () => blockchain.snapshot(),
+		loadFrom: (snapshot) => blockchain.loadFrom(snapshot)
+	};
+}
+//#endregion
+export { createTonEmulator };

package/dist/index.d.mts

@@ -0,0 +1,21 @@
+import { TON_NETWORKS, TonNetwork, TonNetworkConfig, createNetworkConfig, explorerAddressUrl } from "./core/network.mjs";
+import { TonAddress, addressesEqual, assertWorkchain, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress } from "./core/address.mjs";
+import { TonConnectMessage, TonConnectTransaction, TonTransactionMessage, TransactionIntent, createTransactionIntent, toTonConnectTransaction, validateTransactionIntent } from "./transactions/index.mjs";
+import { readableTonConnectError } from "./connect/errors.mjs";
+import { TON_CONNECT_CHAIN_IDS, TonConnectAdapter, TonConnectClient, TonConnectWallet, createTonConnectAdapter, toWalletTransaction } from "./connect/index.mjs";
+import { ContractAuditReference, ContractDescriptor, ContractFamily, ContractProductionApproval, ContractReadiness, ContractSourceReference, UpgradePolicy, assertProductionApproved, createContractDescriptor } from "./contracts/metadata.mjs";
+import { CONTRACT_CATALOG, ContractCatalogId, getContractDescriptor } from "./contracts/catalog/index.mjs";
+import { ContractSendOptions, TonContractClient } from "./contracts/client.mjs";
+import { addressFlagDictionary, crc32, uint256CoinsDictionary, uint32FlagDictionary } from "./contracts/codecs.mjs";
+import { ContractModule, createContractModule } from "./contracts/module.mjs";
+import { ContractModuleClient, ContractModuleClientOptions } from "./contracts/module-client.mjs";
+import { ContractModuleRegistry, TonContractModule, createContractModuleRegistry } from "./contracts/index.mjs";
+import { TokenMetadata, parseTokenMetadata, parseTokenMetadataJson } from "./core/metadata.mjs";
+import { TonAccountState, TonGetMethodResult, TonProvider, TonTransactionSummary } from "./provider/index.mjs";
+import { MAX_TON_COINS, assertTonAmount, formatTon, formatUnits, parseTon, parseUnits } from "./core/amount.mjs";
+import { bytesToBase64, bytesToHex, hexToBytes } from "./core/bytes.mjs";
+import { PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO } from "./core/constants.mjs";
+import { TonErrorCode, TonPackageError, invariant } from "./core/errors.mjs";
+import "./core/index.mjs";
+import { VestingSchedule, claimableAmount, unlockedAmount, validateVestingSchedule } from "./vesting/index.mjs";
+export { CONTRACT_CATALOG, ContractAuditReference, ContractCatalogId, ContractDescriptor, ContractFamily, ContractModule, ContractModuleClient, ContractModuleClientOptions, ContractModuleRegistry, ContractProductionApproval, ContractReadiness, ContractSendOptions, ContractSourceReference, MAX_TON_COINS, PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO, TON_CONNECT_CHAIN_IDS, TON_NETWORKS, TokenMetadata, TonAccountState, TonAddress, TonConnectAdapter, TonConnectClient, TonConnectMessage, TonConnectTransaction, TonConnectWallet, TonContractClient, TonContractModule, TonErrorCode, TonGetMethodResult, TonNetwork, TonNetworkConfig, TonPackageError, TonProvider, TonTransactionMessage, TonTransactionSummary, TransactionIntent, UpgradePolicy, VestingSchedule, addressFlagDictionary, addressesEqual, assertProductionApproved, assertTonAmount, assertWorkchain, bytesToBase64, bytesToHex, claimableAmount, crc32, createContractDescriptor, createContractModule, createContractModuleRegistry, createNetworkConfig, createTonConnectAdapter, createTransactionIntent, explorerAddressUrl, formatTon, formatUnits, getContractDescriptor, hexToBytes, invariant, parseTokenMetadata, parseTokenMetadataJson, parseTon, parseTonAddress, parseUnits, readableTonConnectError, shortenTonAddress, toFriendlyAddress, toTonAddress, toTonConnectTransaction, toWalletTransaction, uint256CoinsDictionary, uint32FlagDictionary, unlockedAmount, validateTransactionIntent, validateVestingSchedule };

package/dist/index.mjs

@@ -0,0 +1,19 @@
+import { TonPackageError, invariant } from "./core/errors.mjs";
+import { addressesEqual, assertWorkchain, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress } from "./core/address.mjs";
+import { MAX_TON_COINS, assertTonAmount, formatTon, formatUnits, parseTon, parseUnits } from "./core/amount.mjs";
+import { bytesToBase64, bytesToHex, hexToBytes } from "./core/bytes.mjs";
+import { createTransactionIntent, toTonConnectTransaction, validateTransactionIntent } from "./transactions/index.mjs";
+import { readableTonConnectError } from "./connect/errors.mjs";
+import { TON_CONNECT_CHAIN_IDS, createTonConnectAdapter, toWalletTransaction } from "./connect/index.mjs";
+import { assertProductionApproved, createContractDescriptor } from "./contracts/metadata.mjs";
+import { CONTRACT_CATALOG, getContractDescriptor } from "./contracts/catalog/index.mjs";
+import { TonContractClient } from "./contracts/client.mjs";
+import { addressFlagDictionary, crc32, uint256CoinsDictionary, uint32FlagDictionary } from "./contracts/codecs.mjs";
+import { createContractModule } from "./contracts/module.mjs";
+import { ContractModuleClient } from "./contracts/module-client.mjs";
+import { createContractModuleRegistry } from "./contracts/index.mjs";
+import { PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO } from "./core/constants.mjs";
+import { parseTokenMetadata, parseTokenMetadataJson } from "./core/metadata.mjs";
+import { TON_NETWORKS, createNetworkConfig, explorerAddressUrl } from "./core/network.mjs";
+import { claimableAmount, unlockedAmount, validateVestingSchedule } from "./vesting/index.mjs";
+export { CONTRACT_CATALOG, ContractModuleClient, MAX_TON_COINS, PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO, TON_CONNECT_CHAIN_IDS, TON_NETWORKS, TonContractClient, TonPackageError, addressFlagDictionary, addressesEqual, assertProductionApproved, assertTonAmount, assertWorkchain, bytesToBase64, bytesToHex, claimableAmount, crc32, createContractDescriptor, createContractModule, createContractModuleRegistry, createNetworkConfig, createTonConnectAdapter, createTransactionIntent, explorerAddressUrl, formatTon, formatUnits, getContractDescriptor, hexToBytes, invariant, parseTokenMetadata, parseTokenMetadataJson, parseTon, parseTonAddress, parseUnits, readableTonConnectError, shortenTonAddress, toFriendlyAddress, toTonAddress, toTonConnectTransaction, toWalletTransaction, uint256CoinsDictionary, uint32FlagDictionary, unlockedAmount, validateTransactionIntent, validateVestingSchedule };

package/dist/indexer/index.d.mts

@@ -0,0 +1,90 @@
+import { TonNetwork } from "../core/network.mjs";
+import { TokenMetadata } from "../core/metadata.mjs";
+import { Address, Cell } from "@ton/core";
+//#region src/indexer/index.d.ts
+export interface IndexedJettonBalance {
+  readonly walletAddress: Address;
+  readonly masterAddress: Address;
+  readonly balance: bigint;
+  readonly metadata?: TokenMetadata | undefined;
+}
+export interface IndexedNftItem {
+  readonly address: Address;
+  readonly index?: bigint | undefined;
+  readonly collection?: Address | undefined;
+  readonly owner?: Address | null | undefined;
+  readonly metadata?: Readonly<Record<string, unknown>> | undefined;
+}
+export interface IndexedNftCollection {
+  readonly address: Address;
+  readonly nextItemIndex?: bigint | undefined;
+  readonly name?: string | undefined;
+  readonly description?: string | undefined;
+  readonly image?: string | undefined;
+}
+export interface IndexedMessage {
+  readonly source?: Address;
+  readonly destination?: Address;
+  readonly createdLt: bigint;
+  readonly createdAt: number;
+  readonly hash: string;
+  readonly rawBody?: Cell;
+}
+export interface IndexedTransaction {
+  readonly hash: string;
+  readonly lt: bigint;
+  readonly account: Address;
+  readonly success: boolean;
+  readonly utime: number;
+  readonly inMsg?: IndexedMessage;
+  readonly outMsgs: readonly IndexedMessage[];
+}
+export interface IndexedTrace {
+  readonly transaction: IndexedTransaction;
+  readonly children?: readonly IndexedTrace[];
+}
+export interface TonIndexer {
+  getJettonBalances(owner: Address): Promise<readonly IndexedJettonBalance[]>;
+  getJettonMetadata(master: Address): Promise<TokenMetadata | undefined>;
+  getNftCollection(collection: Address): Promise<IndexedNftCollection>;
+  getNftItems(options: {
+    readonly collection: Address;
+    readonly limit: number;
+    readonly offset: number;
+    readonly owner?: Address;
+  }): Promise<readonly IndexedNftItem[]>;
+  /** Optional server-only capabilities. TonCenter does not implement these. */
+  getAccountTraces?(address: Address, options?: {
+    readonly beforeLt?: bigint;
+    readonly limit?: number;
+  }): Promise<readonly {
+    readonly id: string;
+    readonly utime: number;
+  }[]>;
+  getTrace?(traceId: string): Promise<IndexedTrace>;
+  getTransactionByMessageHash?(messageHash: string): Promise<{
+    readonly hash: string;
+  } | undefined>;
+  sendBoc?(boc: Cell): Promise<{
+    readonly hash?: string;
+  }>;
+}
+export interface TonCenterIndexerOptions {
+  readonly network: TonNetwork;
+  readonly baseUrl?: string;
+  readonly apiKey?: string;
+  readonly timeoutMs?: number;
+  readonly fetch?: typeof globalThis.fetch;
+}
+export interface TonApiIndexerOptions {
+  readonly network: TonNetwork;
+  readonly baseUrl?: string;
+  readonly apiKey?: string;
+  readonly timeoutMs?: number;
+  readonly fetch?: typeof globalThis.fetch;
+}
+export declare function createTonCenterIndexer(options: TonCenterIndexerOptions): TonIndexer;
+export declare function createTonApiIndexer(options: TonApiIndexerOptions): TonIndexer;
+export declare function createFallbackTonIndexer(primary: TonIndexer, fallback: TonIndexer): TonIndexer;
+export declare function formatIndexedJettonBalance(balance: IndexedJettonBalance): string;
+//#endregion

package/dist/indexer/index.mjs

@@ -0,0 +1,279 @@
+import { TonPackageError, invariant } from "../core/errors.mjs";
+import { parseTonAddress } from "../core/address.mjs";
+import { formatUnits } from "../core/amount.mjs";
+import { parseTokenMetadata } from "../core/metadata.mjs";
+import { createTimedFetch, normalizeHttpsBaseUrl, validateRequestTimeout } from "../core/http.mjs";
+import { Address } from "@ton/core";
+import { TonApiClient } from "@ton-api/client";
+//#region src/indexer/index.ts
+function createTonCenterIndexer(options) {
+	assertNetwork(options.network);
+	const baseUrl = normalizeHttpsBaseUrl(options.baseUrl ?? (options.network === "testnet" ? "https://testnet.toncenter.com/api/v3" : "https://toncenter.com/api/v3"), "TonCenter");
+	const timeoutMs = validateRequestTimeout(options.timeoutMs, "TonCenter");
+	const request = createTimedFetch(options.fetch ?? globalThis.fetch, timeoutMs, "TonCenter");
+	async function get(path, params) {
+		const url = new URL(`${baseUrl}${path}`);
+		for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);
+		const response = await request(url, { headers: {
+			Accept: "application/json",
+			...options.apiKey ? { "X-API-Key": options.apiKey } : {}
+		} });
+		if (!response.ok) throw new TonPackageError("PROVIDER_ERROR", `TonCenter request failed with status ${response.status}`, {
+			provider: "TonCenter",
+			status: response.status,
+			path
+		});
+		try {
+			return await response.json();
+		} catch (cause) {
+			throw new TonPackageError("PROVIDER_ERROR", "TonCenter returned invalid JSON", {
+				provider: "TonCenter",
+				path,
+				causeName: cause instanceof Error ? cause.name : typeof cause
+			});
+		}
+	}
+	return {
+		async getJettonBalances(owner) {
+			return ((await get("/jetton/wallets", {
+				owner_address: owner.toString({
+					urlSafe: true,
+					bounceable: false
+				}),
+				exclude_zero_balance: "true",
+				limit: "1000",
+				offset: "0"
+			})).jetton_wallets ?? []).flatMap((wallet) => {
+				const master = typeof wallet.jetton === "string" ? wallet.jetton : void 0;
+				const address = typeof wallet.address === "string" ? wallet.address : void 0;
+				const balance = typeof wallet.balance === "string" ? wallet.balance : void 0;
+				if (!master || !address || !balance) return [];
+				return [{
+					walletAddress: parseTonAddress(address),
+					masterAddress: parseTonAddress(master),
+					balance: BigInt(balance),
+					metadata: normalizeMetadata(wallet.metadata)
+				}];
+			});
+		},
+		async getJettonMetadata(master) {
+			const item = (await get("/jetton/masters", { address: master.toString({ urlSafe: true }) })).jetton_masters?.[0];
+			return item ? normalizeMetadata(item.metadata) : void 0;
+		},
+		async getNftCollection(collection) {
+			const item = (await get("/nft/collections", { address: collection.toString({ urlSafe: true }) })).nft_collections?.[0] ?? {};
+			return {
+				address: collection,
+				nextItemIndex: toBigInt(item.next_item_index),
+				name: toStringValue(item.name),
+				description: toStringValue(item.description),
+				image: toStringValue(item.image)
+			};
+		},
+		async getNftItems({ collection, limit, offset, owner }) {
+			validatePagination(limit, offset);
+			const result = await get("/nft/items", {
+				collection_address: collection.toString({ urlSafe: true }),
+				limit: String(limit),
+				offset: String(offset),
+				...owner ? { owner_address: owner.toString({ urlSafe: true }) } : {}
+			});
+			return (result.nft_items ?? []).flatMap((item) => {
+				const address = typeof item.address === "string" ? item.address : "";
+				const indexedMetadata = address ? result.metadata?.[address] : void 0;
+				const tokenInfo = indexedMetadata?.token_info;
+				const metadata = Array.isArray(tokenInfo) && tokenInfo[0] && typeof tokenInfo[0] === "object" ? tokenInfo[0] : indexedMetadata;
+				return normalizeNftItem({
+					...item,
+					...metadata ? { metadata } : {}
+				});
+			});
+		}
+	};
+}
+function createTonApiIndexer(options) {
+	assertNetwork(options.network);
+	const baseUrl = normalizeHttpsBaseUrl(options.baseUrl ?? (options.network === "testnet" ? "https://testnet.tonapi.io" : "https://tonapi.io"), "TonAPI");
+	const timeoutMs = validateRequestTimeout(options.timeoutMs, "TonAPI");
+	const client = new TonApiClient({
+		baseUrl,
+		fetch: createTimedFetch(options.fetch ?? globalThis.fetch, timeoutMs, "TonAPI"),
+		...options.apiKey ? { apiKey: options.apiKey } : {}
+	});
+	return {
+		async getJettonBalances(owner) {
+			return ((await client.accounts.getAccountJettonsBalances(owner)).balances ?? []).flatMap((balance) => {
+				if (!balance.walletAddress || !balance.jetton?.address) return [];
+				return [{
+					walletAddress: parseTonAddress(balance.walletAddress),
+					masterAddress: parseTonAddress(balance.jetton.address),
+					balance: BigInt(balance.balance),
+					metadata: normalizeMetadata(balance.jetton)
+				}];
+			});
+		},
+		async getJettonMetadata(master) {
+			return normalizeMetadata((await client.jettons.getJettonInfo(master)).metadata);
+		},
+		async getNftCollection(collection) {
+			const result = await client.nft.getNftCollection(collection);
+			return {
+				address: collection,
+				nextItemIndex: toBigInt(result.nextItemIndex),
+				name: toStringValue(result.name),
+				description: toStringValue(result.description),
+				image: toStringValue(result.image)
+			};
+		},
+		async getNftItems({ collection, limit, offset, owner }) {
+			validatePagination(limit, offset);
+			const result = owner ? await client.accounts.getAccountNftItems(owner, {
+				collection,
+				limit,
+				offset
+			}) : await client.nft.getItemsFromCollection(collection, {
+				limit,
+				offset
+			});
+			return (result.nftItems ?? result.nft_items ?? []).flatMap(normalizeNftItem);
+		},
+		async getAccountTraces(address, options) {
+			const limit = options?.limit ?? 100;
+			invariant(Number.isSafeInteger(limit) && limit >= 1 && limit <= 1e3, "INVALID_TRANSACTION", "Trace limit must be an integer from 1 to 1000");
+			invariant(options?.beforeLt === void 0 || options.beforeLt >= 0n, "INVALID_TRANSACTION", "Trace logical time cannot be negative");
+			return (await client.accounts.getAccountTraces(address, {
+				...options?.beforeLt === void 0 ? {} : { before_lt: options.beforeLt },
+				limit
+			})).traces ?? [];
+		},
+		async getTrace(traceId) {
+			return normalizeTrace(await client.traces.getTrace(traceId));
+		},
+		async getTransactionByMessageHash(messageHash) {
+			const transaction = await client.blockchain.getBlockchainTransactionByMessageHash(messageHash);
+			return transaction?.hash ? { hash: transaction.hash } : void 0;
+		},
+		async sendBoc(boc) {
+			const result = await client.blockchain.sendBlockchainMessage({ boc });
+			const record = result && typeof result === "object" ? result : {};
+			return typeof record.hash === "string" ? { hash: record.hash } : {};
+		}
+	};
+}
+function createFallbackTonIndexer(primary, fallback) {
+	const primaryGetAccountTraces = primary.getAccountTraces;
+	const primaryGetTrace = primary.getTrace;
+	const primaryGetTransactionByMessageHash = primary.getTransactionByMessageHash;
+	const primarySendBoc = primary.sendBoc;
+	return {
+		getJettonBalances: (owner) => withFallback(() => primary.getJettonBalances(owner), () => fallback.getJettonBalances(owner)),
+		getJettonMetadata: (master) => withFallback(() => primary.getJettonMetadata(master), () => fallback.getJettonMetadata(master)),
+		getNftCollection: (collection) => withFallback(() => primary.getNftCollection(collection), () => fallback.getNftCollection(collection)),
+		getNftItems: (options) => withFallback(() => primary.getNftItems(options), () => fallback.getNftItems(options)),
+		...primaryGetAccountTraces ? { getAccountTraces: (address, options) => primaryGetAccountTraces(address, options) } : {},
+		...primaryGetTrace ? { getTrace: (traceId) => primaryGetTrace(traceId) } : {},
+		...primaryGetTransactionByMessageHash ? { getTransactionByMessageHash: (messageHash) => primaryGetTransactionByMessageHash(messageHash) } : {},
+		...primarySendBoc ? { sendBoc: (boc) => primarySendBoc(boc) } : {}
+	};
+}
+function normalizeTrace(value) {
+	const transaction = normalizeTransaction(value.transaction);
+	const children = Array.isArray(value.children) ? value.children.flatMap((child) => child && typeof child === "object" ? [normalizeTrace(child)] : []) : [];
+	return {
+		transaction,
+		...children.length ? { children } : {}
+	};
+}
+function normalizeTransaction(value) {
+	const account = asAddress(value.account);
+	if (!account || typeof value.hash !== "string") throw new Error("TonAPI returned an invalid transaction");
+	const inMsg = normalizeMessage(value.inMsg);
+	return {
+		hash: value.hash,
+		lt: toBigInt(value.lt) ?? 0n,
+		account,
+		success: value.success === true,
+		utime: typeof value.utime === "number" ? value.utime : 0,
+		...inMsg ? { inMsg } : {},
+		outMsgs: Array.isArray(value.outMsgs) ? value.outMsgs.flatMap((message) => {
+			const normalized = normalizeMessage(message);
+			return normalized ? [normalized] : [];
+		}) : []
+	};
+}
+function normalizeMessage(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const record = value;
+	if (typeof record.hash !== "string") return void 0;
+	const source = asAddress(record.source);
+	const destination = asAddress(record.destination);
+	return {
+		...source ? { source } : {},
+		...destination ? { destination } : {},
+		createdLt: toBigInt(record.createdLt) ?? 0n,
+		createdAt: typeof record.createdAt === "number" ? record.createdAt : 0,
+		hash: record.hash,
+		...record.rawBody instanceof Object ? { rawBody: record.rawBody } : {}
+	};
+}
+function normalizeMetadata(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const record = value;
+	const decimals = typeof record.decimals === "number" ? record.decimals : typeof record.decimals === "string" && /^\d+$/.test(record.decimals) ? Number(record.decimals) : void 0;
+	const metadata = parseTokenMetadata({
+		...typeof record.name === "string" ? { name: record.name } : {},
+		...typeof record.symbol === "string" ? { symbol: record.symbol } : {},
+		...typeof record.description === "string" ? { description: record.description } : {},
+		...typeof record.image === "string" ? { image: record.image } : {},
+		...decimals === void 0 ? {} : { decimals },
+		...typeof record.uri === "string" ? { uri: record.uri } : {}
+	});
+	return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function normalizeNftItem(value) {
+	const address = asAddress(value.address);
+	if (!address) return [];
+	const collection = value.collection ?? value.collection_address;
+	const owner = value.owner ?? value.owner_address ?? value.real_owner;
+	return [{
+		address,
+		index: toBigInt(value.index),
+		collection: asAddress(collection),
+		owner: owner === null ? null : asAddress(owner) ?? null,
+		metadata: value.metadata && typeof value.metadata === "object" ? value.metadata : void 0
+	}];
+}
+function asAddress(value) {
+	if (typeof value === "string") return parseTonAddress(value);
+	if (value instanceof Address) return value;
+	if (value && typeof value === "object" && "address" in value) return asAddress(value.address);
+}
+function toBigInt(value) {
+	if (typeof value === "bigint") return value;
+	if (typeof value === "number" && Number.isSafeInteger(value)) return BigInt(value);
+	if (typeof value === "string" && /^\d+$/.test(value)) return BigInt(value);
+}
+function toStringValue(value) {
+	return typeof value === "string" ? value : void 0;
+}
+async function withFallback(primary, fallback) {
+	try {
+		const result = await primary();
+		if (Array.isArray(result) && result.length === 0) return fallback();
+		return result;
+	} catch {
+		return fallback();
+	}
+}
+function validatePagination(limit, offset) {
+	invariant(Number.isSafeInteger(limit) && limit >= 1 && limit <= 1e3, "INVALID_TRANSACTION", "Page limit must be an integer from 1 to 1000");
+	invariant(Number.isSafeInteger(offset) && offset >= 0, "INVALID_TRANSACTION", "Page offset must be a non-negative safe integer");
+}
+function assertNetwork(network) {
+	invariant(network === "mainnet" || network === "testnet", "INVALID_NETWORK", "Unsupported TON network");
+}
+function formatIndexedJettonBalance(balance) {
+	return formatUnits(balance.balance, balance.metadata?.decimals ?? 9);
+}
+//#endregion
+export { createFallbackTonIndexer, createTonApiIndexer, createTonCenterIndexer, formatIndexedJettonBalance };

package/dist/jetton/details.d.mts

@@ -0,0 +1,27 @@
+import { TonNetwork } from "../core/network.mjs";
+import { TokenMetadata } from "../core/metadata.mjs";
+import { Address } from "@ton/core";
+//#region src/jetton/details.d.ts
+export interface JettonDetails {
+  readonly masterAddress: Address;
+  readonly totalSupply: bigint;
+  readonly formattedTotalSupply: string;
+  readonly mintable: boolean;
+  readonly adminAddress: Address | null;
+  readonly holdersCount?: number;
+  readonly metadata?: TokenMetadata;
+  readonly source: "tonapi" | "toncenter";
+}
+export interface FetchJettonDetailsOptions {
+  readonly masterAddress?: string | Address;
+  readonly network?: TonNetwork;
+  readonly tonApiBaseUrl?: string;
+  readonly tonApiKey?: string;
+  readonly rpcEndpoint?: string;
+  readonly tonCenterApiKey?: string;
+  readonly timeoutMs?: number;
+  readonly fetch?: typeof globalThis.fetch;
+}
+export declare function formatCompactSupply(amount: bigint, decimals?: number): string;
+export declare function fetchJettonDetails(options?: FetchJettonDetailsOptions): Promise<JettonDetails>;
+//#endregion

package/dist/jetton/details.mjs

@@ -0,0 +1,116 @@
+import { invariant } from "../core/errors.mjs";
+import { parseTonAddress } from "../core/address.mjs";
+import { formatUnits } from "../core/amount.mjs";
+import { PTJ_TOKEN_INFO } from "../core/constants.mjs";
+import { parseTokenMetadata } from "../core/metadata.mjs";
+import { JettonMaster as JettonMaster$1 } from "./index.mjs";
+import { createTimedFetch, normalizeHttpsBaseUrl, validateRequestTimeout } from "../core/http.mjs";
+import { nftContentFromCell } from "../nft/content.mjs";
+import { TonClient } from "@ton/ton";
+import { TonApiClient } from "@ton-api/client";
+//#region src/jetton/details.ts
+function formatCompactSupply(amount, decimals = 9) {
+	invariant(typeof amount === "bigint" && amount >= 0n, "INVALID_AMOUNT", "Supply must be a non-negative bigint");
+	invariant(Number.isInteger(decimals) && decimals >= 0 && decimals <= 255, "INVALID_AMOUNT", "Invalid token decimals");
+	const scale = 10n ** BigInt(decimals);
+	const whole = amount / scale;
+	let divisor = 1n;
+	let suffix = "";
+	if (whole >= 1000000000n) {
+		divisor = 1000000000n;
+		suffix = "B";
+	} else if (whole >= 1000000n) {
+		divisor = 1000000n;
+		suffix = "M";
+	} else if (whole >= 1000n) {
+		divisor = 1000n;
+		suffix = "K";
+	}
+	const denominator = scale * divisor;
+	const hundredths = (amount * 100n + denominator / 2n) / denominator;
+	const integer = hundredths / 100n;
+	const fraction = (hundredths % 100n).toString().padStart(2, "0").replace(/0+$/, "");
+	return `${integer}${fraction ? `.${fraction}` : ""}${suffix}`;
+}
+async function fetchJettonDetails(options = {}) {
+	const masterAddress = parseTonAddress(options.masterAddress ?? PTJ_TOKEN_INFO.masterAddress);
+	const network = options.network ?? "mainnet";
+	invariant(network === "mainnet" || network === "testnet", "INVALID_NETWORK", "Unsupported TON network");
+	const timeoutMs = validateRequestTimeout(options.timeoutMs, "TON detail lookup");
+	const tonApiBaseUrl = normalizeHttpsBaseUrl(options.tonApiBaseUrl ?? (network === "testnet" ? "https://testnet.tonapi.io" : "https://tonapi.io"), "TonAPI");
+	const rpcEndpoint = normalizeHttpsBaseUrl(options.rpcEndpoint ?? (network === "testnet" ? "https://testnet.toncenter.com/api/v2/jsonRPC" : "https://toncenter.com/api/v2/jsonRPC"), "TonCenter");
+	try {
+		const info = await new TonApiClient({
+			baseUrl: tonApiBaseUrl,
+			fetch: createTimedFetch(options.fetch ?? globalThis.fetch, timeoutMs, "TonAPI"),
+			...options.tonApiKey ? { apiKey: options.tonApiKey } : {}
+		}).jettons.getJettonInfo(masterAddress);
+		const decimals = parseDecimals(info.metadata?.decimals) ?? PTJ_TOKEN_INFO.decimals;
+		const rawMeta = info.metadata;
+		const metadata = rawMeta ? parseTokenMetadata({
+			name: rawMeta.name,
+			symbol: rawMeta.symbol,
+			...parseDecimals(rawMeta.decimals) === void 0 ? {} : { decimals: parseDecimals(rawMeta.decimals) },
+			description: rawMeta.description,
+			image: rawMeta.image
+		}) : isPizzatonJetton(masterAddress) ? {
+			name: PTJ_TOKEN_INFO.name,
+			symbol: PTJ_TOKEN_INFO.symbol,
+			decimals: PTJ_TOKEN_INFO.decimals
+		} : void 0;
+		return {
+			masterAddress,
+			totalSupply: info.totalSupply,
+			formattedTotalSupply: formatUnits(info.totalSupply, decimals),
+			mintable: info.mintable,
+			adminAddress: info.admin?.address ? parseTonAddress(info.admin.address.toRawString()) : null,
+			holdersCount: info.holdersCount,
+			...metadata ? { metadata } : {},
+			source: "tonapi"
+		};
+	} catch {}
+	const data = await new TonClient({
+		endpoint: rpcEndpoint,
+		timeout: timeoutMs,
+		...options.tonCenterApiKey ? { apiKey: options.tonCenterApiKey } : {}
+	}).open(JettonMaster$1.create(masterAddress)).getJettonData();
+	const metadata = readOnchainMetadata(data.content) ?? (isPizzatonJetton(masterAddress) ? {
+		name: PTJ_TOKEN_INFO.name,
+		symbol: PTJ_TOKEN_INFO.symbol,
+		decimals: PTJ_TOKEN_INFO.decimals
+	} : void 0);
+	const decimals = metadata?.decimals ?? PTJ_TOKEN_INFO.decimals;
+	return {
+		masterAddress,
+		totalSupply: data.totalSupply,
+		formattedTotalSupply: formatUnits(data.totalSupply, decimals),
+		mintable: data.mintable,
+		adminAddress: data.adminAddress,
+		...metadata ? { metadata } : {},
+		source: "toncenter"
+	};
+}
+function parseDecimals(value) {
+	if (value === void 0 || value === null) return void 0;
+	const decimals = typeof value === "number" ? value : typeof value === "string" && /^\d+$/.test(value) ? Number(value) : NaN;
+	invariant(Number.isSafeInteger(decimals) && decimals >= 0 && decimals <= 255, "INVALID_METADATA", "Jetton metadata contains invalid decimals");
+	return decimals;
+}
+function isPizzatonJetton(address) {
+	return address.equals(parseTonAddress(PTJ_TOKEN_INFO.masterAddress));
+}
+function readOnchainMetadata(content) {
+	try {
+		const decoded = nftContentFromCell(content);
+		if (decoded.type !== "onchain") return void 0;
+		const decimals = parseDecimals(decoded.data.decimals);
+		return parseTokenMetadata({
+			...decoded.data,
+			...decimals === void 0 ? {} : { decimals }
+		});
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { fetchJettonDetails, formatCompactSupply };

package/dist/jetton/index.d.mts

@@ -0,0 +1,54 @@
+import { TokenMetadata } from "../core/metadata.mjs";
+import { TonProvider } from "../provider/index.mjs";
+import { JETTON_IMPLEMENTATION_PROFILES, JettonImplementationProfile, JettonImplementationVersion, getJettonImplementationProfile } from "./versions.mjs";
+import { Address, Cell, ContractProvider, Sender, TupleBuilder } from "@ton/core";
+import { JettonMaster, JettonMaster as JettonMaster$1, JettonMaster as JettonMasterContract, JettonWallet } from "@ton/ton";
+//#region src/jetton/index.d.ts
+export declare const JETTON_OPCODES: {
+  readonly transfer: 260734629;
+  readonly burn: 1499400124;
+  readonly excesses: 3576854235;
+  readonly internalTransfer: 395134233;
+  readonly transferNotification: 1935855772;
+};
+export interface JettonTransferInput {
+  readonly amount: bigint;
+  readonly destination: Address;
+  readonly responseDestination: Address;
+  readonly queryId?: bigint;
+  readonly forwardAmount?: bigint;
+  readonly customPayload?: Cell;
+  readonly forwardPayload?: Cell;
+}
+export interface JettonBurnInput {
+  readonly amount: bigint;
+  readonly responseDestination: Address;
+  readonly queryId?: bigint;
+  readonly customPayload?: Cell;
+}
+export type JettonMetadata = TokenMetadata;
+export type JettonData = Awaited<ReturnType<JettonMaster$1["getJettonData"]>>;
+export interface JettonWalletData {
+  readonly balance: bigint;
+  readonly owner: Address;
+  readonly master: Address;
+  readonly walletCode: Cell;
+}
+export declare class JettonWalletContract {
+  readonly address: Address;
+  private readonly official;
+  private constructor();
+  static create(address: Address): JettonWalletContract;
+  getBalance(provider: ContractProvider): Promise<bigint>;
+  getWalletData(provider: ContractProvider): Promise<JettonWalletData>;
+  sendTransfer(provider: ContractProvider, via: Sender, input: JettonTransferInput, value: bigint): Promise<void>;
+  sendBurn(provider: ContractProvider, via: Sender, input: JettonBurnInput, value: bigint): Promise<void>;
+}
+export declare function buildJettonTransferBody(input: JettonTransferInput): Cell;
+export declare function buildJettonBurnBody(input: JettonBurnInput): Cell;
+export declare function buildJettonExcessesBody(queryId?: bigint): Cell;
+export declare function buildJettonGetWalletAddressArgs(owner: Address): TupleBuilder;
+export declare function resolveJettonWalletAddress(provider: TonProvider, master: Address, owner: Address): Promise<Address>;
+export declare function parseJettonAmount(value: string, decimals: number): bigint;
+//#endregion
+export { JETTON_IMPLEMENTATION_PROFILES, JettonImplementationProfile, JettonImplementationVersion, type JettonMaster, type JettonMasterContract, JettonWallet, getJettonImplementationProfile };