@truecarry/mcp 0.1.4 → 0.1.6

package/dist/index.js

@@ -70172,7 +70172,7 @@ async function dnsLookup(client, domain, category, resolver) {
 		type: "int",
 		value: toTonDnsCategory(category)
 	}];
-	const { stack, exitCode } = await client.runGetMethod(asAddressFriendly(resolver), "dnsresolve", SerializeStack(param));
+	const { stack, exitCode } = await CallForSuccess(() => client.runGetMethod(asAddressFriendly(resolver), "dnsresolve", SerializeStack(param)));
 	if (stack?.length !== 2) return null;
 	const parsedStack = ParseStack(stack);
 	if (exitCode !== 0) return null;
@@ -86802,7 +86802,24 @@ var McpWalletService = class McpWalletService {
 		}
 	}
 	/**
-	* Get swap quote
+	* Send a raw transaction request directly
+	*/
+	async sendRawTransaction(request) {
+		try {
+			await this.wallet.sendTransaction(request);
+			return {
+				success: true,
+				message: `Successfully sent transaction with ${request.messages.length} message(s)`
+			};
+		} catch (error) {
+			return {
+				success: false,
+				message: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* Get swap quote with transaction params ready to execute
 	*/
 	async getSwapQuote(fromToken, toToken, amount, slippageBps) {
 		const network = this.wallet.getNetwork();
@@ -86821,32 +86838,95 @@ var McpWalletService = class McpWalletService {
 			slippageBps
 		};
 		const quote = await kit.swap.getQuote(params);
-		return {
+		const swapParams = {
 			quote,
+			userAddress: this.wallet.getAddress()
+		};
+		const tx = await kit.swap.buildSwapTransaction(swapParams);
+		return {
 			fromToken: quote.fromToken.type === "ton" ? "TON" : quote.fromToken.value,
 			toToken: quote.toToken.type === "ton" ? "TON" : quote.toToken.value,
 			fromAmount: quote.fromAmount,
 			toAmount: quote.toAmount,
 			minReceived: quote.minReceived,
 			provider: quote.providerId,
-			expiresAt: quote.expiresAt
+			expiresAt: quote.expiresAt,
+			transaction: {
+				messages: tx.messages.map((m) => ({
+					address: m.address,
+					amount: m.amount.toString(),
+					stateInit: m.stateInit,
+					payload: m.payload
+				})),
+				validUntil: tx.validUntil
+			}
+		};
+	}
+	/**
+	* Get all NFTs
+	*/
+	async getNfts(limit = 20, offset = 0) {
+		return (await this.wallet.getNfts({ pagination: {
+			limit,
+			offset
+		} })).nfts.map((nft) => ({
+			address: nft.address,
+			name: nft.info?.name,
+			description: nft.info?.description,
+			image: typeof nft.info?.image === "string" ? nft.info.image : nft.info?.image?.url,
+			collection: nft.collection ? {
+				address: nft.collection.address,
+				name: nft.collection.name
+			} : void 0,
+			attributes: nft.attributes?.map((attr) => ({
+				trait_type: attr.traitType,
+				value: attr.value
+			})),
+			ownerAddress: nft.ownerAddress,
+			isOnSale: nft.isOnSale,
+			isSoulbound: nft.isSoulbound,
+			saleContractAddress: nft.saleContractAddress
+		}));
+	}
+	/**
+	* Get a specific NFT by address
+	*/
+	async getNft(nftAddress) {
+		const nft = await this.wallet.getNft(nftAddress);
+		if (!nft) return null;
+		return {
+			address: nft.address,
+			name: nft.info?.name,
+			description: nft.info?.description,
+			image: typeof nft.info?.image === "string" ? nft.info.image : nft.info?.image?.url,
+			collection: nft.collection ? {
+				address: nft.collection.address,
+				name: nft.collection.name
+			} : void 0,
+			attributes: nft.attributes?.map((attr) => ({
+				trait_type: attr.traitType,
+				value: attr.value
+			})),
+			ownerAddress: nft.ownerAddress,
+			isOnSale: nft.isOnSale,
+			isSoulbound: nft.isSoulbound,
+			saleContractAddress: nft.saleContractAddress
 		};
 	}
 	/**
-	* Execute swap
+	* Send NFT
 	*/
-	async executeSwap(quote) {
+	async sendNft(nftAddress, toAddress, comment) {
 		try {
-			const kit = await this.getKit();
-			const params = {
-				quote,
-				userAddress: this.wallet.getAddress()
-			};
-			const tx = await kit.swap.buildSwapTransaction(params);
+			const tx = await this.wallet.createTransferNftTransaction({
+				nftAddress,
+				recipientAddress: toAddress,
+				comment
+			});
 			await this.wallet.sendTransaction(tx);
 			return {
 				success: true,
-				message: `Successfully swapped ${quote.fromAmount} ${quote.fromToken} for ${quote.toAmount} ${quote.toToken}`
+				message: `Successfully sent NFT ${nftAddress} to ${toAddress}`
 			};
 		} catch (error) {
 			return {
@@ -86863,6 +86943,18 @@ var McpWalletService = class McpWalletService {
 		return this.config.contacts.resolve("default", name);
 	}
 	/**
+	* Resolve a TON DNS domain (e.g., "wallet.ton") to a wallet address
+	*/
+	async resolveDns(domain) {
+		return this.wallet.getClient().resolveDnsWallet(domain);
+	}
+	/**
+	* Reverse resolve a wallet address to a TON DNS domain
+	*/
+	async backResolveDns(address) {
+		return this.wallet.getClient().backResolveDnsWallet(address);
+	}
+	/**
 	* Close and cleanup
 	*/
 	async close() {
@@ -87067,6 +87159,17 @@ const sendJettonSchema = z.object({
 	amount: z.string().min(1).describe("Amount of tokens to send in human-readable format"),
 	comment: z.string().optional().describe("Optional comment/memo for the transaction")
 });
+const transactionMessageSchema = z.object({
+	address: z.string().min(1).describe("Recipient wallet address"),
+	amount: z.string().min(1).describe("Amount to transfer in nanotons"),
+	stateInit: z.string().optional().describe("Initial state for deploying a new contract (Base64)"),
+	payload: z.string().optional().describe("Message payload data (Base64)")
+});
+const sendRawTransactionSchema = z.object({
+	messages: z.array(transactionMessageSchema).min(1).describe("Array of messages to include in the transaction"),
+	validUntil: z.number().optional().describe("Unix timestamp after which the transaction becomes invalid"),
+	fromAddress: z.string().optional().describe("Sender wallet address")
+});
 function createMcpTransferTools(service) {
 	return {
 		send_ton: {
@@ -87159,6 +87262,41 @@ function createMcpTransferTools(service) {
 					}, 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.",
+			inputSchema: sendRawTransactionSchema,
+			handler: async (args) => {
+				const result = await service.sendRawTransaction({
+					messages: args.messages,
+					validUntil: args.validUntil,
+					fromAddress: args.fromAddress
+				});
+				if (!result.success) return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({
+							success: false,
+							error: result.message
+						})
+					}],
+					isError: true
+				};
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: true,
+						message: result.message,
+						details: {
+							messageCount: args.messages.length,
+							messages: args.messages.map((m) => ({
+								to: m.address,
+								amount: `${m.amount} nanoTON`
+							}))
+						}
+					}, null, 2)
+				}] };
+			}
 		}
 	};
 }
@@ -87172,49 +87310,153 @@ function createMcpTransferTools(service) {
 * LICENSE file in the root directory of this source tree.
 *
 */
-const quoteCache = /* @__PURE__ */ new Map();
-function generateQuoteId() {
-	return `quote_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-}
-function cleanExpiredQuotes() {
-	const now = Date.now();
-	for (const [id, data] of quoteCache.entries()) if (data.expiresAt < now) quoteCache.delete(id);
-}
 const getSwapQuoteSchema = z.object({
 	fromToken: z.string().min(1).describe("Token to swap from (\"TON\" or jetton address)"),
 	toToken: z.string().min(1).describe("Token to swap to (\"TON\" or jetton address)"),
 	amount: z.string().min(1).describe("Amount to swap in raw units"),
 	slippageBps: z.number().optional().describe("Slippage tolerance in basis points (default 100 = 1%)")
 });
-const executeSwapSchema = z.object({ quoteId: z.string().min(1).describe("Quote ID returned from get_swap_quote") });
 function createMcpSwapTools(service) {
+	return { get_swap_quote: {
+		description: "Get a quote for swapping tokens. Returns quote details and transaction params. If user confirms, use send_raw_transaction to execute.",
+		inputSchema: getSwapQuoteSchema,
+		handler: async (args) => {
+			try {
+				const result = await service.getSwapQuote(args.fromToken, args.toToken, args.amount, args.slippageBps);
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: true,
+						quote: {
+							fromToken: result.fromToken,
+							toToken: result.toToken,
+							fromAmount: result.fromAmount,
+							toAmount: result.toAmount,
+							minReceived: result.minReceived,
+							provider: result.provider,
+							expiresAt: result.expiresAt ? (/* @__PURE__ */ new Date(result.expiresAt * 1e3)).toISOString() : null
+						},
+						transaction: result.transaction,
+						note: "If user confirms, use send_raw_transaction with the transaction params to execute the swap."
+					}, null, 2)
+				}] };
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify({
+							success: false,
+							error: error instanceof Error ? error.message : "Unknown error"
+						})
+					}],
+					isError: true
+				};
+			}
+		}
+	} };
+}
+
+//#endregion
+//#region src/tools/known-jettons-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 getKnownJettonsSchema = z.object({});
+const KNOWN_JETTONS = [
+	{
+		symbol: "USD₮",
+		name: "Tether USD",
+		address: "EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs",
+		decimals: 6
+	},
+	{
+		symbol: "NOT",
+		name: "Notcoin",
+		address: "EQAvlWFDxGF2lXm67y4yzC17wYKD9A0guwPkMs1gOsM__NOT",
+		decimals: 9
+	},
+	{
+		symbol: "DOGS",
+		name: "Dogs",
+		address: "EQCvxJy4eG8hyHBFsZ7eePxrRsUQSFE_jpptRAYBmcG_DOGS",
+		decimals: 9
+	},
+	{
+		symbol: "DUST",
+		name: "DeDust",
+		address: "EQBlqsm144Dq6SjbPI4jjZvA1hqTIP3CvHovbIfW_t-SCALE",
+		decimals: 9
+	},
+	{
+		symbol: "GRAM",
+		name: "Gram",
+		address: "EQC47093oX5Xhb0xuk2lCr2RhS8rj-vul61u4W2UH5ORmG_O",
+		decimals: 9
+	}
+];
+function createMcpKnownJettonsTools() {
+	return { get_known_jettons: {
+		description: "Get a list of known/popular Jettons (tokens) on TON with their addresses and metadata. Useful for looking up token addresses for swaps or transfers.",
+		inputSchema: getKnownJettonsSchema,
+		handler: async () => {
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					jettons: KNOWN_JETTONS,
+					count: KNOWN_JETTONS.length
+				}, null, 2)
+			}] };
+		}
+	} };
+}
+
+//#endregion
+//#region src/tools/nft-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 getNftsSchema = z.object({
+	limit: z.number().min(1).max(100).optional().describe("Maximum number of NFTs to return (default: 20, max: 100)"),
+	offset: z.number().min(0).optional().describe("Offset for pagination (default: 0)")
+});
+const getNftSchema = z.object({ nftAddress: z.string().min(1).describe("NFT item contract address") });
+const sendNftSchema = z.object({
+	nftAddress: z.string().min(1).describe("NFT item contract address to transfer"),
+	toAddress: z.string().min(1).describe("Recipient TON address"),
+	comment: z.string().optional().describe("Optional comment/memo for the transaction")
+});
+function createMcpNftTools(service) {
 	return {
-		get_swap_quote: {
-			description: "Get a quote for swapping tokens. Returns a quote ID to use with execute_swap.",
-			inputSchema: getSwapQuoteSchema,
+		get_nfts: {
+			description: "List all NFTs (non-fungible tokens) in the wallet with their metadata, collection info, and attributes.",
+			inputSchema: getNftsSchema,
 			handler: async (args) => {
 				try {
-					cleanExpiredQuotes();
-					const result = await service.getSwapQuote(args.fromToken, args.toToken, args.amount, args.slippageBps);
-					const quoteId = generateQuoteId();
-					const expiresAt = result.expiresAt ? result.expiresAt * 1e3 : Date.now() + 6e4;
-					quoteCache.set(quoteId, {
-						quote: result.quote,
-						expiresAt
-					});
+					const nfts = await service.getNfts(args.limit ?? 20, args.offset ?? 0);
 					return { content: [{
 						type: "text",
 						text: JSON.stringify({
 							success: true,
-							quoteId,
-							fromToken: result.fromToken,
-							toToken: result.toToken,
-							fromAmount: result.fromAmount,
-							toAmount: result.toAmount,
-							minReceived: result.minReceived,
-							provider: result.provider,
-							expiresAt: result.expiresAt ? (/* @__PURE__ */ new Date(result.expiresAt * 1e3)).toISOString() : null,
-							note: "Use the quoteId with execute_swap to complete the swap."
+							nfts: nfts.map((nft) => ({
+								address: nft.address,
+								name: nft.name,
+								description: nft.description,
+								image: nft.image,
+								collection: nft.collection,
+								attributes: nft.attributes,
+								isOnSale: nft.isOnSale,
+								isSoulbound: nft.isSoulbound
+							})),
+							count: nfts.length
 						}, null, 2)
 					}] };
 				} catch (error) {
@@ -87231,61 +87473,175 @@ function createMcpSwapTools(service) {
 				}
 			}
 		},
-		execute_swap: {
-			description: "Execute a token swap using a quote.",
-			inputSchema: executeSwapSchema,
+		get_nft: {
+			description: "Get detailed information about a specific NFT by its address.",
+			inputSchema: getNftSchema,
 			handler: async (args) => {
-				cleanExpiredQuotes();
-				const cachedQuote = quoteCache.get(args.quoteId);
-				if (!cachedQuote) return {
-					content: [{
+				try {
+					const nft = await service.getNft(args.nftAddress);
+					if (!nft) return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({
+								success: false,
+								error: "NFT not found"
+							})
+						}],
+						isError: true
+					};
+					return { content: [{
 						type: "text",
 						text: JSON.stringify({
-							success: false,
-							error: "Quote not found or expired. Please get a new quote."
-						})
-					}],
-					isError: true
-				};
-				if (cachedQuote.expiresAt < Date.now()) {
-					quoteCache.delete(args.quoteId);
+							success: true,
+							nft: {
+								address: nft.address,
+								name: nft.name,
+								description: nft.description,
+								image: nft.image,
+								collection: nft.collection,
+								attributes: nft.attributes,
+								ownerAddress: nft.ownerAddress,
+								isOnSale: nft.isOnSale,
+								isSoulbound: nft.isSoulbound,
+								saleContractAddress: nft.saleContractAddress
+							}
+						}, null, 2)
+					}] };
+				} catch (error) {
 					return {
 						content: [{
 							type: "text",
 							text: JSON.stringify({
 								success: false,
-								error: "Quote has expired. Please get a new quote."
+								error: error instanceof Error ? error.message : "Unknown error"
 							})
 						}],
 						isError: true
 					};
 				}
-				const result = await service.executeSwap(cachedQuote.quote);
-				quoteCache.delete(args.quoteId);
-				if (!result.success) return {
-					content: [{
+			}
+		},
+		send_nft: {
+			description: "Transfer an NFT from the wallet to another address.",
+			inputSchema: sendNftSchema,
+			handler: async (args) => {
+				try {
+					const result = await service.sendNft(args.nftAddress, args.toAddress, args.comment);
+					return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({
+								success: result.success,
+								message: result.message,
+								nftAddress: args.nftAddress,
+								recipient: args.toAddress
+							}, null, 2)
+						}],
+						isError: !result.success
+					};
+				} catch (error) {
+					return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({
+								success: false,
+								error: error instanceof Error ? error.message : "Unknown error"
+							})
+						}],
+						isError: true
+					};
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/tools/dns-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 resolveDnsSchema = z.object({ domain: z.string().min(1).describe("TON DNS domain to resolve (e.g., \"foundation.ton\")") });
+const backResolveDnsSchema = z.object({ address: z.string().min(1).describe("TON wallet address to reverse resolve") });
+function createMcpDnsTools(service) {
+	return {
+		resolve_dns: {
+			description: "Resolve a TON DNS domain (e.g., \"foundation.ton\") to a wallet address. Use this when the user provides a .ton domain instead of a raw address.",
+			inputSchema: resolveDnsSchema,
+			handler: async (args) => {
+				try {
+					const address = await service.resolveDns(args.domain);
+					if (!address) return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({
+								success: false,
+								error: `Could not resolve domain "${args.domain}". The domain may not exist or may not have a wallet record.`
+							})
+						}],
+						isError: true
+					};
+					return { content: [{
 						type: "text",
 						text: JSON.stringify({
-							success: false,
-							error: result.message
+							success: true,
+							domain: args.domain,
+							address
+						}, null, 2)
+					}] };
+				} catch (error) {
+					return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({
+								success: false,
+								error: `Failed to resolve domain: ${error instanceof Error ? error.message : "Unknown error"}`
+							})
+						}],
+						isError: true
+					};
+				}
+			}
+		},
+		back_resolve_dns: {
+			description: "Reverse resolve a TON wallet address to its DNS domain (e.g., find the .ton domain associated with an address).",
+			inputSchema: backResolveDnsSchema,
+			handler: async (args) => {
+				try {
+					const domain = await service.backResolveDns(args.address);
+					if (!domain) return { content: [{
+						type: "text",
+						text: JSON.stringify({
+							success: true,
+							address: args.address,
+							domain: null,
+							message: "No DNS domain found for this address."
 						})
-					}],
-					isError: true
-				};
-				return { content: [{
-					type: "text",
-					text: JSON.stringify({
-						success: true,
-						message: result.message,
-						details: {
-							fromToken: cachedQuote.quote.fromToken,
-							toToken: cachedQuote.quote.toToken,
-							fromAmount: cachedQuote.quote.fromAmount,
-							toAmount: cachedQuote.quote.toAmount,
-							provider: cachedQuote.quote.providerId
-						}
-					}, null, 2)
-				}] };
+					}] };
+					return { content: [{
+						type: "text",
+						text: JSON.stringify({
+							success: true,
+							address: args.address,
+							domain
+						}, null, 2)
+					}] };
+				} catch (error) {
+					return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({
+								success: false,
+								error: `Failed to reverse resolve address: ${error instanceof Error ? error.message : "Unknown error"}`
+							})
+						}],
+						isError: true
+					};
+				}
 			}
 		}
 	};
@@ -87342,6 +87698,9 @@ async function createTonWalletMCP(config) {
 	const balanceTools = createMcpBalanceTools(walletService);
 	const transferTools = createMcpTransferTools(walletService);
 	const swapTools = createMcpSwapTools(walletService);
+	const knownJettonsTools = createMcpKnownJettonsTools();
+	const nftTools = createMcpNftTools(walletService);
+	const dnsTools = createMcpDnsTools(walletService);
 	const registerTool = (name, tool) => {
 		server.registerTool(name, {
 			description: tool.description,
@@ -87354,8 +87713,14 @@ async function createTonWalletMCP(config) {
 	registerTool("get_transactions", balanceTools.get_transactions);
 	registerTool("send_ton", transferTools.send_ton);
 	registerTool("send_jetton", transferTools.send_jetton);
+	registerTool("send_raw_transaction", transferTools.send_raw_transaction);
 	registerTool("get_swap_quote", swapTools.get_swap_quote);
-	registerTool("execute_swap", swapTools.execute_swap);
+	registerTool("get_known_jettons", knownJettonsTools.get_known_jettons);
+	registerTool("get_nfts", nftTools.get_nfts);
+	registerTool("get_nft", nftTools.get_nft);
+	registerTool("send_nft", nftTools.send_nft);
+	registerTool("resolve_dns", dnsTools.resolve_dns);
+	registerTool("back_resolve_dns", dnsTools.back_resolve_dns);
 	return server;
 }
 /**