@pizzaton/ton 0.0.0-stage → 0.1.0

package/dist/provider/index.d.mts

@@ -0,0 +1,32 @@
+import { TonNetwork } from "../core/network.mjs";
+import { Address, Contract, ContractProvider, OpenedContract, StateInit, TupleItem, TupleReader } from "@ton/core";
+//#region src/provider/index.d.ts
+export interface TonAccountState {
+  readonly status: "active" | "uninitialized" | "frozen" | "non-existing";
+  readonly balance: bigint;
+}
+export interface TonTransactionSummary {
+  readonly lt: bigint;
+  readonly hash: string;
+  readonly timestamp: number;
+}
+export interface TonGetMethodResult {
+  readonly gasUsed: number;
+  readonly stack: TupleReader;
+  readonly exitCode?: number;
+}
+export interface TonProvider {
+  readonly network: TonNetwork;
+  openContract<T extends Contract>(contract: T): OpenedContract<T>;
+  contractProvider(address: Address, init?: StateInit | null): ContractProvider;
+  getBalance(address: Address): Promise<bigint>;
+  getAccountState(address: Address): Promise<TonAccountState>;
+  runGetMethod(address: Address, method: string, args?: readonly TupleItem[]): Promise<TonGetMethodResult>;
+  getTransactions(address: Address, options?: {
+    readonly limit?: number;
+    readonly lt?: bigint;
+    readonly hash?: string;
+  }): Promise<readonly TonTransactionSummary[]>;
+  isContractDeployed(address: Address): Promise<boolean>;
+}
+//#endregion

package/dist/provider/index.mjs

@@ -0,0 +1 @@
+export {};

package/dist/react/index.d.mts

@@ -0,0 +1,13 @@
+import { TransactionIntent } from "../transactions/index.mjs";
+import { TonConnectAdapter, TonConnectWallet } from "../connect/index.mjs";
+//#region src/react/index.d.ts
+export declare function useTonWallet(adapter: TonConnectAdapter | null): TonConnectWallet | null;
+export type TonTransactionStatus = "idle" | "sending" | "sent" | "error";
+export declare function useTonTransaction(adapter: TonConnectAdapter | null): {
+  readonly send: (intent: TransactionIntent) => Promise<string | null>;
+  readonly status: TonTransactionStatus;
+  readonly boc: string | null;
+  readonly error: Error | null;
+  readonly reset: () => void;
+};
+//#endregion

package/dist/react/index.mjs

@@ -0,0 +1,48 @@
+import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
+//#region src/react/index.ts
+function useTonWallet(adapter) {
+	return useSyncExternalStore((listener) => adapter?.subscribe(listener) ?? (() => void 0), () => adapter?.getWallet() ?? null, () => null);
+}
+function useTonTransaction(adapter) {
+	const [status, setStatus] = useState("idle");
+	const [boc, setBoc] = useState(null);
+	const [error, setError] = useState(null);
+	const sending = useRef(false);
+	const reset = useCallback(() => {
+		setStatus("idle");
+		setBoc(null);
+		setError(null);
+	}, []);
+	const send = useCallback(async (intent) => {
+		if (!adapter) throw new Error("A TON Connect adapter is required");
+		if (sending.current) throw new Error("A TON transaction is already being sent");
+		sending.current = true;
+		setStatus("sending");
+		setError(null);
+		try {
+			const result = await adapter.sendTransaction(intent);
+			setBoc(result);
+			setStatus("sent");
+			return result;
+		} catch (cause) {
+			const nextError = cause instanceof Error ? cause : new Error(String(cause));
+			setError(nextError);
+			setStatus("error");
+			return null;
+		} finally {
+			sending.current = false;
+		}
+	}, [adapter]);
+	useEffect(() => {
+		if (!adapter) reset();
+	}, [adapter, reset]);
+	return {
+		send,
+		status,
+		boc,
+		error,
+		reset
+	};
+}
+//#endregion
+export { useTonTransaction, useTonWallet };

package/dist/server/index.d.mts

@@ -0,0 +1,11 @@
+import { TonNetwork } from "../core/network.mjs";
+import { TonProvider } from "../provider/index.mjs";
+//#region src/server/index.d.ts
+export interface TonHttpProviderOptions {
+  readonly network: TonNetwork;
+  readonly endpoint: string;
+  readonly apiKey?: string;
+  readonly timeoutMs?: number;
+}
+export declare function createTonHttpProvider(options: TonHttpProviderOptions): TonProvider;
+//#endregion

package/dist/server/index.mjs

@@ -0,0 +1,55 @@
+import { invariant } from "../core/errors.mjs";
+import { createNetworkConfig } from "../core/network.mjs";
+import { TonClient } from "@ton/ton";
+//#region src/server/index.ts
+function createTonHttpProvider(options) {
+	const networkConfig = createNetworkConfig({
+		network: options.network,
+		endpoint: options.endpoint
+	});
+	const timeoutMs = options.timeoutMs ?? 1e4;
+	invariant(Number.isSafeInteger(timeoutMs) && timeoutMs > 0, "INVALID_NETWORK", "TON provider timeout must be a positive safe integer");
+	const client = new TonClient({
+		endpoint: networkConfig.endpoint,
+		...options.apiKey === void 0 ? {} : { apiKey: options.apiKey },
+		timeout: timeoutMs
+	});
+	return {
+		network: options.network,
+		openContract: (contract) => client.open(contract),
+		contractProvider: (address, init) => client.provider(address, init),
+		getBalance: (address) => client.getBalance(address),
+		async getAccountState(address) {
+			const state = await client.getContractState(address);
+			return {
+				status: state.state === "active" ? "active" : state.state === "frozen" ? "frozen" : "uninitialized",
+				balance: state.balance
+			};
+		},
+		async runGetMethod(address, method, args) {
+			const result = await client.runMethodWithError(address, method, args ? [...args] : []);
+			return {
+				gasUsed: result.gas_used,
+				stack: result.stack,
+				exitCode: result.exit_code
+			};
+		},
+		async getTransactions(address, transactionOptions) {
+			const limit = transactionOptions?.limit ?? 20;
+			invariant(Number.isSafeInteger(limit) && limit >= 1 && limit <= 1e3, "INVALID_TRANSACTION", "Transaction limit must be an integer from 1 to 1000");
+			if (transactionOptions?.lt !== void 0) invariant(transactionOptions.lt >= 0n, "INVALID_TRANSACTION", "Transaction logical time cannot be negative");
+			return (await client.getTransactions(address, {
+				limit,
+				...transactionOptions?.lt !== void 0 ? { lt: transactionOptions.lt.toString() } : {},
+				...transactionOptions?.hash ? { hash: transactionOptions.hash } : {}
+			})).map((transaction) => ({
+				lt: transaction.lt,
+				hash: transaction.hash().toString("hex"),
+				timestamp: transaction.now
+			}));
+		},
+		isContractDeployed: (address) => client.isContractDeployed(address)
+	};
+}
+//#endregion
+export { createTonHttpProvider };

package/dist/simulation/index.d.mts

@@ -0,0 +1,112 @@
+import { Address, Cell, Message, StateInit } from "@ton/core";
+import { AccountEvent } from "@ton-api/client";
+import { Blockchain, BlockchainConfig, Event } from "@ton/sandbox";
+//#region src/simulation/index.d.ts
+export type TonSimulationSource = "sandbox" | "tonapi";
+export interface TonSimulationInput {
+  /** A serialized external or internal message, or a message object for local sandbox execution. */
+  readonly message: Cell | Message;
+  /** Required for unsigned external-wallet previews. Internal messages do not need this flag. */
+  readonly ignoreSignatureCheck?: boolean;
+  /** Keep mutations in a local sandbox. Preview callers should leave this false. */
+  readonly persist?: boolean;
+}
+export interface TonSimulationMessage {
+  readonly type: "internal" | "external-in" | "external-out";
+  readonly source?: Address;
+  readonly destination?: Address;
+  readonly value?: bigint;
+  readonly body?: Cell;
+  readonly init?: StateInit;
+  readonly createdAt?: number;
+  readonly createdLt?: bigint;
+}
+export interface TonSimulationTransaction {
+  readonly hash: string;
+  readonly logicalTime: bigint;
+  /** Raw 256-bit account identifier; TON transactions do not carry the workchain in this field. */
+  readonly accountId: string;
+  readonly timestamp: number;
+  readonly success: boolean;
+  readonly oldStatus: string;
+  readonly endStatus: string;
+  readonly totalFees: bigint;
+  readonly storageFees: bigint;
+  readonly gasFees: bigint;
+  readonly forwardFees: bigint;
+  readonly actionFees: bigint;
+  readonly gasUsed: bigint;
+  readonly vmSteps: number;
+  readonly exitCode?: number;
+  readonly actionSuccess?: boolean;
+  readonly input?: TonSimulationMessage;
+  readonly outputs: readonly TonSimulationMessage[];
+  readonly parentHash?: string;
+  readonly childHashes: readonly string[];
+  readonly blockchainLogs: string;
+  readonly vmLogs: string;
+  readonly debugLogs: string;
+  readonly oldStorage?: Cell;
+  readonly newStorage?: Cell;
+}
+export interface TonSimulationCost {
+  readonly totalFees: bigint;
+  readonly storageFees: bigint;
+  readonly gasFees: bigint;
+  readonly forwardFees: bigint;
+  readonly actionFees: bigint;
+  readonly gasUsed: bigint;
+  readonly vmSteps: number;
+}
+export interface TonSimulationError {
+  readonly message: string;
+  readonly exitCode?: number;
+}
+export interface TonSimulationResult {
+  readonly source: TonSimulationSource;
+  readonly success: boolean;
+  readonly transactions: readonly TonSimulationTransaction[];
+  readonly cost: TonSimulationCost;
+  readonly rootTransactionHash?: string;
+  readonly events?: readonly Event[] | readonly AccountEvent[];
+  readonly error?: TonSimulationError;
+  /** Always true for remote previews because the remote chain may change before signing. */
+  readonly speculative: boolean;
+}
+export interface TonSimulationAdapter {
+  readonly source: TonSimulationSource;
+  simulate(input: TonSimulationInput): Promise<TonSimulationResult>;
+}
+export declare function createTonSimulationWithFallback(primary: TonSimulationAdapter, fallback: TonSimulationAdapter): TonSimulationAdapter;
+export interface TonSandboxSimulation extends TonSimulationAdapter {
+  readonly source: "sandbox";
+  readonly blockchain: Blockchain;
+}
+export interface TonSandboxSimulationOptions {
+  /** Recording storage snapshots makes state diffs available but is slower. */
+  readonly recordStorage?: boolean;
+}
+export declare function messageToCell(message: Message): Cell;
+export declare function createTonSandboxSimulation(blockchain: Blockchain, options?: TonSandboxSimulationOptions): TonSandboxSimulation;
+export interface TonClient4SandboxSimulationOptions {
+  readonly endpoint: string;
+  readonly timeoutMs?: number;
+  readonly blockSeqno?: number;
+  readonly config?: BlockchainConfig;
+  readonly now?: number;
+  readonly recordStorage?: boolean;
+}
+/**
+ * Creates a native sandbox backed by a read-only snapshot of the live chain.
+ * Contract code and account state are fetched lazily from TonClient4.
+ */
+export declare function createTonClient4SandboxSimulation(options: TonClient4SandboxSimulationOptions): Promise<TonSandboxSimulation>;
+export interface TonApiSimulationFallbackOptions {
+  readonly baseUrl?: string;
+  readonly apiKey?: string;
+  readonly timeoutMs?: number;
+  readonly fetch?: typeof globalThis.fetch;
+}
+/** Optional fallback for clients that cannot hydrate a native sandbox snapshot. */
+export declare function createTonApiSimulationFallback(options?: TonApiSimulationFallbackOptions): TonSimulationAdapter;
+//#endregion

package/dist/simulation/index.mjs

@@ -0,0 +1,310 @@
+import { invariant } from "../core/errors.mjs";
+import { createTimedFetch, normalizeHttpsBaseUrl, validateRequestTimeout } from "../core/http.mjs";
+import { Cell, beginCell, storeMessage } from "@ton/core";
+import { TonClient4 } from "@ton/ton";
+import { TonApiClient } from "@ton-api/client";
+import { Blockchain, RemoteBlockchainStorage, wrapTonClient4ForRemote } from "@ton/sandbox";
+//#region src/simulation/index.ts
+function createTonSimulationWithFallback(primary, fallback) {
+	return {
+		source: primary.source,
+		async simulate(input) {
+			try {
+				const result = await primary.simulate(input);
+				if (!result.error) return result;
+			} catch {}
+			return fallback.simulate(input);
+		}
+	};
+}
+function messageToCell(message) {
+	return beginCell().store(storeMessage(message)).endCell();
+}
+function createTonSandboxSimulation(blockchain, options = {}) {
+	blockchain.recordStorage = options.recordStorage ?? true;
+	return {
+		source: "sandbox",
+		blockchain,
+		async simulate(input) {
+			return withBlockchainLock(blockchain, async () => {
+				const snapshot = blockchain.snapshot();
+				try {
+					const result = await blockchain.sendMessage(input.message, { ignoreChksig: input.ignoreSignatureCheck ?? false });
+					return buildSandboxResult(result.transactions, result.events);
+				} catch (cause) {
+					return buildFailureResult("sandbox", cause, false);
+				} finally {
+					if (!input.persist) await blockchain.loadFrom(snapshot);
+				}
+			});
+		}
+	};
+}
+/**
+* Creates a native sandbox backed by a read-only snapshot of the live chain.
+* Contract code and account state are fetched lazily from TonClient4.
+*/
+async function createTonClient4SandboxSimulation(options) {
+	const endpoint = normalizeHttpsBaseUrl(options.endpoint, "TON Client4 endpoint");
+	const timeoutMs = validateRequestTimeout(options.timeoutMs, "TON Client4");
+	if (options.blockSeqno !== void 0) invariant(Number.isSafeInteger(options.blockSeqno) && options.blockSeqno >= 0, "INVALID_NETWORK", "TON Client4 block sequence number must be a non-negative safe integer");
+	if (options.now !== void 0) invariant(Number.isSafeInteger(options.now) && options.now >= 0, "INVALID_NETWORK", "TON simulation time must be a non-negative safe integer");
+	const client = new TonClient4({
+		endpoint,
+		timeout: timeoutMs
+	});
+	const latest = await client.getLastBlock();
+	const blockSeqno = options.blockSeqno ?? latest.last.seqno;
+	const config = options.config ?? Cell.fromBase64((await client.getConfig(blockSeqno)).config.cell);
+	const blockchain = await Blockchain.create({
+		config,
+		storage: new RemoteBlockchainStorage(wrapTonClient4ForRemote(client), blockSeqno),
+		autoDeployLibs: true
+	});
+	blockchain.now = options.now ?? latest.now;
+	return createTonSandboxSimulation(blockchain, options);
+}
+/** Optional fallback for clients that cannot hydrate a native sandbox snapshot. */
+function createTonApiSimulationFallback(options = {}) {
+	const baseUrl = options.baseUrl ?? "https://tonapi.io";
+	const normalizedBaseUrl = normalizeHttpsBaseUrl(baseUrl, "TonAPI");
+	const timeoutMs = validateRequestTimeout(options.timeoutMs, "TonAPI");
+	const client = new TonApiClient({
+		baseUrl: normalizedBaseUrl,
+		fetch: createTimedFetch(options.fetch ?? globalThis.fetch, timeoutMs, "TonAPI"),
+		...options.apiKey === void 0 ? {} : { apiKey: options.apiKey }
+	});
+	return {
+		source: "tonapi",
+		async simulate(input) {
+			const boc = input.message instanceof Cell ? input.message : messageToCell(input.message);
+			try {
+				return buildTonApiResult(await client.emulation.emulateMessageToTrace({ boc }, { ignore_signature_check: input.ignoreSignatureCheck ?? false }));
+			} catch (cause) {
+				return buildFailureResult("tonapi", cause, true);
+			}
+		}
+	};
+}
+function buildSandboxResult(transactions, events) {
+	const normalized = transactions.map(normalizeSandboxTransaction);
+	const rootTransaction = normalized.find((transaction) => !transaction.parentHash);
+	const cost = normalized.reduce((total, transaction) => ({
+		totalFees: total.totalFees + transaction.totalFees,
+		storageFees: total.storageFees + transaction.storageFees,
+		gasFees: total.gasFees + transaction.gasFees,
+		forwardFees: total.forwardFees + transaction.forwardFees,
+		actionFees: total.actionFees + transaction.actionFees,
+		gasUsed: total.gasUsed + transaction.gasUsed,
+		vmSteps: total.vmSteps + transaction.vmSteps
+	}), zeroCost());
+	return {
+		source: "sandbox",
+		success: normalized.length > 0 && normalized.every((transaction) => transaction.success),
+		transactions: normalized,
+		cost,
+		events,
+		...rootTransaction ? { rootTransactionHash: rootTransaction.hash } : {},
+		...normalized.length === 0 ? { error: { message: "Sandbox produced no transactions" } } : {},
+		speculative: false
+	};
+}
+function normalizeSandboxTransaction(transaction) {
+	const description = transaction.description;
+	const compute = "computePhase" in description ? description.computePhase : void 0;
+	const storage = "storagePhase" in description ? description.storagePhase : void 0;
+	const action = "actionPhase" in description ? description.actionPhase : void 0;
+	const computePhase = compute ?? void 0;
+	const actionPhase = action ?? void 0;
+	const gasUsed = computePhase?.type === "vm" ? computePhase.gasUsed : 0n;
+	const gasFees = computePhase?.type === "vm" ? computePhase.gasFees : 0n;
+	const vmSteps = computePhase?.type === "vm" ? computePhase.vmSteps : 0;
+	const actionFees = actionPhase?.totalActionFees ?? 0n;
+	const forwardFees = actionPhase?.totalFwdFees ?? 0n;
+	const aborted = "aborted" in description ? description.aborted : false;
+	const computeSuccess = computePhase?.type === "vm" ? computePhase.success : true;
+	const actionSuccess = actionPhase?.success;
+	return {
+		hash: transaction.hash().toString("hex"),
+		logicalTime: transaction.lt,
+		accountId: transaction.address.toString(16).padStart(64, "0"),
+		timestamp: transaction.now,
+		success: !aborted && computeSuccess && actionSuccess !== false,
+		oldStatus: transaction.oldStatus,
+		endStatus: transaction.endStatus,
+		totalFees: transaction.totalFees.coins,
+		storageFees: storage?.storageFeesCollected ?? 0n,
+		gasFees,
+		forwardFees,
+		actionFees,
+		gasUsed,
+		vmSteps,
+		...computePhase?.type === "vm" ? { exitCode: computePhase.exitCode } : {},
+		...actionSuccess !== void 0 ? { actionSuccess } : {},
+		...transaction.inMessage ? { input: summarizeMessage(transaction.inMessage) } : {},
+		outputs: transaction.outMessages.values().map(summarizeMessage),
+		...transaction.parent ? { parentHash: transaction.parent.hash().toString("hex") } : {},
+		childHashes: transaction.children.map((child) => child.hash().toString("hex")),
+		blockchainLogs: transaction.blockchainLogs,
+		vmLogs: transaction.vmLogs,
+		debugLogs: transaction.debugLogs,
+		...transaction.oldStorage ? { oldStorage: transaction.oldStorage } : {},
+		...transaction.newStorage ? { newStorage: transaction.newStorage } : {}
+	};
+}
+function summarizeMessage(message) {
+	const info = message.info;
+	if (info.type === "internal") return {
+		type: "internal",
+		source: info.src,
+		destination: info.dest,
+		value: info.value.coins,
+		body: message.body,
+		...message.init ? { init: message.init } : {},
+		createdAt: info.createdAt,
+		createdLt: info.createdLt
+	};
+	if (info.type === "external-in") return {
+		type: "external-in",
+		destination: info.dest,
+		body: message.body,
+		...message.init ? { init: message.init } : {}
+	};
+	return {
+		type: "external-out",
+		source: info.src,
+		body: message.body,
+		createdAt: info.createdAt,
+		createdLt: info.createdLt
+	};
+}
+function buildTonApiResult(trace) {
+	const transactions = flattenTonApiTrace(trace).map(normalizeTonApiTransaction);
+	const cost = transactions.reduce((total, transaction) => ({
+		totalFees: total.totalFees + transaction.totalFees,
+		storageFees: total.storageFees + transaction.storageFees,
+		gasFees: total.gasFees + transaction.gasFees,
+		forwardFees: total.forwardFees + transaction.forwardFees,
+		actionFees: total.actionFees + transaction.actionFees,
+		gasUsed: total.gasUsed + transaction.gasUsed,
+		vmSteps: total.vmSteps + transaction.vmSteps
+	}), zeroCost());
+	return {
+		source: "tonapi",
+		success: transactions.length > 0 && transactions.every((transaction) => transaction.success),
+		transactions,
+		cost,
+		...transactions.length === 0 ? { error: { message: "TonAPI returned no transactions" } } : {},
+		...transactions[0] ? { rootTransactionHash: transactions[0].hash } : {},
+		speculative: true
+	};
+}
+function flattenTonApiTrace(root) {
+	const flattened = [];
+	const pending = [{ trace: root }];
+	const seen = /* @__PURE__ */ new Set();
+	while (pending.length > 0) {
+		const item = pending.pop();
+		if (!item) continue;
+		invariant(!seen.has(item.trace), "PROVIDER_ERROR", "TonAPI returned a recursive trace");
+		seen.add(item.trace);
+		invariant(seen.size <= 1e5, "PROVIDER_ERROR", "TonAPI trace exceeds the transaction limit");
+		flattened.push(item);
+		const children = item.trace.children ?? [];
+		for (let index = children.length - 1; index >= 0; index -= 1) {
+			const child = children[index];
+			if (child) pending.push({
+				trace: child,
+				parentHash: item.trace.transaction.hash
+			});
+		}
+	}
+	return flattened;
+}
+function normalizeTonApiTransaction(item) {
+	const transaction = item.trace.transaction;
+	const compute = transaction.computePhase;
+	const action = transaction.actionPhase;
+	const storage = transaction.storagePhase;
+	return {
+		hash: transaction.hash,
+		logicalTime: transaction.lt,
+		accountId: transaction.account.address.hash.toString("hex").padStart(64, "0"),
+		timestamp: transaction.utime,
+		success: transaction.success,
+		oldStatus: transaction.origStatus,
+		endStatus: transaction.endStatus,
+		totalFees: transaction.totalFees,
+		storageFees: storage?.feesCollected ?? 0n,
+		gasFees: compute?.gasFees ?? 0n,
+		forwardFees: action?.fwdFees ?? 0n,
+		actionFees: action ? action.totalFees - action.fwdFees : 0n,
+		gasUsed: compute?.gasUsed ?? 0n,
+		vmSteps: compute?.vmSteps ?? 0,
+		...compute?.exitCode !== void 0 ? { exitCode: compute.exitCode } : {},
+		...action ? { actionSuccess: action.success } : {},
+		...transaction.inMsg ? { input: summarizeTonApiMessage(transaction.inMsg) } : {},
+		outputs: transaction.outMsgs.map(summarizeTonApiMessage),
+		...item.parentHash ? { parentHash: item.parentHash } : {},
+		childHashes: (item.trace.children ?? []).map((child) => child.transaction.hash),
+		blockchainLogs: "",
+		vmLogs: "",
+		debugLogs: ""
+	};
+}
+function summarizeTonApiMessage(message) {
+	if (!message) return { type: "external-in" };
+	return {
+		type: message.msgType === "int_msg" ? "internal" : message.msgType === "ext_out_msg" ? "external-out" : "external-in",
+		...message.source ? { source: message.source.address } : {},
+		...message.destination ? { destination: message.destination.address } : {},
+		...message.value === void 0 ? {} : { value: message.value },
+		...message.rawBody ? { body: message.rawBody } : {},
+		...message.createdAt === void 0 ? {} : { createdAt: message.createdAt },
+		...message.createdLt === void 0 ? {} : { createdLt: message.createdLt }
+	};
+}
+function zeroCost() {
+	return {
+		totalFees: 0n,
+		storageFees: 0n,
+		gasFees: 0n,
+		forwardFees: 0n,
+		actionFees: 0n,
+		gasUsed: 0n,
+		vmSteps: 0
+	};
+}
+function buildFailureResult(source, cause, speculative) {
+	const error = cause instanceof Error ? cause : new Error(String(cause));
+	const exitCode = typeof cause === "object" && cause !== null && "exitCode" in cause && typeof cause.exitCode === "number" ? cause.exitCode : void 0;
+	return {
+		source,
+		success: false,
+		transactions: [],
+		cost: zeroCost(),
+		error: {
+			message: error.message,
+			...exitCode !== void 0 ? { exitCode } : {}
+		},
+		speculative
+	};
+}
+const blockchainLocks = /* @__PURE__ */ new WeakMap();
+async function withBlockchainLock(blockchain, operation) {
+	const previous = blockchainLocks.get(blockchain) ?? Promise.resolve();
+	let release = () => {};
+	const turn = new Promise((resolve) => {
+		release = resolve;
+	});
+	blockchainLocks.set(blockchain, turn);
+	await previous;
+	try {
+		return await operation();
+	} finally {
+		release();
+		if (blockchainLocks.get(blockchain) === turn) blockchainLocks.delete(blockchain);
+	}
+}
+//#endregion
+export { createTonApiSimulationFallback, createTonClient4SandboxSimulation, createTonSandboxSimulation, createTonSimulationWithFallback, messageToCell };

package/dist/transactions/index.d.mts

@@ -0,0 +1,33 @@
+import { TonNetwork } from "../core/network.mjs";
+import { TonAddress } from "../core/address.mjs";
+import { Address, Cell } from "@ton/core";
+import { SendTransactionRequestWithMessages } from "@tonconnect/sdk";
+//#region src/transactions/index.d.ts
+export interface TonTransactionMessage {
+  readonly to: string | Address | TonAddress;
+  readonly value: bigint;
+  readonly body?: Cell;
+  readonly stateInit?: Cell;
+  readonly bounce?: boolean;
+}
+export interface TransactionIntent {
+  readonly kind: "ton-transaction";
+  readonly id: string;
+  readonly validUntil: number;
+  readonly messages: readonly TonTransactionMessage[];
+  readonly metadata?: Readonly<Record<string, string>>;
+}
+export type TonConnectMessage = SendTransactionRequestWithMessages["messages"][number];
+export type TonConnectTransaction = Pick<SendTransactionRequestWithMessages, "validUntil" | "messages">;
+export declare function createTransactionIntent(input: {
+  id: string;
+  validUntil: number;
+  messages: readonly TonTransactionMessage[];
+  metadata?: Readonly<Record<string, string>>;
+}): TransactionIntent;
+export declare function validateTransactionIntent(input: Pick<TransactionIntent, "id" | "validUntil" | "messages">, now?: number): void;
+export declare function toTonConnectTransaction(intent: TransactionIntent, options: {
+  network: TonNetwork;
+  now?: number;
+}): TonConnectTransaction;
+//#endregion

package/dist/transactions/index.mjs

@@ -0,0 +1,51 @@
+import { invariant } from "../core/errors.mjs";
+import { parseTonAddress, toFriendlyAddress } from "../core/address.mjs";
+import { MAX_TON_COINS } from "../core/amount.mjs";
+import { bytesToBase64 } from "../core/bytes.mjs";
+import { Cell } from "@ton/core";
+//#region src/transactions/index.ts
+function createTransactionIntent(input) {
+	validateTransactionIntent(input);
+	return Object.freeze({
+		kind: "ton-transaction",
+		id: input.id,
+		validUntil: input.validUntil,
+		messages: Object.freeze(input.messages.map((message) => Object.freeze({ ...message }))),
+		...input.metadata ? { metadata: Object.freeze({ ...input.metadata }) } : {}
+	});
+}
+function validateTransactionIntent(input, now = Math.floor(Date.now() / 1e3)) {
+	invariant(typeof input.id === "string" && input.id.trim().length > 0, "INVALID_TRANSACTION", "Transaction intent id is required");
+	invariant(Number.isSafeInteger(now), "INVALID_TRANSACTION", "Current time must be a safe integer");
+	invariant(Number.isSafeInteger(input.validUntil), "INVALID_TRANSACTION", "validUntil must be a safe integer");
+	invariant(input.validUntil > now, "INVALID_TRANSACTION", "Transaction intent has expired");
+	invariant(input.validUntil <= now + 3600, "INVALID_TRANSACTION", "Transaction intent expires too far in the future");
+	invariant(Array.isArray(input.messages) && input.messages.length > 0 && input.messages.length <= 4, "INVALID_TRANSACTION", "A transaction must contain between one and four messages");
+	for (const message of input.messages) {
+		invariant(typeof message === "object" && message !== null, "INVALID_TRANSACTION", "Transaction message must be an object");
+		invariant(typeof message.value === "bigint" && message.value >= 0n, "INVALID_TRANSACTION", "Message value must be a non-negative bigint");
+		invariant(message.value <= MAX_TON_COINS, "INVALID_TRANSACTION", "Message value is out of range");
+		parseTonAddress(message.to);
+		invariant(message.body === void 0 || message.body instanceof Cell, "INVALID_TRANSACTION", "Message body must be a TON Cell");
+		invariant(message.stateInit === void 0 || message.stateInit instanceof Cell, "INVALID_TRANSACTION", "Message state init must be a TON Cell");
+		invariant(message.bounce === void 0 || typeof message.bounce === "boolean", "INVALID_TRANSACTION", "Message bounce flag must be a boolean");
+	}
+}
+function toTonConnectTransaction(intent, options) {
+	invariant(options.network === "mainnet" || options.network === "testnet", "INVALID_NETWORK", "Unsupported TON network");
+	validateTransactionIntent(intent, options.now);
+	return {
+		validUntil: intent.validUntil,
+		messages: intent.messages.map((message) => ({
+			address: toFriendlyAddress(message.to, {
+				network: options.network,
+				bounceable: message.bounce ?? true
+			}),
+			amount: message.value.toString(),
+			...message.body ? { payload: bytesToBase64(message.body.toBoc()) } : {},
+			...message.stateInit ? { stateInit: bytesToBase64(message.stateInit.toBoc()) } : {}
+		}))
+	};
+}
+//#endregion
+export { createTransactionIntent, toTonConnectTransaction, validateTransactionIntent };