@ton/mcp 0.1.12 → 0.1.13

package/dist/cli.js

@@ -27975,9 +27975,12 @@ function isFriendlyTonAddress(address) {
 *
 */
 function asHex(data) {
-	if (!/^0x[0-9a-fA-F]+$/.test(data) || data.length % 2 !== 0) throw new Error("Not a valid hex");
+	if (!isHex(data)) throw new Error("Not a valid hex");
 	return data;
 }
+function isHex(data) {
+	return /^0x[0-9a-fA-F]+$/.test(data) && data.length % 2 === 0;
+}
 
 //#endregion
 //#region ../walletkit/dist/esm/errors/codes.js
@@ -29485,7 +29488,7 @@ function delay(ms) {
 * LICENSE file in the root directory of this source tree.
 *
 */
-async function CallForSuccess(toCall, attempts = 20, delayMs = 100) {
+async function CallForSuccess(toCall, attempts = 20, delayMs = 100, shouldRetry) {
 	if (typeof toCall !== "function") throw new Error("unknown input");
 	let i = 0;
 	let lastError;
@@ -29493,6 +29496,7 @@ async function CallForSuccess(toCall, attempts = 20, delayMs = 100) {
 		return await toCall();
 	} catch (err) {
 		lastError = err;
+		if (shouldRetry && !shouldRetry(err)) throw err;
 		i++;
 		await delay(delayMs);
 	}
@@ -29781,6 +29785,16 @@ function isValidEventMethod(method) {
 	].includes(method);
 }
 
+//#endregion
+//#region ../walletkit/dist/esm/validation/address.js
+/**
+* Copyright (c) TonTech.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+
 //#endregion
 //#region ../walletkit/dist/esm/validation/transaction.js
 /**
@@ -70152,13 +70166,11 @@ function getDeviceInfoWithDefaults(options) {
 */
 function getDeviceInfoForWallet(walletAdapter, deviceInfoOptions) {
 	const baseDeviceInfo = getDeviceInfoWithDefaults(deviceInfoOptions);
-	if (walletAdapter?.getSupportedFeatures) {
-		const adapterFeatures = walletAdapter.getSupportedFeatures();
-		return addLegacySendTransactionFeature({
-			...baseDeviceInfo,
-			features: adapterFeatures
-		});
-	}
+	const walletSupportedFeatures = walletAdapter?.getSupportedFeatures();
+	if (walletSupportedFeatures) return addLegacySendTransactionFeature({
+		...baseDeviceInfo,
+		features: walletSupportedFeatures
+	});
 	return baseDeviceInfo;
 }
 function addLegacySendTransactionFeature(options) {
@@ -71321,6 +71333,7 @@ var AssetType;
 const Network = {
 	mainnet: () => ({ chainId: "-239" }),
 	testnet: () => ({ chainId: "-3" }),
+	tetra: () => ({ chainId: "662387" }),
 	custom: (chainId) => ({ chainId })
 };
 
@@ -71650,15 +71663,12 @@ var TransactionHandler = class extends BasicHandler {
 	*/
 	validateNetwork(network, wallet) {
 		let errors = [];
-		if (typeof network === "string") if (network === "-3" || network === "-239") {
-			const chain = network === "-3" ? CHAIN.TESTNET : CHAIN.MAINNET;
-			if (chain !== wallet.getNetwork().chainId) errors.push("Invalid network not equal to wallet network");
-			else return {
-				result: chain,
-				isValid: errors.length === 0,
-				errors
-			};
-		} else errors.push("Invalid network not a valid network");
+		if (typeof network === "string") if (network !== wallet.getNetwork().chainId) errors.push("Invalid network not equal to wallet network");
+		else return {
+			result: network,
+			isValid: errors.length === 0,
+			errors
+		};
 		else errors.push("Invalid network not a string");
 		return {
 			result: void 0,
@@ -72859,25 +72869,21 @@ function parseDomain(url) {
 	}
 }
 function toTonConnectSignDataPayload(payload) {
-	let network;
-	if (payload.network?.chainId === CHAIN.MAINNET) network = CHAIN.MAINNET;
-	else if (payload.network?.chainId === CHAIN.TESTNET) network = CHAIN.TESTNET;
-	else network = void 0;
 	if (payload.data.type === "text") return {
-		network,
+		network: payload.network?.chainId,
 		from: payload.fromAddress,
 		type: "text",
 		text: payload.data.value.content
 	};
 	else if (payload.data.type === "cell") return {
-		network,
+		network: payload.network?.chainId,
 		from: payload.fromAddress,
 		type: "cell",
 		schema: payload.data.value.schema,
 		cell: payload.data.value.content
 	};
 	else return {
-		network,
+		network: payload.network?.chainId,
 		from: payload.fromAddress,
 		type: "binary",
 		bytes: payload.data.value.content
@@ -74289,7 +74295,19 @@ function DefaultSignature(data, privateKey) {
 	if (fullKey.length === 32) fullKey = (0, import_dist$2.keyPairFromSeed)(Buffer.from(fullKey)).secretKey;
 	return Uint8ArrayToHex((0, import_dist$2.sign)(Buffer.from(Uint8Array.from(data)), Buffer.from(fullKey)));
 }
-function createWalletSigner(privateKey) {
+function DefaultDomainSignature(data, privateKey, domain) {
+	let fullKey = privateKey;
+	if (fullKey.length === 32) fullKey = (0, import_dist$2.keyPairFromSeed)(Buffer.from(fullKey)).secretKey;
+	return Uint8ArrayToHex((0, import_dist$3.domainSign)({
+		data: Buffer.from(Uint8Array.from(data)),
+		secretKey: Buffer.from(fullKey),
+		domain
+	}));
+}
+function createWalletSigner(privateKey, domain) {
+	if (domain) return async (data) => {
+		return DefaultDomainSignature(Uint8Array.from(data), privateKey, domain);
+	};
 	return async (data) => {
 		return DefaultSignature(Uint8Array.from(data), privateKey);
 	};
@@ -74318,10 +74336,10 @@ var Signer = class {
 	* @param options - Optional configuration for mnemonic type
 	* @returns Signer function with publicKey property
 	*/
-	static async fromMnemonic(mnemonic, options) {
+	static async fromMnemonic(mnemonic, options, domain) {
 		const keyPair = await MnemonicToKeyPair(mnemonic, options?.type ?? "ton");
 		return {
-			sign: createWalletSigner(keyPair.secretKey),
+			sign: createWalletSigner(keyPair.secretKey, domain),
 			publicKey: Uint8ArrayToHex(keyPair.publicKey)
 		};
 	}
@@ -74330,11 +74348,11 @@ var Signer = class {
 	* @param privateKey - Private key as hex string or Uint8Array
 	* @returns Signer function with publicKey property
 	*/
-	static async fromPrivateKey(privateKey) {
+	static async fromPrivateKey(privateKey, domain) {
 		const privateKeyBytes = typeof privateKey === "string" ? Uint8Array.from(Buffer.from(privateKey.replace("0x", ""), "hex")) : privateKey;
 		const keyPair = (0, import_dist$2.keyPairFromSeed)(Buffer.from(privateKeyBytes));
 		return {
-			sign: createWalletSigner(keyPair.secretKey),
+			sign: createWalletSigner(keyPair.secretKey, domain),
 			publicKey: Uint8ArrayToHex(keyPair.publicKey)
 		};
 	}
@@ -74528,6 +74546,238 @@ async function getNftFromClient(client, address) {
 	return result.nfts.length > 0 ? result.nfts[0] : null;
 }
 
+//#endregion
+//#region ../walletkit/dist/esm/utils/toncenter/getTxOpcode.js
+/**
+* Copyright (c) TonTech.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+/**
+* Returns the resolved opcode for a transaction.
+*/
+const getTxOpcode = (tx) => {
+	const msg = tx.in_msg;
+	if (!msg) return null;
+	return msg.opcode ?? null;
+};
+
+//#endregion
+//#region ../walletkit/dist/esm/utils/toncenter/createTraceTypeDetector.js
+/**
+* Copyright (c) TonTech.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+/**
+* Generic factory function to create a trace type detector.
+* Returns true if the trace contains at least one transaction with ANY of the trigger opcodes.
+*/
+const createTraceTypeDetector = (triggerOpcodes) => {
+	return (transactions) => {
+		for (const tx of Object.values(transactions)) {
+			const opcode = getTxOpcode(tx);
+			if (opcode && triggerOpcodes.has(opcode)) return true;
+		}
+		return false;
+	};
+};
+
+//#endregion
+//#region ../walletkit/dist/esm/utils/toncenter/isTransactionFailed.js
+/**
+* Copyright (c) TonTech.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+/**
+* Checks if a single transaction failed.
+* A transaction is considered failed if it was aborted, or if its compute
+* or action phases failed to execute successfully (including skipped actions).
+*/
+const isTransactionFailed = (tx) => {
+	const desc = tx.description;
+	if (!desc) return false;
+	if (desc.aborted) return true;
+	if (desc.compute_ph?.success === false) return true;
+	if (desc.action?.success === false) return true;
+	if (desc.action && desc.action.skipped_actions > 0) return true;
+	return false;
+};
+
+//#endregion
+//#region ../walletkit/dist/esm/utils/toncenter/createFailureDetector.js
+/**
+* Copyright (c) TonTech.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+/**
+* Generic factory function to create a failure detector.
+* Checks if ANY transaction in the trace has aborted, EXCEPT those
+* explicitly listed in the `nonCriticalOpcodes` set.
+*
+* If a transaction opcode is in `nonCriticalOpcodes`, its failure is ignored.
+* If a transaction has an unknown opcode or an opcode not in the set, and it fails,
+* the entire trace is considered failed.
+*/
+const createFailureDetector = (nonCriticalOpcodes) => {
+	return (transactions) => {
+		for (const tx of Object.values(transactions)) if (isTransactionFailed(tx)) {
+			const opcode = getTxOpcode(tx);
+			if (opcode && nonCriticalOpcodes.has(opcode)) continue;
+			return true;
+		}
+		return false;
+	};
+};
+
+//#endregion
+//#region ../walletkit/dist/esm/utils/toncenter/isFailedTrace.js
+/**
+* Copyright (c) TonTech.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+const KNOWN_TRACE_TYPES = [{
+	triggerOpcodes: new Set(["0x0f8a7ea5"]),
+	safeToSkipOpcodes: new Set(["0x7362d09c", "0xd53276db"])
+}];
+/**
+* Determines if a transaction trace has failed.
+*
+* In TON, a single transaction triggers a tree of internal messages.
+* Some messages can fail (abort) or be skipped without affecting the main action.
+*
+* This function applies action-specific logic:
+* - Checks known trace types (like Jetton Transfers) against their specific allowed failures.
+* - **Unknown types**: checks if ANY transaction in the trace has failed.
+*
+* @param tx - The trace response from toncenter
+* @returns `true` if the trace is considered failed
+*/
+const isFailedTrace = (tx) => {
+	const trace = tx.traces?.[0];
+	if (!trace) return false;
+	const transactions = trace.transactions ?? {};
+	if (Object.keys(transactions).length === 0) return false;
+	for (const config of KNOWN_TRACE_TYPES) if (createTraceTypeDetector(config.triggerOpcodes)(transactions)) return createFailureDetector(config.safeToSkipOpcodes)(transactions);
+	return createFailureDetector(/* @__PURE__ */ new Set())(transactions);
+};
+
+//#endregion
+//#region ../walletkit/dist/esm/utils/toncenter/parseTraceResponse.js
+/**
+* Copyright (c) TonTech.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+/**
+* Helper to parse ToncenterTracesResponse into TransactionStatusResponse.
+* Returns null if no traces are found.
+*/
+const parseTraceResponse = (response) => {
+	if (!response.traces || response.traces.length === 0) return null;
+	const traceInfo = response.traces[0].trace_info;
+	const isEffectivelyCompleted = traceInfo.trace_state === "complete" || traceInfo.trace_state === "pending" && traceInfo.pending_messages === 0;
+	let status = "pending";
+	if (traceInfo.pending_messages === 0) {
+		if (isFailedTrace(response)) status = "failed";
+		else if (isEffectivelyCompleted) status = "completed";
+	}
+	return {
+		status,
+		totalMessages: traceInfo.messages,
+		pendingMessages: traceInfo.pending_messages,
+		onchainMessages: traceInfo.messages - traceInfo.pending_messages
+	};
+};
+
+//#endregion
+//#region ../walletkit/dist/esm/utils/getNormalizedExtMessageHash.js
+/**
+* Copyright (c) TonTech.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+/**
+* Generates a normalized hash of an "external-in" message for comparison.
+*
+* This function ensures consistent hashing of external-in messages by following [TEP-467].
+* See documentation: https://docs.ton.org/ecosystem/ton-connect/message-lookup#transaction-lookup-using-external-message-from-ton-connect
+*
+* @param params - An object containing the built BOC as a base64 string.
+* @returns An object containing the hash (Hex string) and the boc (Base64 string) of the normalized message.
+* @throws if the message type is not `external-in`.
+*/
+function getNormalizedExtMessageHash(boc) {
+	const message = (0, import_dist$3.loadMessage)(import_dist$3.Cell.fromBase64(boc).beginParse());
+	if (message.info.type !== "external-in") throw new Error(`Message must be "external-in", got ${message.info.type}`);
+	const info = {
+		...message.info,
+		src: void 0,
+		importFee: 0n
+	};
+	const normalizedMessage = {
+		...message,
+		init: null,
+		info
+	};
+	const normalizedCell = (0, import_dist$3.beginCell)().store((0, import_dist$3.storeMessage)(normalizedMessage, { forceRef: true })).endCell();
+	return {
+		hash: `0x${normalizedCell.hash().toString("hex")}`,
+		boc: normalizedCell.toBoc().toString("base64")
+	};
+}
+
+//#endregion
+//#region ../walletkit/dist/esm/utils/toncenter/getTransactionStatus.js
+/**
+* Copyright (c) TonTech.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+/**
+* Get the status of a transaction by its BOC.
+*
+* In TON, a single external message triggers a tree of internal messages.
+* The transaction is "complete" only when the entire trace finishes.
+*/
+async function getTransactionStatus(client, params) {
+	const hashToSearch = params.boc ? getNormalizedExtMessageHash(params.boc).hash : params.normalizedHash;
+	if (!hashToSearch) throw new Error("Either boc or normalizedHash must be provided");
+	try {
+		const pendingStatus = parseTraceResponse(await client.getPendingTrace({ externalMessageHash: [hashToSearch] }));
+		if (pendingStatus) return pendingStatus;
+	} catch (_e) {}
+	try {
+		const completedStatus = parseTraceResponse(await client.getTrace({ traceId: [hashToSearch] }));
+		if (completedStatus) return completedStatus;
+	} catch (_e) {}
+	return {
+		status: "unknown",
+		totalMessages: 0,
+		pendingMessages: 0,
+		onchainMessages: 0
+	};
+}
+
 //#endregion
 //#region ../walletkit/dist/esm/utils/messageBuilders.js
 /**
@@ -74710,7 +74960,12 @@ var WalletTonClass = class {
 		try {
 			const boc = await this.getSignedSendTransaction(request);
 			await CallForSuccess(() => this.getClient().sendBoc(boc));
-			return { boc };
+			const { hash: normalizedHash, boc: normalizedBoc } = getNormalizedExtMessageHash(boc);
+			return {
+				boc,
+				normalizedBoc,
+				normalizedHash
+			};
 		} catch (error) {
 			log$13.error("Failed to send transaction", { error });
 			if (error instanceof WalletKitError) throw error;
@@ -77424,8 +77679,8 @@ var ApiClientToncenter = class {
 	disableNetworkSend;
 	constructor(config = {}) {
 		this.network = config.network;
-		const dnsResolver = this.network?.chainId === CHAIN.MAINNET ? ROOT_DNS_RESOLVER_MAINNET : ROOT_DNS_RESOLVER_TESTNET;
-		const defaultEndpoint = this.network?.chainId === CHAIN.MAINNET ? "https://toncenter.com" : "https://testnet.toncenter.com";
+		const dnsResolver = this.network?.chainId === Network.mainnet().chainId ? ROOT_DNS_RESOLVER_MAINNET : ROOT_DNS_RESOLVER_TESTNET;
+		const defaultEndpoint = this.network?.chainId === Network.mainnet().chainId ? "https://toncenter.com" : "https://testnet.toncenter.com";
 		this.dnsResolver = config.dnsResolver ?? dnsResolver;
 		this.endpoint = config.endpoint ?? defaultEndpoint;
 		this.apiKey = config.apiKey;
@@ -77461,7 +77716,7 @@ var ApiClientToncenter = class {
 	}
 	async sendBoc(boc) {
 		if (this.disableNetworkSend) return "";
-		return Base64ToBigInt((await this.postJson("/api/v3/message", { boc })).message_hash_norm).toString(16);
+		return `0x${Base64ToBigInt((await this.postJson("/api/v3/message", { boc })).message_hash_norm).toString(16)}`;
 	}
 	async runGetMethod(address, method, stack = [], seqno) {
 		const props = {
@@ -77592,31 +77847,31 @@ var ApiClientToncenter = class {
 		}));
 	}
 	async getTrace(request) {
-		const traceId = padBase64(Base64Normalize((request.traceId ? request.traceId[0] : void 0) || "").replace(/=/g, ""));
-		try {
-			const response = await CallForSuccess(() => this.getJson("/api/v3/traces", { tx_hash: traceId }));
-			if (response.traces.length > 0) return response;
-		} catch (error) {
-			log$7.error("Error fetching trace", { error });
-		}
-		try {
-			const response = await CallForSuccess(() => this.getJson("/api/v3/traces", { trace_id: traceId }));
-			if (response.traces.length > 0) return response;
-		} catch (error) {
-			log$7.error("Error fetching trace", { error });
-		}
-		try {
-			const response = await CallForSuccess(() => this.getJson("/api/v3/traces", { msg_hash: traceId }));
-			if (response.traces.length > 0) return response;
-		} catch (error) {
-			log$7.error("Error fetching pending trace", { error });
-		}
+		const traceIdStr = (request.traceId ? request.traceId[0] : void 0) || "";
+		const traceId = isHex(traceIdStr) ? traceIdStr : padBase64(Base64Normalize(traceIdStr).replace(/=/g, ""));
+		const tryGetTrace = async (field) => {
+			const response = await CallForSuccess(() => this.getJson("/api/v3/traces", { [field]: traceId }), void 0, void 0, (err) => err instanceof TonClientError ? err.status !== 422 : true);
+			if (response?.traces?.length > 0) return response;
+			throw new Error(`No traces found for ${field}`);
+		};
+		const results = await Promise.allSettled([
+			tryGetTrace("tx_hash"),
+			tryGetTrace("trace_id"),
+			tryGetTrace("msg_hash")
+		]);
+		const fulfilledResult = results.find((result) => result.status === "fulfilled");
+		if (fulfilledResult) return fulfilledResult.value;
+		results.forEach((result) => {
+			if (result.status === "rejected") log$7.error("Error fetching trace", { error: result.reason });
+		});
 		throw new Error("Failed to fetch trace");
 	}
 	async getPendingTrace(request) {
 		try {
-			const response = await CallForSuccess(() => this.getJson("/api/v3/pendingTraces", { ext_msg_hash: request.externalMessageHash }));
-			if (response.traces.length > 0) return response;
+			const response = await CallForSuccess(() => {
+				return this.getJson("/api/v3/pendingTraces", { ext_msg_hash: request.externalMessageHash });
+			}, void 0, void 0, (err) => err instanceof TonClientError ? err.status !== 422 : true);
+			if (response?.traces?.length > 0) return response;
 		} catch (error) {
 			log$7.error("Error fetching pending trace", { error });
 		}
@@ -77755,7 +78010,7 @@ const log$6 = globalLogger.createChild("NetworkManager");
 /**
 * Manages multiple API clients for different networks
 *
-* Each network (identified by CHAIN) has its own ApiClient instance.
+* Each network has its own ApiClient instance.
 * At least one network must be configured.
 */
 var KitNetworkManager = class {
@@ -77786,7 +78041,10 @@ var KitNetworkManager = class {
 	*/
 	createClient(network, apiClientConfig, options) {
 		if (this.isApiClient(apiClientConfig)) return apiClientConfig;
-		const defaultEndpoint = network.chainId === CHAIN.MAINNET ? "https://toncenter.com" : "https://testnet.toncenter.com";
+		let defaultEndpoint;
+		if (network.chainId == Network.mainnet().chainId) defaultEndpoint = "https://toncenter.com";
+		else if (network.chainId == Network.tetra().chainId) defaultEndpoint = "https://tetra.tonapi.io";
+		else defaultEndpoint = "https://testnet.toncenter.com";
 		return new ApiClientToncenter({
 			endpoint: apiClientConfig?.url || defaultEndpoint,
 			apiKey: apiClientConfig?.key,
@@ -77802,7 +78060,7 @@ var KitNetworkManager = class {
 	}
 	/**
 	* Get API client for a specific network
-	* @param chainId - The chain ID (CHAIN.MAINNET or CHAIN.TESTNET)
+	* @param chainId - The chain ID
 	* @returns The API client for the specified network
 	* @throws WalletKitError if no client is configured for the network
 	*/
@@ -77920,7 +78178,7 @@ var TonWalletKit = class {
 					items: [{
 						name: "ton_addr",
 						address: import_dist$3.Address.parse(walletAddress).toRawString(),
-						network: wallet.getNetwork().chainId === CHAIN.MAINNET ? CHAIN.MAINNET : CHAIN.TESTNET,
+						network: wallet.getNetwork().chainId,
 						walletStateInit,
 						publicKey
 					}]
@@ -111338,7 +111596,7 @@ var McpWalletService = class McpWalletService {
 	* Get wallet network
 	*/
 	getNetwork() {
-		return this.wallet.getNetwork().chainId === Network.mainnet().chainId ? "mainnet" : "testnet";
+		return this.wallet.getNetwork().chainId === Network.mainnet().chainId ? "mainnet" : Network.tetra().chainId ? "tetra" : "testnet";
 	}
 	/**
 	* Initialize TonWalletKit (for swap operations)
@@ -111454,10 +111712,11 @@ var McpWalletService = class McpWalletService {
 				transferAmount: amountNano,
 				comment
 			});
-			await this.wallet.sendTransaction(tx);
+			const response = await this.wallet.sendTransaction(tx);
 			return {
 				success: true,
-				message: `Successfully sent ${amountNano} nanoTON to ${toAddress}`
+				message: `Successfully sent ${amountNano} nanoTON to ${toAddress}`,
+				normalizedHash: response.normalizedHash
 			};
 		} catch (error) {
 			return {
@@ -111477,10 +111736,11 @@ var McpWalletService = class McpWalletService {
 				transferAmount: amountRaw,
 				comment
 			});
-			await this.wallet.sendTransaction(tx);
+			const response = await this.wallet.sendTransaction(tx);
 			return {
 				success: true,
-				message: `Successfully sent jettons to ${toAddress}`
+				message: `Successfully sent jettons to ${toAddress}`,
+				normalizedHash: response.normalizedHash
 			};
 		} catch (error) {
 			return {
@@ -111494,10 +111754,11 @@ var McpWalletService = class McpWalletService {
 	*/
 	async sendRawTransaction(request) {
 		try {
-			await this.wallet.sendTransaction(request);
+			const tx = await this.wallet.sendTransaction(request);
 			return {
 				success: true,
-				message: `Successfully sent transaction with ${request.messages.length} message(s)`
+				message: `Successfully sent transaction with ${request.messages.length} message(s)`,
+				normalizedHash: tx.normalizedHash
 			};
 		} catch (error) {
 			return {
@@ -111507,6 +111768,15 @@ var McpWalletService = class McpWalletService {
 		}
 	}
 	/**
+	* Get the status of a transaction by its normalized hash.
+	*
+	* In TON, a single external message triggers a tree of internal messages.
+	* The transaction is "complete" only when the entire trace finishes.
+	*/
+	async getTransactionStatus(normalizedHash) {
+		return getTransactionStatus(this.wallet.getClient(), { normalizedHash });
+	}
+	/**
 	* Get swap quote with transaction params ready to execute
 	* @param fromToken Token to swap from ("TON" or jetton address)
 	* @param toToken Token to swap to ("TON" or jetton address)
@@ -111620,10 +111890,11 @@ var McpWalletService = class McpWalletService {
 				recipientAddress: toAddress,
 				comment
 			});
-			await this.wallet.sendTransaction(tx);
+			const response = await this.wallet.sendTransaction(tx);
 			return {
 				success: true,
-				message: `Successfully sent NFT ${nftAddress} to ${toAddress}`
+				message: `Successfully sent NFT ${nftAddress} to ${toAddress}`,
+				normalizedHash: response.normalizedHash
 			};
 		} catch (error) {
 			return {
@@ -115432,7 +115703,7 @@ const sendRawTransactionSchema = objectType({
 function createMcpTransferTools(service) {
 	return {
 		send_ton: {
-			description: "Send TON from the wallet to an address. Amount is in TON (e.g., \"1.5\" means 1.5 TON).",
+			description: "Send TON from the wallet to an address. Amount is in TON (e.g., \"1.5\" means 1.5 TON). Returns normalizedHash. Default flow: poll get_transaction_status until completed or failed; user can skip.",
 			inputSchema: sendTonSchema,
 			handler: async (args) => {
 				const rawAmount = toRawAmount(args.amount, TON_DECIMALS);
@@ -115455,14 +115726,15 @@ function createMcpTransferTools(service) {
 						details: {
 							to: args.toAddress,
 							amount: `${args.amount} TON`,
-							comment: args.comment || null
+							comment: args.comment || null,
+							normalizedHash: result.normalizedHash
 						}
 					}, null, 2)
 				}] };
 			}
 		},
 		send_jetton: {
-			description: "Send Jettons (tokens) from the wallet to an address. Amount is in human-readable format.",
+			description: "Send Jettons (tokens) from the wallet to an address. Amount is in human-readable format. Returns normalizedHash. Default flow: poll get_transaction_status until completed or failed; user can skip.",
 			inputSchema: sendJettonSchema,
 			handler: async (args) => {
 				let decimals;
@@ -115516,14 +115788,15 @@ function createMcpTransferTools(service) {
 							to: args.toAddress,
 							jettonAddress: args.jettonAddress,
 							amount: `${args.amount} ${symbol || "tokens"}`,
-							comment: args.comment || null
+							comment: args.comment || null,
+							normalizedHash: result.normalizedHash
 						}
 					}, null, 2)
 				}] };
 			}
 		},
 		send_raw_transaction: {
-			description: "Send a raw transaction with full control over messages. Amounts are in nanotons. Supports multiple messages in a single transaction.",
+			description: "Send a raw transaction with full control over messages. Amounts are in nanotons. Supports multiple messages. Returns normalizedHash. Default flow: poll get_transaction_status until completed or failed; user can skip.",
 			inputSchema: sendRawTransactionSchema,
 			handler: async (args) => {
 				const result = await service.sendRawTransaction({
@@ -115551,7 +115824,8 @@ function createMcpTransferTools(service) {
 							messages: args.messages.map((m) => ({
 								to: m.address,
 								amount: `${m.amount} nanoTON`
-							}))
+							})),
+							normalizedHash: result.normalizedHash
 						}
 					}, null, 2)
 				}] };
@@ -115781,7 +116055,7 @@ function createMcpNftTools(service) {
 			}
 		},
 		send_nft: {
-			description: "Transfer an NFT from the wallet to another address.",
+			description: "Transfer an NFT from the wallet to another address. Returns normalizedHash. Default flow: poll get_transaction_status until completed or failed; user can skip.",
 			inputSchema: sendNftSchema,
 			handler: async (args) => {
 				try {
@@ -115793,7 +116067,8 @@ function createMcpNftTools(service) {
 								success: result.success,
 								message: result.message,
 								nftAddress: args.nftAddress,
-								recipient: args.toAddress
+								recipient: args.toAddress,
+								normalizedHash: result.normalizedHash
 							}, null, 2)
 						}],
 						isError: !result.success
@@ -115815,6 +116090,43 @@ function createMcpNftTools(service) {
 	};
 }
 
+//#endregion
+//#region src/tools/transaction-tools.ts
+/**
+* Copyright (c) TonTech.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+const getTransactionStatusSchema = objectType({ normalizedHash: stringType().min(1).describe("Normalized hash of the external-in transaction (Hex string)") });
+function createMcpTransactionTools(service) {
+	return { get_transaction_status: {
+		description: "Get the status of a transaction by its normalized hash (pending, completed, or failed). Default flow after any send: poll until completed or failed; user can specify whether to check.",
+		inputSchema: getTransactionStatusSchema,
+		handler: async (args) => {
+			try {
+				const result = await service.getTransactionStatus(args.normalizedHash);
+				return { content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}] };
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({
+							success: false,
+							error: `Failed to get transaction status: ${error instanceof Error ? error.message : "Unknown error"}`
+						})
+					}],
+					isError: true
+				};
+			}
+		}
+	} };
+}
+
 //#endregion
 //#region src/tools/dns-tools.ts
 /**
@@ -115960,6 +116272,7 @@ async function createTonWalletMCP(config) {
 	const knownJettonsTools = createMcpKnownJettonsTools();
 	const nftTools = createMcpNftTools(walletService);
 	const dnsTools = createMcpDnsTools(walletService);
+	const transactionTools = createMcpTransactionTools(walletService);
 	const registerTool = (name, tool) => {
 		server.registerTool(name, {
 			description: tool.description,
@@ -115974,6 +116287,7 @@ async function createTonWalletMCP(config) {
 	registerTool("send_ton", transferTools.send_ton);
 	registerTool("send_jetton", transferTools.send_jetton);
 	registerTool("send_raw_transaction", transferTools.send_raw_transaction);
+	registerTool("get_transaction_status", transactionTools.get_transaction_status);
 	registerTool("get_swap_quote", swapTools.get_swap_quote);
 	registerTool("get_known_jettons", knownJettonsTools.get_known_jettons);
 	registerTool("get_nfts", nftTools.get_nfts);