@pizzaton/ton 0.0.0-stage → 0.1.0

package/dist/contracts/wrappers/tonresistor.mjs

@@ -0,0 +1,276 @@
+import { buildJettonBurnBody, buildJettonTransferBody } from "../../jetton/index.mjs";
+import { ContractWrapper } from "./base.mjs";
+import { beginCell, contractAddress } from "@ton/core";
+//#region src/contracts/wrappers/tonresistor.ts
+/** TONresistor bonding-curve source revision: https://github.com/TONresistor/bonding-curve-contracts */
+const TONRESISTOR_BONDING_CURVE_COMMIT = "5dbb20575fde5144d00c63f9d3099c0ac71bab95";
+const TONRESISTOR_OPCODES = {
+	createLaunch: 2694881281,
+	changeMasterAdmin: 2694881282,
+	claimMasterAdmin: 2694881283,
+	changeTreasury: 2694881284,
+	withdrawProtocolFees: 2694881285,
+	depositProtocolFees: 2694881286,
+	reinitializeCurve: 2694881300,
+	initializeCurve: 2694881296,
+	buyJettons: 2694881297,
+	graduate: 2694881298,
+	flushFees: 2694881299,
+	initPoolResult: 3457702871,
+	transferNotification: 1935855772,
+	internalTransfer: 395134233,
+	askToTransfer: 260734629,
+	askToBurn: 1499400124,
+	mintNewJettons: 1680571655,
+	dropMinterAdmin: 1949430305,
+	changeMinterAdmin: 1694626644,
+	claimMinterAdmin: 4220051737,
+	changeMinterMetadata: 3414567170,
+	upgradeMinterCode: 621336170,
+	requestWalletAddress: 745978227,
+	topUp: 3547469196,
+	returnExcesses: 3576854235,
+	jettonTransfer: 260734629,
+	jettonBurn: 1499400124,
+	burnNotification: 2078119902
+};
+const header = (opcode, queryId = 0n) => beginCell().storeUint(opcode, 32).storeUint(queryId, 64);
+function uint(value, bits, field) {
+	if (value < 0n || value >= 1n << BigInt(bits)) throw new RangeError(`${field} must fit in uint${String(bits)}`);
+	return value;
+}
+function uint8(value, field) {
+	if (!Number.isInteger(value) || value < 0 || value > 255) throw new RangeError(`${field} must fit in uint8`);
+	return value;
+}
+function buildTonResistorMasterData(config) {
+	return beginCell().storeAddress(config.admin).storeAddress(null).storeAddress(config.treasury).storeUint(uint(config.totalLaunches ?? 0n, 64, "totalLaunches"), 64).storeCoins(config.feesBalance ?? 0n).endCell();
+}
+var TonResistorBondingCurveMaster = class TonResistorBondingCurveMaster extends ContractWrapper {
+	static createFromAddress(address) {
+		return new TonResistorBondingCurveMaster(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildTonResistorMasterData(config)
+		};
+		return new TonResistorBondingCurveMaster(contractAddress(workchain, init), init);
+	}
+	async sendDeploy(provider, via, value) {
+		await this.send(provider, via, value);
+	}
+	async sendCreateLaunch(provider, via, value, metadata, salt, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.createLaunch, queryId).storeRef(metadata).storeUint(uint(salt, 64, "salt"), 64).endCell());
+	}
+	async sendChangeAdmin(provider, via, value, newAdmin, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.changeMasterAdmin, queryId).storeAddress(newAdmin).endCell());
+	}
+	async sendClaimAdmin(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.claimMasterAdmin, queryId).endCell());
+	}
+	async sendChangeTreasury(provider, via, value, treasury, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.changeTreasury, queryId).storeAddress(treasury).endCell());
+	}
+	async sendWithdrawProtocolFees(provider, via, value, amount, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.withdrawProtocolFees, queryId).storeCoins(amount).endCell());
+	}
+	async sendDepositProtocolFees(provider, via, value, amount, creator, salt, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.depositProtocolFees, queryId).storeCoins(amount).storeAddress(creator).storeUint(uint(salt, 64, "salt"), 64).endCell());
+	}
+	async sendReinitializeCurve(provider, via, value, creator, salt, metadata, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.reinitializeCurve, queryId).storeAddress(creator).storeUint(uint(salt, 64, "salt"), 64).storeRef(metadata).endCell());
+	}
+	async sendTopUp(provider, via, value) {
+		await this.send(provider, via, value, beginCell().storeUint(TONRESISTOR_OPCODES.topUp, 32).endCell());
+	}
+	async getMasterData(provider) {
+		const stack = await this.get(provider, "get_master_data");
+		return {
+			admin: stack.readAddress(),
+			nextAdmin: stack.readAddressOpt(),
+			treasury: stack.readAddress(),
+			totalLaunches: stack.readBigNumber(),
+			feesBalance: stack.readBigNumber()
+		};
+	}
+	async getLaunchAddress(provider, creator, salt) {
+		return (await this.get(provider, "get_launch_address", [{
+			type: "slice",
+			cell: beginCell().storeAddress(creator).endCell()
+		}, {
+			type: "int",
+			value: salt
+		}])).readAddress();
+	}
+	async getStorageReserve(provider) {
+		return (await this.get(provider, "get_storage_reserve")).readBigNumber();
+	}
+	async getVersion(provider) {
+		return (await this.get(provider, "get_version")).readBigNumber();
+	}
+};
+function buildTonResistorCurveData(config) {
+	uint8(config.state, "state");
+	return beginCell().storeUint(config.state, 8).storeAddress(config.jettonMinter).storeCoins(config.virtualTonReserve).storeCoins(config.realTonReserve ?? 0n).storeCoins(config.curveJettonBalance ?? 0n).storeCoins(config.feeAccrued ?? 0n).storeCoins(config.migrationReserve ?? 0n).storeRef(buildTonResistorLaunchConfig(config.config)).storeBit(config.dropAdminPending ?? false).storeCoins(config.pendingBuyTonInNet ?? 0n).endCell();
+}
+function buildTonResistorLaunchConfig(config) {
+	return beginCell().storeAddress(config.master).storeAddress(config.creator).storeUint(uint(config.salt, 64, "salt"), 64).storeCoins(config.curveSupply).storeCoins(config.dexReserveSupply).storeCoins(config.graduationThreshold).endCell();
+}
+function storeForwardPayload(builder, payload) {
+	if (payload.type === "inline") return builder.storeBit(0).storeSlice(payload.cell.beginParse());
+	return builder.storeBit(1).storeRef(payload.cell);
+}
+var TonResistorBondingCurve = class TonResistorBondingCurve extends ContractWrapper {
+	static createFromAddress(address) {
+		return new TonResistorBondingCurve(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildTonResistorCurveData(config)
+		};
+		return new TonResistorBondingCurve(contractAddress(workchain, init), init);
+	}
+	async sendDeploy(provider, via, value) {
+		await this.send(provider, via, value);
+	}
+	async sendInitialize(provider, via, value, jettonMinter, refundTo, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.initializeCurve, queryId).storeAddress(jettonMinter).storeAddress(refundTo ?? null).endCell());
+	}
+	async sendBuy(provider, via, value, minJettonsOut, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.buyJettons, queryId).storeCoins(minJettonsOut).endCell());
+	}
+	async sendFlushFees(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.flushFees, queryId).endCell());
+	}
+	async sendGraduate(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.graduate, queryId).endCell());
+	}
+	async sendInitPoolResult(provider, via, value, exitCode, customPayload, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.initPoolResult, queryId).storeInt(exitCode, 32).storeMaybeRef(customPayload ?? null).endCell());
+	}
+	async sendTransferNotification(provider, via, value, jettonAmount, transferInitiator, forwardPayload, queryId = 0n) {
+		const body = header(TONRESISTOR_OPCODES.transferNotification, queryId).storeCoins(jettonAmount).storeAddress(transferInitiator);
+		await this.send(provider, via, value, storeForwardPayload(body, forwardPayload).endCell());
+	}
+	async sendTopUp(provider, via, value) {
+		await this.send(provider, via, value, beginCell().storeUint(TONRESISTOR_OPCODES.topUp, 32).endCell());
+	}
+	async getCurveData(provider) {
+		const stack = await this.get(provider, "get_curve_data");
+		return {
+			state: stack.readBigNumber(),
+			creator: stack.readAddress(),
+			salt: stack.readBigNumber(),
+			jettonMinter: stack.readAddressOpt(),
+			virtualTonReserve: stack.readBigNumber(),
+			realTonReserve: stack.readBigNumber(),
+			curveJettonBalance: stack.readBigNumber(),
+			curveSupply: stack.readBigNumber(),
+			dexReserveSupply: stack.readBigNumber(),
+			graduationThreshold: stack.readBigNumber(),
+			feeAccrued: stack.readBigNumber(),
+			migrationReserve: stack.readBigNumber(),
+			dropAdminPending: stack.readBoolean(),
+			pendingBuyTonInNet: stack.readBigNumber()
+		};
+	}
+};
+function buildTonResistorJettonWalletData(config) {
+	return beginCell().storeCoins(config.balance).storeAddress(config.owner).storeAddress(config.minter).endCell();
+}
+var TonResistorJettonWallet = class TonResistorJettonWallet extends ContractWrapper {
+	static createFromAddress(address) {
+		return new TonResistorJettonWallet(address);
+	}
+	static createFromConfig(config, code, workchain = 0) {
+		const init = {
+			code,
+			data: buildTonResistorJettonWalletData(config)
+		};
+		return new TonResistorJettonWallet(contractAddress(workchain, init), init);
+	}
+	async sendAskToTransfer(provider, via, value, input) {
+		const body = header(TONRESISTOR_OPCODES.askToTransfer, input.queryId).storeCoins(input.amount).storeAddress(input.recipient).storeAddress(input.excessesTo ?? null).storeMaybeRef(input.customPayload ?? null).storeCoins(input.forwardAmount);
+		await this.send(provider, via, value, storeForwardPayload(body, input.forwardPayload).endCell());
+	}
+	async sendAskToBurn(provider, via, value, amount, excessesTo, customPayload, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.askToBurn, queryId).storeCoins(amount).storeAddress(excessesTo ?? null).storeMaybeRef(customPayload ?? null).endCell());
+	}
+	async sendInternalTransfer(provider, via, value, input) {
+		const body = header(TONRESISTOR_OPCODES.internalTransfer, input.queryId).storeCoins(input.amount).storeAddress(input.initiator ?? null).storeAddress(input.excessesTo ?? null).storeCoins(input.forwardAmount);
+		await this.send(provider, via, value, storeForwardPayload(body, input.forwardPayload).endCell());
+	}
+	async sendTopUp(provider, via, value) {
+		await this.send(provider, via, value, beginCell().storeUint(TONRESISTOR_OPCODES.topUp, 32).endCell());
+	}
+	async getWalletData(provider) {
+		const stack = await this.get(provider, "get_wallet_data");
+		return {
+			balance: stack.readBigNumber(),
+			owner: stack.readAddress(),
+			minter: stack.readAddress(),
+			walletCode: stack.readCell()
+		};
+	}
+};
+var TonResistorJettonMinter = class TonResistorJettonMinter extends ContractWrapper {
+	static createFromAddress(address) {
+		return new TonResistorJettonMinter(address);
+	}
+	async sendMint(provider, via, value, input) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.mintNewJettons, input.queryId).storeAddress(input.recipient).storeCoins(input.tonAmount).storeRef(input.internalTransfer).endCell());
+	}
+	async sendRequestWalletAddress(provider, via, value, owner, includeOwnerAddress, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.requestWalletAddress, queryId).storeAddress(owner).storeBit(includeOwnerAddress).endCell());
+	}
+	async sendChangeAdmin(provider, via, value, admin, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.changeMinterAdmin, queryId).storeAddress(admin).endCell());
+	}
+	async sendClaimAdmin(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.claimMinterAdmin, queryId).endCell());
+	}
+	async sendDropAdmin(provider, via, value, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.dropMinterAdmin, queryId).endCell());
+	}
+	async sendChangeMetadata(provider, via, value, metadata, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.changeMinterMetadata, queryId).storeRef(metadata).endCell());
+	}
+	async sendUpgradeCode(provider, via, value, newData, newCode, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.upgradeMinterCode, queryId).storeRef(newData).storeRef(newCode).endCell());
+	}
+	async sendBurnNotification(provider, via, value, amount, burnInitiator, excessesTo, queryId = 0n) {
+		await this.send(provider, via, value, header(TONRESISTOR_OPCODES.burnNotification, queryId).storeCoins(amount).storeAddress(burnInitiator).storeAddress(excessesTo ?? null).endCell());
+	}
+	async sendTopUp(provider, via, value) {
+		await this.send(provider, via, value, beginCell().storeUint(TONRESISTOR_OPCODES.topUp, 32).endCell());
+	}
+	async getJettonData(provider) {
+		const stack = await this.get(provider, "get_jetton_data");
+		return {
+			totalSupply: stack.readBigNumber(),
+			mintable: stack.readBoolean(),
+			admin: stack.readAddressOpt(),
+			content: stack.readCell(),
+			walletCode: stack.readCell()
+		};
+	}
+	async getWalletAddress(provider, owner) {
+		return (await this.get(provider, "get_wallet_address", [{
+			type: "slice",
+			cell: beginCell().storeAddress(owner).endCell()
+		}])).readAddress();
+	}
+	async getNextAdmin(provider) {
+		return (await this.get(provider, "get_next_admin_address")).readAddressOpt();
+	}
+};
+function buildTonResistorJettonTransfer(input) {
+	return buildJettonTransferBody(input);
+}
+function buildTonResistorJettonBurn(input) {
+	return buildJettonBurnBody(input);
+}
+//#endregion
+export { TONRESISTOR_BONDING_CURVE_COMMIT, TONRESISTOR_OPCODES, TonResistorBondingCurve, TonResistorBondingCurveMaster, TonResistorJettonMinter, TonResistorJettonWallet, buildTonResistorCurveData, buildTonResistorJettonBurn, buildTonResistorJettonTransfer, buildTonResistorJettonWalletData, buildTonResistorLaunchConfig, buildTonResistorMasterData };

package/dist/core/address.d.mts

@@ -0,0 +1,25 @@
+import { TonNetwork } from "./network.mjs";
+import { Address } from "@ton/core";
+//#region src/core/address.d.ts
+export type TonAddress = string & {
+  readonly __brand: "TonAddress";
+};
+export declare function parseTonAddress(value: string | Address): Address;
+export declare function toTonAddress(value: string | Address): TonAddress;
+export declare function addressesEqual(left: string | Address, right: string | Address): boolean;
+export declare function toFriendlyAddress(value: string | Address, options?: {
+  network?: TonNetwork;
+  bounceable?: boolean;
+}): string;
+/**
+ * Returns a compact, user-facing TON address while preserving the friendly
+ * (base64url) representation used by wallets and explorers.
+ */
+export declare function shortenTonAddress(value: string | Address, options?: {
+  network?: TonNetwork;
+  bounceable?: boolean;
+  prefixLength?: number;
+  suffixLength?: number;
+}): string;
+export declare function assertWorkchain(value: string | Address, workchain: number): void;
+//#endregion

package/dist/core/address.mjs

@@ -0,0 +1,45 @@
+import { TonPackageError, invariant } from "./errors.mjs";
+import { Address } from "@ton/core";
+//#region src/core/address.ts
+function parseTonAddress(value) {
+	if (value instanceof Address) return value;
+	if (typeof value !== "string") throw new TonPackageError("INVALID_ADDRESS", "Invalid TON address");
+	try {
+		return Address.parse(value);
+	} catch (error) {
+		throw new TonPackageError("INVALID_ADDRESS", "Invalid TON address", { cause: String(error) });
+	}
+}
+function toTonAddress(value) {
+	return parseTonAddress(value).toRawString();
+}
+function addressesEqual(left, right) {
+	return parseTonAddress(left).equals(parseTonAddress(right));
+}
+function toFriendlyAddress(value, options = {}) {
+	invariant(options.network === void 0 || options.network === "mainnet" || options.network === "testnet", "INVALID_NETWORK", "Unsupported TON network");
+	return parseTonAddress(value).toString({
+		urlSafe: true,
+		bounceable: options.bounceable ?? true,
+		testOnly: options.network === "testnet"
+	});
+}
+/**
+* Returns a compact, user-facing TON address while preserving the friendly
+* (base64url) representation used by wallets and explorers.
+*/
+function shortenTonAddress(value, options = {}) {
+	const friendlyAddress = toFriendlyAddress(value, options);
+	const prefixLength = options.prefixLength ?? 6;
+	const suffixLength = options.suffixLength ?? 4;
+	invariant(Number.isSafeInteger(prefixLength) && prefixLength >= 0, "INVALID_ADDRESS", "Address prefix length must be a non-negative safe integer");
+	invariant(Number.isSafeInteger(suffixLength) && suffixLength >= 0, "INVALID_ADDRESS", "Address suffix length must be a non-negative safe integer");
+	if (friendlyAddress.length <= prefixLength + suffixLength + 1) return friendlyAddress;
+	return `${friendlyAddress.slice(0, prefixLength)}…${friendlyAddress.slice(-suffixLength)}`;
+}
+function assertWorkchain(value, workchain) {
+	const address = parseTonAddress(value);
+	invariant(address.workChain === workchain, "INVALID_ADDRESS", `Expected workchain ${workchain}, received ${address.workChain}`);
+}
+//#endregion
+export { addressesEqual, assertWorkchain, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress };

package/dist/core/amount.d.mts

@@ -0,0 +1,8 @@
+//#region src/core/amount.d.ts
+export declare const MAX_TON_COINS: bigint;
+export declare function assertTonAmount(value: bigint, label?: string): void;
+export declare function parseUnits(value: string, decimals: number): bigint;
+export declare function formatUnits(value: bigint, decimals: number, trimTrailingZeros?: boolean): string;
+export declare const parseTon: (value: string) => bigint;
+export declare const formatTon: (value: bigint) => string;
+//#endregion

package/dist/core/amount.mjs

@@ -0,0 +1,34 @@
+import { invariant } from "./errors.mjs";
+//#region src/core/amount.ts
+const DECIMAL_PATTERN = /^\d+(?:\.\d+)?$/;
+const MAX_TON_COINS = (1n << 120n) - 1n;
+function assertTonAmount(value, label = "TON amount") {
+	invariant(typeof value === "bigint" && value >= 0n && value <= MAX_TON_COINS, "INVALID_AMOUNT", `${label} is outside the TON coin range`);
+}
+function parseUnits(value, decimals) {
+	invariant(typeof value === "string", "INVALID_AMOUNT", "Amount must be a decimal string");
+	invariant(Number.isInteger(decimals) && decimals >= 0 && decimals <= 255, "INVALID_AMOUNT", "Invalid decimals");
+	const normalized = value.trim();
+	invariant(DECIMAL_PATTERN.test(normalized), "INVALID_AMOUNT", "Amount must be a non-negative decimal string");
+	const [whole = "", fraction = ""] = normalized.split(".");
+	invariant(fraction.length <= decimals, "INVALID_AMOUNT", "Amount has more fractional digits than the token supports");
+	const paddedFraction = fraction.padEnd(decimals, "0");
+	return BigInt(whole) * BigInt(10) ** BigInt(decimals) + BigInt(paddedFraction || "0");
+}
+function formatUnits(value, decimals, trimTrailingZeros = true) {
+	invariant(typeof value === "bigint", "INVALID_AMOUNT", "Amount must be a bigint");
+	invariant(Number.isInteger(decimals) && decimals >= 0 && decimals <= 255, "INVALID_AMOUNT", "Invalid decimals");
+	invariant(value >= BigInt(0), "INVALID_AMOUNT", "Amount cannot be negative");
+	if (decimals === 0) return value.toString();
+	const scale = BigInt(10) ** BigInt(decimals);
+	const whole = value / scale;
+	const fraction = value % scale;
+	if (fraction === BigInt(0)) return whole.toString();
+	let fractional = fraction.toString().padStart(decimals, "0");
+	if (trimTrailingZeros) fractional = fractional.replace(/0+$/, "");
+	return `${whole}.${fractional}`;
+}
+const parseTon = (value) => parseUnits(value, 9);
+const formatTon = (value) => formatUnits(value, 9);
+//#endregion
+export { MAX_TON_COINS, assertTonAmount, formatTon, formatUnits, parseTon, parseUnits };

package/dist/core/bytes.d.mts

@@ -0,0 +1,5 @@
+//#region src/core/bytes.d.ts
+export declare function bytesToBase64(bytes: Uint8Array): string;
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare function hexToBytes(value: string): Uint8Array;
+//#endregion

package/dist/core/bytes.mjs

@@ -0,0 +1,18 @@
+//#region src/core/bytes.ts
+function bytesToBase64(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	if (typeof btoa === "function") return btoa(binary);
+	return Buffer.from(bytes).toString("base64");
+}
+function bytesToHex(bytes) {
+	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(value) {
+	if (!/^(?:[0-9a-f]{2})*$/i.test(value)) throw new Error("Invalid hexadecimal value");
+	const bytes = new Uint8Array(value.length / 2);
+	for (let index = 0; index < bytes.length; index += 1) bytes[index] = Number.parseInt(value.slice(index * 2, index * 2 + 2), 16);
+	return bytes;
+}
+//#endregion
+export { bytesToBase64, bytesToHex, hexToBytes };

package/dist/core/constants.d.mts

@@ -0,0 +1,14 @@
+//#region src/core/constants.d.ts
+export declare const PIZZATON_MAINNET_ADDRESSES: {
+  readonly ptjMaster: "EQAgotSkX06MIW-A0ni5yKqeNlwc3nASnbO1dwGo-kwpg2Zg";
+  readonly pizzaBoyNftCollection: "EQA6A7BJi3m_DF7hnVjzrm_Oj0XeaT9e_rqCRRn99sHvYbcD";
+  readonly saleCoordinator: "EQAagkh1kW3ZoK0zNn3QnOC0kKKDJi3AcxcEgnh5uz1LyrfZ";
+};
+export declare const PTJ_TOKEN_INFO: {
+  readonly symbol: "PTJ";
+  readonly name: "PizzaTon Token";
+  readonly decimals: 9;
+  readonly maxSupply: bigint;
+  readonly masterAddress: "EQAgotSkX06MIW-A0ni5yKqeNlwc3nASnbO1dwGo-kwpg2Zg";
+};
+//#endregion

package/dist/core/constants.mjs

@@ -0,0 +1,15 @@
+//#region src/core/constants.ts
+const PIZZATON_MAINNET_ADDRESSES = {
+	ptjMaster: "EQAgotSkX06MIW-A0ni5yKqeNlwc3nASnbO1dwGo-kwpg2Zg",
+	pizzaBoyNftCollection: "EQA6A7BJi3m_DF7hnVjzrm_Oj0XeaT9e_rqCRRn99sHvYbcD",
+	saleCoordinator: "EQAagkh1kW3ZoK0zNn3QnOC0kKKDJi3AcxcEgnh5uz1LyrfZ"
+};
+const PTJ_TOKEN_INFO = {
+	symbol: "PTJ",
+	name: "PizzaTon Token",
+	decimals: 9,
+	maxSupply: 200000000n * 10n ** 9n,
+	masterAddress: PIZZATON_MAINNET_ADDRESSES.ptjMaster
+};
+//#endregion
+export { PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO };

package/dist/core/errors.d.mts

@@ -0,0 +1,9 @@
+//#region src/core/errors.d.ts
+export type TonErrorCode = "INVALID_ADDRESS" | "INVALID_AMOUNT" | "INVALID_NETWORK" | "INVALID_TRANSACTION" | "INVALID_METADATA" | "INVALID_PROOF" | "INVALID_SCHEDULE" | "PROVIDER_ERROR";
+export declare class TonPackageError extends Error {
+  readonly code: TonErrorCode;
+  readonly details: Readonly<Record<string, unknown>> | undefined;
+  constructor(code: TonErrorCode, message: string, details?: Readonly<Record<string, unknown>>);
+}
+export declare function invariant(condition: unknown, code: TonErrorCode, message: string, details?: Readonly<Record<string, unknown>>): asserts condition;
+//#endregion

package/dist/core/errors.mjs

@@ -0,0 +1,16 @@
+//#region src/core/errors.ts
+var TonPackageError = class extends Error {
+	code;
+	details;
+	constructor(code, message, details) {
+		super(message);
+		this.name = "TonPackageError";
+		this.code = code;
+		this.details = details;
+	}
+};
+function invariant(condition, code, message, details) {
+	if (!condition) throw new TonPackageError(code, message, details);
+}
+//#endregion
+export { TonPackageError, invariant };

package/dist/core/http.mjs

@@ -0,0 +1,39 @@
+import { TonPackageError, invariant } from "./errors.mjs";
+//#region src/core/http.ts
+function normalizeHttpsBaseUrl(value, provider) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		throw new TonPackageError("INVALID_NETWORK", `${provider} base URL must be a valid HTTPS URL`);
+	}
+	invariant(url.protocol === "https:" && !url.username && !url.password && !url.search && !url.hash, "INVALID_NETWORK", `${provider} base URL must use HTTPS and contain no credentials, query, or fragment`);
+	return url.toString().replace(/\/$/, "");
+}
+function validateRequestTimeout(timeoutMs, provider) {
+	const timeout = timeoutMs ?? 1e4;
+	invariant(Number.isSafeInteger(timeout) && timeout > 0, "INVALID_NETWORK", `${provider} timeout must be a positive safe integer`);
+	return timeout;
+}
+function createTimedFetch(fetcher, timeoutMs, provider) {
+	return (async (input, init) => {
+		const timeoutSignal = AbortSignal.timeout(timeoutMs);
+		const signal = init?.signal ? AbortSignal.any([init.signal, timeoutSignal]) : timeoutSignal;
+		try {
+			return await fetcher(input, {
+				...init,
+				signal
+			});
+		} catch (cause) {
+			const timedOut = timeoutSignal.aborted && !init?.signal?.aborted;
+			throw new TonPackageError("PROVIDER_ERROR", `${provider} request ${timedOut ? "timed out" : "failed"}`, {
+				provider,
+				timedOut,
+				timeoutMs,
+				causeName: cause instanceof Error ? cause.name : typeof cause
+			});
+		}
+	});
+}
+//#endregion
+export { createTimedFetch, normalizeHttpsBaseUrl, validateRequestTimeout };

package/dist/core/index.d.mts

@@ -0,0 +1,8 @@
+import { TON_NETWORKS, TonNetwork, TonNetworkConfig, createNetworkConfig, explorerAddressUrl } from "./network.mjs";
+import { TonAddress, addressesEqual, assertWorkchain, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress } from "./address.mjs";
+import { TokenMetadata, parseTokenMetadata, parseTokenMetadataJson } from "./metadata.mjs";
+import { MAX_TON_COINS, assertTonAmount, formatTon, formatUnits, parseTon, parseUnits } from "./amount.mjs";
+import { bytesToBase64, bytesToHex, hexToBytes } from "./bytes.mjs";
+import { PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO } from "./constants.mjs";
+import { TonErrorCode, TonPackageError, invariant } from "./errors.mjs";
+export { MAX_TON_COINS, PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO, TON_NETWORKS, TokenMetadata, TonAddress, TonErrorCode, TonNetwork, TonNetworkConfig, TonPackageError, addressesEqual, assertTonAmount, assertWorkchain, bytesToBase64, bytesToHex, createNetworkConfig, explorerAddressUrl, formatTon, formatUnits, hexToBytes, invariant, parseTokenMetadata, parseTokenMetadataJson, parseTon, parseTonAddress, parseUnits, shortenTonAddress, toFriendlyAddress, toTonAddress };

package/dist/core/index.mjs

@@ -0,0 +1,8 @@
+import { TonPackageError, invariant } from "./errors.mjs";
+import { addressesEqual, assertWorkchain, parseTonAddress, shortenTonAddress, toFriendlyAddress, toTonAddress } from "./address.mjs";
+import { MAX_TON_COINS, assertTonAmount, formatTon, formatUnits, parseTon, parseUnits } from "./amount.mjs";
+import { bytesToBase64, bytesToHex, hexToBytes } from "./bytes.mjs";
+import { PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO } from "./constants.mjs";
+import { parseTokenMetadata, parseTokenMetadataJson } from "./metadata.mjs";
+import { TON_NETWORKS, createNetworkConfig, explorerAddressUrl } from "./network.mjs";
+export { MAX_TON_COINS, PIZZATON_MAINNET_ADDRESSES, PTJ_TOKEN_INFO, TON_NETWORKS, TonPackageError, addressesEqual, assertTonAmount, assertWorkchain, bytesToBase64, bytesToHex, createNetworkConfig, explorerAddressUrl, formatTon, formatUnits, hexToBytes, invariant, parseTokenMetadata, parseTokenMetadataJson, parseTon, parseTonAddress, parseUnits, shortenTonAddress, toFriendlyAddress, toTonAddress };

package/dist/core/metadata.d.mts

@@ -0,0 +1,12 @@
+//#region src/core/metadata.d.ts
+export interface TokenMetadata {
+  readonly name?: string;
+  readonly symbol?: string;
+  readonly description?: string;
+  readonly image?: string;
+  readonly decimals?: number;
+  readonly uri?: string;
+}
+export declare function parseTokenMetadata(value: unknown): TokenMetadata;
+export declare function parseTokenMetadataJson(json: string): TokenMetadata;
+//#endregion

package/dist/core/metadata.mjs

@@ -0,0 +1,35 @@
+import { TonPackageError } from "./errors.mjs";
+import { z } from "zod";
+//#region src/core/metadata.ts
+const TOKEN_METADATA_MAX_BYTES = 65536;
+const tokenMetadataSchema = z.object({
+	name: z.string().max(256).optional(),
+	symbol: z.string().max(64).optional(),
+	description: z.string().max(8192).optional(),
+	image: z.string().max(2048).optional(),
+	decimals: z.number().int().min(0).max(255).optional(),
+	uri: z.string().max(2048).optional()
+});
+function parseTokenMetadata(value) {
+	const result = tokenMetadataSchema.safeParse(value);
+	if (!result.success) throw new TonPackageError("INVALID_METADATA", "Token metadata failed validation", { issues: result.error.issues.map((issue) => issue.message) });
+	return {
+		...result.data.name === void 0 ? {} : { name: result.data.name },
+		...result.data.symbol === void 0 ? {} : { symbol: result.data.symbol },
+		...result.data.description === void 0 ? {} : { description: result.data.description },
+		...result.data.image === void 0 ? {} : { image: result.data.image },
+		...result.data.decimals === void 0 ? {} : { decimals: result.data.decimals },
+		...result.data.uri === void 0 ? {} : { uri: result.data.uri }
+	};
+}
+function parseTokenMetadataJson(json) {
+	if (new TextEncoder().encode(json).byteLength > TOKEN_METADATA_MAX_BYTES) throw new TonPackageError("INVALID_METADATA", "Token metadata exceeds the size limit");
+	try {
+		return parseTokenMetadata(JSON.parse(json));
+	} catch (error) {
+		if (error instanceof TonPackageError) throw error;
+		throw new TonPackageError("INVALID_METADATA", "Token metadata is not valid JSON", { cause: String(error) });
+	}
+}
+//#endregion
+export { parseTokenMetadata, parseTokenMetadataJson };

package/dist/core/network.d.mts

@@ -0,0 +1,24 @@
+//#region src/core/network.d.ts
+export declare const TON_NETWORKS: {
+  readonly mainnet: {
+    readonly network: "mainnet";
+    readonly explorerBaseUrl: "https://tonviewer.com";
+  };
+  readonly testnet: {
+    readonly network: "testnet";
+    readonly explorerBaseUrl: "https://testnet.tonviewer.com";
+  };
+};
+export type TonNetwork = keyof typeof TON_NETWORKS;
+export interface TonNetworkConfig {
+  readonly network: TonNetwork;
+  readonly endpoint: string;
+  readonly explorerBaseUrl: string;
+}
+export declare function createNetworkConfig(input: {
+  network: TonNetwork;
+  endpoint: string;
+  explorerBaseUrl?: string;
+}): TonNetworkConfig;
+export declare function explorerAddressUrl(config: TonNetworkConfig, address: string): string;
+//#endregion

package/dist/core/network.mjs

@@ -0,0 +1,41 @@
+import { TonPackageError } from "./errors.mjs";
+//#region src/core/network.ts
+const TON_NETWORKS = {
+	mainnet: {
+		network: "mainnet",
+		explorerBaseUrl: "https://tonviewer.com"
+	},
+	testnet: {
+		network: "testnet",
+		explorerBaseUrl: "https://testnet.tonviewer.com"
+	}
+};
+function createNetworkConfig(input) {
+	if (input.network !== "mainnet" && input.network !== "testnet") throw new TonPackageError("INVALID_NETWORK", "Unsupported TON network");
+	let endpoint;
+	try {
+		endpoint = new URL(input.endpoint);
+	} catch {
+		throw new TonPackageError("INVALID_NETWORK", "TON endpoint must be a valid URL");
+	}
+	if (endpoint.protocol !== "https:") throw new TonPackageError("INVALID_NETWORK", "TON endpoint must use HTTPS");
+	if (endpoint.username || endpoint.password) throw new TonPackageError("INVALID_NETWORK", "TON endpoint must not include embedded credentials");
+	const explorerInput = input.explorerBaseUrl ?? TON_NETWORKS[input.network].explorerBaseUrl;
+	let explorer;
+	try {
+		explorer = new URL(explorerInput);
+	} catch {
+		throw new TonPackageError("INVALID_NETWORK", "TON explorer URL must be a valid URL");
+	}
+	if (explorer.protocol !== "https:" || explorer.username || explorer.password) throw new TonPackageError("INVALID_NETWORK", "TON explorer URL must use HTTPS and must not include credentials");
+	return Object.freeze({
+		network: input.network,
+		endpoint: endpoint.toString(),
+		explorerBaseUrl: explorer.toString().replace(/\/$/, "")
+	});
+}
+function explorerAddressUrl(config, address) {
+	return `${config.explorerBaseUrl}/${encodeURIComponent(address)}`;
+}
+//#endregion
+export { TON_NETWORKS, createNetworkConfig, explorerAddressUrl };