@truecarry/mcp 0.1.3 → 0.1.5

package/dist/cli.js

@@ -21893,7 +21893,7 @@ var WalletKitError = class WalletKitError extends Error {
 function asBase64(data) {
 	if (!/^[A-Za-z0-9+/]*={0,2}$/.test(data)) throw new Error("Not a valid base64");
 	try {
-		if (Buffer.from(data, "base64").toString("base64") !== data) throw new Error("Not a valid base64");
+		ParseBase64(data);
 	} catch (_e) {
 		throw new Error("Not a valid base64");
 	}
@@ -23814,36 +23814,22 @@ var TONConnectStoredSessionManager = class {
 	async getSession(sessionId) {
 		return this.sessions.get(sessionId);
 	}
-	async getSessionByDomain(domain) {
-		let host;
-		try {
-			host = new URL(domain).host;
+	async getSessions(filter) {
+		let sessions = Array.from(this.sessions.values());
+		if (!filter) return sessions;
+		let domain;
+		if (filter.domain) try {
+			domain = new URL(filter.domain).host;
 		} catch {
-			return;
-		}
-		for (const session of this.sessions.values()) if (session.domain === host) return this.getSession(session.sessionId);
-	}
-	/**
-	* Get all sessions as array
-	*/
-	async getSessions() {
-		return Array.from(this.sessions.values());
-	}
-	/**
-	* Get sessions for specific wallet by wallet ID
-	*/
-	async getSessionsForWallet(walletId) {
-		return (await this.getSessions()).filter((session) => session.walletId === walletId);
-	}
-	/**
-	* Update session activity timestamp
-	*/
-	async updateSessionActivity(sessionId) {
-		const session = this.sessions.get(sessionId);
-		if (session) {
-			session.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
-			await this.persistSessions();
-		}
+			domain = filter.domain;
+		}
+		return sessions.filter((session) => {
+			let isIncluded = true;
+			if (filter.walletId) isIncluded = isIncluded && session.walletId === filter.walletId;
+			if (filter.domain) isIncluded = isIncluded && session.domain === domain;
+			if (filter.isJsBridge !== void 0) isIncluded = isIncluded && session.isJsBridge === filter.isJsBridge;
+			return isIncluded;
+		});
 	}
 	/**
 	* Remove session by ID
@@ -23851,11 +23837,8 @@ var TONConnectStoredSessionManager = class {
 	async removeSession(sessionId) {
 		if (this.sessions.delete(sessionId)) await this.persistSessions();
 	}
-	/**
-	* Remove all sessions for a wallet by wallet ID or wallet adapter
-	*/
-	async removeSessionsForWallet(walletId) {
-		const sessionsToRemove = await this.getSessionsForWallet(walletId);
+	async removeSessions(filter) {
+		const sessionsToRemove = await this.getSessions(filter);
 		let removedCount = 0;
 		for (const session of sessionsToRemove) if (this.sessions.delete(session.sessionId)) removedCount++;
 		if (removedCount > 0) await this.persistSessions();
@@ -64265,13 +64248,15 @@ var BridgeManager = class {
 			isJsBridge: true,
 			tabId: messageInfo.tabId,
 			domain: messageInfo.domain,
-			messageId: messageInfo.messageId
+			messageId: messageInfo.messageId,
+			walletId: messageInfo.walletId
 		});
 		else if (event.method == "restoreConnection") this.eventEmitter?.emit("restoreConnection", {
 			...event,
 			tabId: messageInfo.tabId,
 			domain: messageInfo.domain,
-			messageId: messageInfo.messageId
+			messageId: messageInfo.messageId,
+			walletId: messageInfo.walletId
 		});
 		else if (event.method == "send" && event?.params?.length === 1) this.eventQueue.push({
 			...event,
@@ -64279,7 +64264,8 @@ var BridgeManager = class {
 			isJsBridge: true,
 			tabId: messageInfo.tabId,
 			domain: messageInfo.domain,
-			messageId: messageInfo.messageId
+			messageId: messageInfo.messageId,
+			walletId: messageInfo.walletId
 		});
 		this.processBridgeEvents().catch((error) => {
 			log$21.error("Error in background event processing", { error });
@@ -64331,7 +64317,8 @@ var BridgeManager = class {
 				isJsBridge: event?.isJsBridge,
 				tabId: event?.tabId,
 				messageId: event?.messageId,
-				traceId: event?.traceId
+				traceId: event?.traceId,
+				walletId: event?.walletId
 			};
 			if (!rawEvent.traceId) rawEvent.traceId = v7_default();
 			await this.sessionManager.initialize();
@@ -64349,7 +64336,12 @@ var BridgeManager = class {
 					};
 				}
 			} else if (rawEvent.domain) {
-				const session = await this.sessionManager.getSessionByDomain(rawEvent.domain);
+				const sessions = await this.sessionManager.getSessions({
+					walletId: event.walletId,
+					domain: rawEvent.domain,
+					isJsBridge: rawEvent.isJsBridge
+				});
+				const session = sessions.length > 0 ? sessions[0] : void 0;
 				if (session?.walletId) rawEvent.walletId = session.walletId;
 				if (session?.walletAddress) rawEvent.walletAddress = session.walletAddress;
 				if (session?.sessionId) rawEvent.from = session.sessionId;
@@ -68159,9 +68151,6 @@ async function MnemonicToKeyPair(mnemonic, mnemonicType = "ton") {
 		supportedTypes: ["ton", "bip39"]
 	});
 }
-async function CreateTonMnemonic() {
-	return (0, import_dist$1.mnemonicNew)(24);
-}
 
 //#endregion
 //#region ../walletkit/dist/esm/utils/sign.js
@@ -70109,6 +70098,7 @@ var DefiManagerError = class extends Error {
 	static NO_DEFAULT_PROVIDER = "NO_DEFAULT_PROVIDER";
 	static NETWORK_ERROR = "NETWORK_ERROR";
 	static INVALID_PARAMS = "INVALID_PARAMS";
+	static INVALID_PROVIDER = "INVALID_PROVIDER";
 	code;
 	details;
 	constructor(message, code, details) {
@@ -70150,36 +70140,42 @@ var SwapError = class extends DefiManagerError {
 */
 var DefiManager = class {
 	providers = /* @__PURE__ */ new Map();
-	defaultProvider;
+	defaultProviderId;
 	/**
 	* Register a swap provider
 	* @param name - Unique name for the provider
 	* @param provider - Provider instance
 	*/
-	registerProvider(name, provider) {
-		this.providers.set(name, provider);
-		if (!this.defaultProvider) this.defaultProvider = name;
+	/**
+	* Register a swap provider
+	* @param provider - Provider instance
+	*/
+	registerProvider(provider) {
+		const providerId = provider.providerId;
+		if (!providerId) throw this.createError("Provider must have a providerId", DefiManagerError.INVALID_PROVIDER);
+		this.providers.set(providerId, provider);
+		if (!this.defaultProviderId) this.defaultProviderId = providerId;
 	}
 	/**
 	* Set the default provider to use when none is specified
-	* @param name - Provider name
+	* @param providerId - Provider name
 	* @throws DefiManagerError if provider not found
 	*/
-	setDefaultProvider(name) {
-		if (!this.providers.has(name)) throw this.createError(`Provider '${name}' not registered`, DefiManagerError.PROVIDER_NOT_FOUND, {
-			provider: name,
+	setDefaultProvider(providerId) {
+		if (!this.providers.has(providerId)) throw this.createError(`Provider '${providerId}' not registered`, DefiManagerError.PROVIDER_NOT_FOUND, {
+			provider: providerId,
 			registered: Array.from(this.providers.keys())
 		});
-		this.defaultProvider = name;
+		this.defaultProviderId = providerId;
 	}
 	/**
 	* Get a provider by name, or the default provider
-	* @param name - Optional provider name
+	* @param providerId - Optional provider name
 	* @returns Provider instance
 	* @throws DefiManagerError if provider not found or no default set
 	*/
-	getProvider(name) {
-		const providerName = name || this.defaultProvider;
+	getProvider(providerId) {
+		const providerName = providerId || this.defaultProviderId;
 		if (!providerName) throw this.createError("No default provider set. Register a provider first.", DefiManagerError.NO_DEFAULT_PROVIDER);
 		const provider = this.providers.get(providerName);
 		if (!provider) throw this.createError(`Provider '${providerName}' not found`, DefiManagerError.PROVIDER_NOT_FOUND, {
@@ -70197,11 +70193,11 @@ var DefiManager = class {
 	}
 	/**
 	* Check if a provider is registered
-	* @param name - Provider name
+	* @param providerId - Provider id
 	* @returns True if provider exists
 	*/
-	hasProvider(name) {
-		return this.providers.has(name);
+	hasProvider(providerId) {
+		return this.providers.has(providerId);
 	}
 };
 
@@ -70229,14 +70225,12 @@ var SwapManager = class extends DefiManager {
 	* @returns Promise resolving to swap quote
 	*/
 	async getQuote(params, provider) {
-		if (params.amountFrom && params.amountTo) throw new SwapError("Cannot specify both amountFrom and amountTo", SwapError.INVALID_PARAMS);
-		if (!params.amountFrom && !params.amountTo) throw new SwapError("Must specify either amountFrom or amountTo", SwapError.INVALID_PARAMS);
 		log$10.debug("Getting swap quote", {
 			fromToken: params.fromToken,
 			toToken: params.toToken,
-			amountFrom: params.amountFrom,
-			amountTo: params.amountTo,
-			provider: provider || this.defaultProvider
+			amount: params.amount,
+			isReverseSwap: params.isReverseSwap,
+			provider: provider || this.defaultProviderId
 		});
 		try {
 			const quote = await this.getProvider(provider).getQuote(params);
@@ -70263,7 +70257,7 @@ var SwapManager = class extends DefiManager {
 	async buildSwapTransaction(params, provider) {
 		log$10.debug("Building swap transaction", {
 			userAddress: params.userAddress,
-			provider: provider || this.defaultProvider
+			provider: provider || this.defaultProviderId
 		});
 		try {
 			const transaction = await this.getProvider(provider).buildSwapTransaction(params);
@@ -71530,23 +71524,28 @@ var TonWalletKit = class {
 		this.eventEmitter.on("restoreConnection", async (event) => {
 			if (!event.domain) {
 				log$5.error("Domain is required for restore connection");
-				return;
+				return this.sendErrorConnectResponse(event);
 			}
-			const session = await this.sessionManager.getSessionByDomain(event.domain);
+			const sessions = await this.sessionManager.getSessions({
+				walletId: event.walletId,
+				domain: event.domain,
+				isJsBridge: true
+			});
+			const session = sessions.length > 0 ? sessions[0] : void 0;
 			if (!session) {
 				log$5.error("Session not found for domain", { domain: event.domain });
-				return;
+				return this.sendErrorConnectResponse(event);
 			}
 			const wallet = session.walletId ? this.walletManager?.getWallet(session.walletId) : void 0;
 			if (!wallet) {
 				log$5.error("Wallet not found for session", { walletId: session.walletId });
-				return;
+				return this.sendErrorConnectResponse(event);
 			}
 			const walletAddress = wallet.getAddress();
 			const walletStateInit = await wallet.getStateInit();
 			const publicKey = wallet.getPublicKey().replace("0x", "");
 			const deviceInfo = getDeviceInfoForWallet(wallet, this.config.deviceInfo);
-			const connectResponse = {
+			const tonConnectEvent = {
 				event: "connect",
 				id: Date.now(),
 				payload: {
@@ -71560,9 +71559,20 @@ var TonWalletKit = class {
 					}]
 				}
 			};
-			this.bridgeManager.sendJsBridgeResponse(event?.tabId?.toString() || "", true, event?.id ?? event?.messageId, connectResponse);
+			this.bridgeManager.sendJsBridgeResponse(event?.tabId?.toString() || "", true, event?.id ?? event?.messageId, tonConnectEvent);
 		});
 	}
+	async sendErrorConnectResponse(event) {
+		const tonConnectEvent = {
+			event: "connect_error",
+			id: Date.now(),
+			payload: {
+				code: CONNECT_EVENT_ERROR_CODES.UNKNOWN_APP_ERROR,
+				message: ""
+			}
+		};
+		await this.bridgeManager.sendJsBridgeResponse(event?.tabId?.toString() || "", true, event?.id ?? event?.messageId, tonConnectEvent);
+	}
 	/**
 	* Initialize all components
 	*/
@@ -71667,7 +71677,7 @@ var TonWalletKit = class {
 		if (!wallet) throw new WalletKitError(ERROR_CODES.WALLET_NOT_FOUND, "Wallet not found for removal", void 0, { walletId });
 		await this.eventProcessor.stopProcessing(wallet.getAddress());
 		await this.walletManager.removeWallet(walletId);
-		await this.sessionManager.removeSessionsForWallet(walletId);
+		await this.sessionManager.removeSessions({ walletId });
 	}
 	async clearWallets() {
 		await this.ensureInitialized();
@@ -87854,15 +87864,21 @@ function unwrapObservable(originalMethod) {
 *
 */
 const tokenToAddress = (token) => {
-	if (token === "TON") return "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
-	return import_dist$2.Address.parse(token).toRawString();
+	if (token.type === "ton") return "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
+	return import_dist$2.Address.parse(token.value).toRawString();
 };
 const addressToToken = (address) => {
-	if (address === "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c") return "TON";
+	if (address === "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c") return { type: "ton" };
 	try {
-		return import_dist$2.Address.parseRaw(address).toString();
+		return {
+			type: "jetton",
+			value: import_dist$2.Address.parseRaw(address).toString()
+		};
 	} catch {
-		return address;
+		return {
+			type: "jetton",
+			value: address
+		};
 	}
 };
 const toOmnistonAddress = (address, network) => {
@@ -87929,8 +87945,10 @@ var OmnistonSwapProvider = class extends SwapProvider {
 	referrerFeeBps;
 	flexibleReferrerFee;
 	omniston$;
+	providerId;
 	constructor(config) {
 		super();
+		this.providerId = config?.providerId ?? "omniston";
 		this.apiUrl = config?.apiUrl ?? "wss://omni-ws.ston.fi";
 		this.defaultSlippageBps = config?.defaultSlippageBps ?? 100;
 		this.quoteTimeoutMs = config?.quoteTimeoutMs ?? 1e4;
@@ -87950,8 +87968,8 @@ var OmnistonSwapProvider = class extends SwapProvider {
 		log$1.debug("Getting Omniston quote", {
 			fromToken: params.fromToken,
 			toToken: params.toToken,
-			amountFrom: params.amountFrom,
-			amountTo: params.amountTo
+			amount: params.amount,
+			isReverseSwap: params.isReverseSwap
 		});
 		try {
 			const bidAssetAddress = tokenToAddress(params.fromToken);
@@ -87961,7 +87979,7 @@ var OmnistonSwapProvider = class extends SwapProvider {
 			const referrerFeeBps = params.providerOptions?.referrerFeeBps ?? this.referrerFeeBps;
 			const flexibleReferrerFee = params.providerOptions?.flexibleReferrerFee ?? this.flexibleReferrerFee;
 			const quoteRequest = {
-				amount: params.amountFrom ? { bidUnits: params.amountFrom } : { askUnits: params.amountTo },
+				amount: params.isReverseSwap ? { askUnits: params.amount } : { bidUnits: params.amount },
 				settlementMethods: [SettlementMethod.SETTLEMENT_METHOD_SWAP],
 				bidAssetAddress: toOmnistonAddress(bidAssetAddress, params.network),
 				askAssetAddress: toOmnistonAddress(askAssetAddress, params.network),
@@ -88095,7 +88113,7 @@ var OmnistonSwapProvider = class extends SwapProvider {
 		});
 		return {
 			metadata,
-			provider: "omniston",
+			providerId: this.providerId,
 			fromToken: params.fromToken,
 			toToken: params.toToken,
 			fromAmount: quote.bidUnits,
@@ -88108,388 +88126,6 @@ var OmnistonSwapProvider = class extends SwapProvider {
 	}
 };
 
-//#endregion
-//#region src/core/UserScopedStorage.ts
-/**
-* User-scoped storage wrapper.
-* Automatically prefixes all keys with user namespace.
-*/
-var UserScopedStorage = class {
-	storage;
-	userId;
-	prefix;
-	constructor(storage, userId) {
-		this.storage = storage;
-		this.userId = userId;
-		this.prefix = `user:${userId}:`;
-	}
-	/**
-	* Get the user ID this storage is scoped to
-	*/
-	getUserId() {
-		return this.userId;
-	}
-	/**
-	* Build full key with user prefix
-	*/
-	buildKey(key) {
-		return `${this.prefix}${key}`;
-	}
-	/**
-	* Strip user prefix from a key
-	*/
-	stripPrefix(fullKey) {
-		if (fullKey.startsWith(this.prefix)) return fullKey.slice(this.prefix.length);
-		return fullKey;
-	}
-	/**
-	* Get a value by key (user-scoped)
-	*/
-	async get(key) {
-		return this.storage.get(this.buildKey(key));
-	}
-	/**
-	* Set a value (user-scoped)
-	*/
-	async set(key, value, ttlSeconds) {
-		return this.storage.set(this.buildKey(key), value, ttlSeconds);
-	}
-	/**
-	* Delete a key (user-scoped)
-	*/
-	async delete(key) {
-		return this.storage.delete(this.buildKey(key));
-	}
-	/**
-	* List keys matching prefix (user-scoped)
-	* Returns keys with user prefix stripped.
-	*/
-	async list(subPrefix) {
-		const fullPrefix = this.buildKey(subPrefix);
-		return (await this.storage.list(fullPrefix)).map((k) => this.stripPrefix(k));
-	}
-	/**
-	* Get the underlying storage adapter.
-	* Use with caution - bypasses user isolation.
-	*/
-	getUnderlyingStorage() {
-		return this.storage;
-	}
-};
-
-//#endregion
-//#region src/core/UserScopedSigner.ts
-/**
-* User-scoped signer wrapper.
-* Ensures all operations are scoped to the authenticated user.
-*/
-var UserScopedSigner = class {
-	signer;
-	userId;
-	userPrefix;
-	constructor(signer, userId) {
-		this.signer = signer;
-		this.userId = userId;
-		this.userPrefix = `${userId}:`;
-	}
-	/**
-	* Get the user ID this signer is scoped to
-	*/
-	getUserId() {
-		return this.userId;
-	}
-	/**
-	* Build user-scoped wallet ID from wallet name
-	*/
-	scopedId(walletName) {
-		return `${this.userPrefix}${walletName}`;
-	}
-	/**
-	* Extract wallet name from scoped ID
-	*/
-	extractName(scopedId) {
-		if (scopedId.startsWith(this.userPrefix)) return scopedId.slice(this.userPrefix.length);
-		return scopedId;
-	}
-	/**
-	* Check if a wallet ID belongs to this user
-	*/
-	isOwnedByUser(walletId) {
-		return walletId.startsWith(this.userPrefix);
-	}
-	/**
-	* Transform wallet info to expose wallet name instead of internal ID
-	*/
-	transformWalletInfo(info) {
-		return {
-			...info,
-			name: this.extractName(info.walletId)
-		};
-	}
-	/**
-	* Create a new wallet (user-scoped)
-	*/
-	async createWallet(params) {
-		const result = await this.signer.createWallet({
-			walletId: this.scopedId(params.name),
-			version: params.version,
-			network: params.network
-		});
-		return this.transformWalletInfo(result);
-	}
-	/**
-	* Import a wallet from mnemonic (user-scoped)
-	* Note: Mnemonic is passed to signer and stored securely, never returned
-	*/
-	async importWallet(params) {
-		const result = await this.signer.importWallet({
-			walletId: this.scopedId(params.name),
-			mnemonic: params.mnemonic,
-			version: params.version,
-			network: params.network
-		});
-		return this.transformWalletInfo(result);
-	}
-	/**
-	* Get wallet by name (user-scoped)
-	* Returns null for both "not found" and "not owned" to prevent enumeration
-	*/
-	async getWallet(walletName) {
-		const walletId = this.scopedId(walletName);
-		const wallet = await this.signer.getWallet(walletId);
-		if (!wallet) return null;
-		if (!this.isOwnedByUser(wallet.walletId)) return null;
-		return this.transformWalletInfo(wallet);
-	}
-	/**
-	* List all wallets for this user
-	*/
-	async listWallets() {
-		const userIds = (await this.signer.listWalletIds()).filter((id) => this.isOwnedByUser(id));
-		return (await Promise.all(userIds.map(async (id) => {
-			const wallet = await this.signer.getWallet(id);
-			return wallet ? this.transformWalletInfo(wallet) : null;
-		}))).filter((w) => w !== null);
-	}
-	/**
-	* Delete a wallet (user-scoped)
-	* Returns false for both "not found" and "not owned"
-	*/
-	async deleteWallet(walletName) {
-		const walletId = this.scopedId(walletName);
-		const wallet = await this.signer.getWallet(walletId);
-		if (!wallet || !this.isOwnedByUser(wallet.walletId)) return false;
-		return this.signer.deleteWallet(walletId);
-	}
-	/**
-	* Sign a transaction (user-scoped)
-	* Verifies ownership before signing
-	*/
-	async signTransaction(walletName, unsignedBoc) {
-		const walletId = this.scopedId(walletName);
-		const wallet = await this.signer.getWallet(walletId);
-		if (!wallet || !this.isOwnedByUser(wallet.walletId)) throw new Error("Wallet not found");
-		return this.signer.signTransaction(walletId, unsignedBoc);
-	}
-	/**
-	* Sign a message (user-scoped)
-	* Verifies ownership before signing
-	*/
-	async signMessage(walletName, message) {
-		const walletId = this.scopedId(walletName);
-		const wallet = await this.signer.getWallet(walletId);
-		if (!wallet || !this.isOwnedByUser(wallet.walletId)) throw new Error("Wallet not found");
-		return this.signer.signMessage(walletId, message);
-	}
-	/**
-	* Get the underlying signer adapter.
-	* Use with caution - bypasses user isolation.
-	*/
-	getUnderlyingSigner() {
-		return this.signer;
-	}
-};
-
-//#endregion
-//#region src/core/LimitsManager.ts
-/** TON has 9 decimal places */
-const TON_DECIMALS$1 = 9;
-/**
-* LimitsManager enforces safety limits on transactions and wallet counts.
-*/
-var LimitsManager = class {
-	limits;
-	constructor(limits) {
-		this.limits = {
-			maxTransactionTon: limits?.maxTransactionTon ?? Infinity,
-			dailyLimitTon: limits?.dailyLimitTon ?? Infinity,
-			maxWalletsPerUser: limits?.maxWalletsPerUser ?? Infinity
-		};
-	}
-	/**
-	* Check if a transaction amount is within limits
-	*/
-	async checkTransactionLimit(storage, amountTon) {
-		if (amountTon > this.limits.maxTransactionTon) return {
-			allowed: false,
-			reason: `Transaction amount ${amountTon} TON exceeds maximum allowed ${this.limits.maxTransactionTon} TON per transaction`
-		};
-		const today = this.getTodayDate();
-		const usage = await this.getDailyUsage(storage, today);
-		const currentSpentTon = this.nanoToTon(usage.totalSpentNano);
-		if (currentSpentTon + amountTon > this.limits.dailyLimitTon) {
-			const remainingTon = Math.max(0, this.limits.dailyLimitTon - currentSpentTon);
-			return {
-				allowed: false,
-				reason: `Transaction would exceed daily limit of ${this.limits.dailyLimitTon} TON. Already spent: ${currentSpentTon.toFixed(2)} TON. Remaining: ${remainingTon.toFixed(2)} TON`
-			};
-		}
-		return { allowed: true };
-	}
-	/**
-	* Record a transaction for daily limit tracking
-	*/
-	async recordTransaction(storage, amountTon) {
-		const today = this.getTodayDate();
-		const usage = await this.getDailyUsage(storage, today);
-		const newUsage = {
-			date: today,
-			totalSpentNano: (BigInt(usage.totalSpentNano) + BigInt(this.tonToNano(amountTon))).toString()
-		};
-		await storage.set(`daily:${today}`, newUsage, 9e4);
-	}
-	/**
-	* Check if user can create another wallet
-	*/
-	async checkWalletCountLimit(currentWalletCount) {
-		if (currentWalletCount >= this.limits.maxWalletsPerUser) return {
-			allowed: false,
-			reason: `Maximum wallet limit of ${this.limits.maxWalletsPerUser} reached`
-		};
-		return { allowed: true };
-	}
-	/**
-	* Get the configured limits
-	*/
-	getLimits() {
-		return { ...this.limits };
-	}
-	/**
-	* Get today's date as ISO string (YYYY-MM-DD)
-	*/
-	getTodayDate() {
-		return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-	}
-	/**
-	* Get daily usage for a specific date
-	*/
-	async getDailyUsage(storage, date) {
-		return await storage.get(`daily:${date}`) ?? {
-			date,
-			totalSpentNano: "0"
-		};
-	}
-	/**
-	* Convert TON to nanoTON string
-	*/
-	tonToNano(ton) {
-		return BigInt(Math.floor(ton * Math.pow(10, TON_DECIMALS$1))).toString();
-	}
-	/**
-	* Convert nanoTON string to TON
-	*/
-	nanoToTon(nano) {
-		return Number(BigInt(nano)) / Math.pow(10, TON_DECIMALS$1);
-	}
-};
-
-//#endregion
-//#region src/core/PendingTransactionManager.ts
-/** Default pending transaction TTL in seconds (5 minutes) */
-const DEFAULT_PENDING_TTL_SECONDS = 300;
-/**
-* PendingTransactionManager handles the confirmation flow for transactions.
-*/
-var PendingTransactionManager = class {
-	ttlSeconds;
-	constructor(ttlSeconds = DEFAULT_PENDING_TTL_SECONDS) {
-		this.ttlSeconds = ttlSeconds;
-	}
-	/**
-	* Generate a unique transaction ID
-	*/
-	generateId() {
-		return `tx_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-	}
-	/**
-	* Create a pending transaction
-	*/
-	async createPending(storage, params) {
-		const id = this.generateId();
-		const now = /* @__PURE__ */ new Date();
-		const expiresAt = new Date(now.getTime() + this.ttlSeconds * 1e3);
-		const pending = {
-			id,
-			type: params.type,
-			walletName: params.walletName,
-			createdAt: now.toISOString(),
-			expiresAt: expiresAt.toISOString(),
-			description: params.description,
-			data: params.data
-		};
-		await storage.set(`pending:${id}`, pending, this.ttlSeconds);
-		return pending;
-	}
-	/**
-	* Get a pending transaction by ID
-	*/
-	async getPending(storage, transactionId) {
-		const pending = await storage.get(`pending:${transactionId}`);
-		if (!pending) return null;
-		if (new Date(pending.expiresAt) < /* @__PURE__ */ new Date()) {
-			await this.deletePending(storage, transactionId);
-			return null;
-		}
-		return pending;
-	}
-	/**
-	* List all pending transactions for the user
-	*/
-	async listPending(storage) {
-		const keys = await storage.list("pending:");
-		const now = /* @__PURE__ */ new Date();
-		const transactions = [];
-		for (const key of keys) {
-			const pending = await storage.get(key);
-			if (pending && new Date(pending.expiresAt) >= now) transactions.push(pending);
-		}
-		return transactions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-	}
-	/**
-	* Delete a pending transaction
-	*/
-	async deletePending(storage, transactionId) {
-		return storage.delete(`pending:${transactionId}`);
-	}
-	/**
-	* Mark a pending transaction as confirmed (delete it)
-	* The actual execution is handled by the caller
-	*/
-	async confirmPending(storage, transactionId) {
-		const pending = await this.getPending(storage, transactionId);
-		if (!pending) return null;
-		await this.deletePending(storage, transactionId);
-		return pending;
-	}
-	/**
-	* Cancel a pending transaction
-	*/
-	async cancelPending(storage, transactionId) {
-		if (!await this.getPending(storage, transactionId)) return false;
-		return this.deletePending(storage, transactionId);
-	}
-};
-
 //#endregion
 //#region src/services/McpWalletService.ts
 /**
@@ -88500,38 +88136,46 @@ var PendingTransactionManager = class {
 *
 */
 /**
-* McpWalletService - Multi-user wallet service with adapter support
+* McpWalletService - Simplified wallet service for MCP server
 *
-* This service wraps wallet operations with:
-* - User isolation via UserScopedSigner and UserScopedStorage
-* - Transaction limits via LimitsManager
-* - Confirmation flow via PendingTransactionManager
+* This service wraps a single Wallet instance for operations.
+* Wallet management (create/import/list/remove) is handled externally.
 *
-* Unlike the standalone WalletService, this service is designed for
-* multi-user environments like Telegram bots.
+* For multi-user scenarios (e.g., Telegram bots), use this service
+* with user-specific wallet instances.
 */
 /**
-* McpWalletService manages wallet operations for multi-user MCP deployments.
+* McpWalletService manages wallet operations for a single wallet.
 */
-var McpWalletService = class {
+var McpWalletService = class McpWalletService {
 	config;
-	limitsManager;
-	pendingManager;
+	wallet;
 	kit = null;
-	loadedWallets = /* @__PURE__ */ new Map();
 	constructor(config) {
 		this.config = config;
-		this.limitsManager = new LimitsManager(config.limits);
-		this.pendingManager = new PendingTransactionManager();
+		this.wallet = config.wallet;
+	}
+	static async create(config) {
+		const wallet = await wrapWalletInterface(config.wallet);
+		return new McpWalletService({
+			...config,
+			wallet
+		});
 	}
 	/**
-	* Get Network instance from network name
+	* Get wallet address
 	*/
-	getNetwork(networkName) {
-		return networkName === "mainnet" ? Network.mainnet() : Network.testnet();
+	getAddress() {
+		return this.wallet.getAddress();
 	}
 	/**
-	* Initialize TonWalletKit
+	* Get wallet network
+	*/
+	getNetwork() {
+		return this.wallet.getNetwork().chainId === Network.mainnet().chainId ? "mainnet" : "testnet";
+	}
+	/**
+	* Initialize TonWalletKit (for swap operations)
 	*/
 	async getKit() {
 		if (!this.kit) {
@@ -88554,169 +88198,27 @@ var McpWalletService = class {
 			});
 			await this.kit.waitForReady();
 			const omnistonProvider = new OmnistonSwapProvider({ defaultSlippageBps: 100 });
-			this.kit.swap.registerProvider("omniston", omnistonProvider);
-			this.kit.swap.setDefaultProvider("omniston");
+			this.kit.swap.registerProvider(omnistonProvider);
 		}
 		return this.kit;
 	}
 	/**
-	* Create user-scoped storage wrapper
-	*/
-	createUserStorage(userId) {
-		return new UserScopedStorage(this.config.storage, userId);
-	}
-	/**
-	* Create user-scoped signer wrapper
-	*/
-	createUserSigner(userId) {
-		return new UserScopedSigner(this.config.signer, userId);
-	}
-	/**
-	* Get limits manager
-	*/
-	getLimitsManager() {
-		return this.limitsManager;
-	}
-	/**
-	* Get pending transaction manager
-	*/
-	getPendingManager() {
-		return this.pendingManager;
-	}
-	/**
-	* Check if confirmation is required
-	*/
-	requiresConfirmation() {
-		return this.config.requireConfirmation ?? false;
-	}
-	/**
-	* Create a new wallet for a user
-	*/
-	async createWallet(userSigner, userStorage, name, version = "v5r1", networkName = this.config.defaultNetwork ?? "mainnet") {
-		const existingWallets = await userSigner.listWallets();
-		const limitCheck = await this.limitsManager.checkWalletCountLimit(existingWallets.length);
-		if (!limitCheck.allowed) throw new Error(limitCheck.reason);
-		const walletInfo = await userSigner.createWallet({
-			name,
-			version,
-			network: networkName
-		});
-		const metadata = {
-			name: walletInfo.name,
-			address: walletInfo.address,
-			network: walletInfo.network,
-			version: walletInfo.version,
-			createdAt: walletInfo.createdAt
-		};
-		await userStorage.set(`wallet:${name}`, metadata);
-		return {
-			name: walletInfo.name,
-			address: walletInfo.address,
-			network: walletInfo.network
-		};
-	}
-	/**
-	* Import a wallet for a user
-	*/
-	async importWallet(userSigner, userStorage, name, mnemonic, version = "v5r1", networkName = this.config.defaultNetwork ?? "mainnet") {
-		const existingWallets = await userSigner.listWallets();
-		const limitCheck = await this.limitsManager.checkWalletCountLimit(existingWallets.length);
-		if (!limitCheck.allowed) throw new Error(limitCheck.reason);
-		const walletInfo = await userSigner.importWallet({
-			name,
-			mnemonic,
-			version,
-			network: networkName
-		});
-		const metadata = {
-			name: walletInfo.name,
-			address: walletInfo.address,
-			network: walletInfo.network,
-			version: walletInfo.version,
-			createdAt: walletInfo.createdAt
-		};
-		await userStorage.set(`wallet:${name}`, metadata);
-		return {
-			name: walletInfo.name,
-			address: walletInfo.address,
-			network: walletInfo.network
-		};
-	}
-	/**
-	* List all wallets for a user
-	*/
-	async listWallets(userSigner) {
-		return (await userSigner.listWallets()).map((w) => ({
-			name: w.name,
-			address: w.address,
-			network: w.network,
-			version: w.version,
-			createdAt: w.createdAt
-		}));
-	}
-	/**
-	* Remove a wallet for a user
-	*/
-	async removeWallet(userSigner, userStorage, name) {
-		const deleted = await userSigner.deleteWallet(name);
-		if (deleted) await userStorage.delete(`wallet:${name}`);
-		return deleted;
-	}
-	/**
-	* Get or load a wallet for balance/transfer operations
-	*/
-	async getWalletForOperations(userSigner, name) {
-		const walletInfo = await userSigner.getWallet(name);
-		if (!walletInfo) throw new Error("Wallet not found");
-		const network = this.getNetwork(walletInfo.network);
-		const walletId = createWalletId(network, walletInfo.address);
-		if (this.loadedWallets.has(walletId)) return this.loadedWallets.get(walletId);
-		const signer = userSigner.getUnderlyingSigner();
-		if (typeof signer.getLoadedWallet === "function") {
-			const scopedId = `${userSigner.getUserId()}:${name}`;
-			const wallet = await signer.getLoadedWallet(scopedId);
-			this.loadedWallets.set(walletId, wallet);
-			return wallet;
-		}
-		if (typeof signer.getStoredWallet === "function") {
-			const scopedId = `${userSigner.getUserId()}:${name}`;
-			const storedWallet = signer.getStoredWallet(scopedId);
-			if (storedWallet) {
-				const kit = await this.getKit();
-				const signerInstance = await Signer.fromMnemonic(storedWallet.mnemonic, { type: "ton" });
-				const walletAdapter = storedWallet.version === "v5r1" ? await WalletV5R1Adapter.create(signerInstance, {
-					client: kit.getApiClient(network),
-					network
-				}) : await WalletV4R2Adapter.create(signerInstance, {
-					client: kit.getApiClient(network),
-					network
-				});
-				let wallet = await kit.addWallet(walletAdapter);
-				if (!wallet) wallet = kit.getWallet(walletId);
-				if (!wallet) throw new Error("Failed to load wallet");
-				this.loadedWallets.set(walletId, wallet);
-				return wallet;
-			}
-		}
-		throw new Error("Unable to load wallet for operations");
-	}
-	/**
 	* Get TON balance
 	*/
-	async getBalance(userSigner, walletName) {
-		return (await this.getWalletForOperations(userSigner, walletName)).getBalance();
+	async getBalance() {
+		return this.wallet.getBalance();
 	}
 	/**
 	* Get Jetton balance
 	*/
-	async getJettonBalance(userSigner, walletName, jettonAddress) {
-		return (await this.getWalletForOperations(userSigner, walletName)).getJettonBalance(jettonAddress);
+	async getJettonBalance(jettonAddress) {
+		return this.wallet.getJettonBalance(jettonAddress);
 	}
 	/**
 	* Get all Jettons
 	*/
-	async getJettons(userSigner, walletName) {
-		return (await (await this.getWalletForOperations(userSigner, walletName)).getJettons({ pagination: {
+	async getJettons() {
+		return (await this.wallet.getJettons({ pagination: {
 			limit: 100,
 			offset: 0
 		} })).jettons.map((j) => ({
@@ -88728,15 +88230,11 @@ var McpWalletService = class {
 		}));
 	}
 	/**
-	* Get transaction history for a wallet
-	*/
-	/**
-	* Get transaction history using events API (like demo wallet)
+	* Get transaction history using events API
 	*/
-	async getTransactions(userSigner, walletName, limit = 20) {
-		const wallet = await this.getWalletForOperations(userSigner, walletName);
-		const address = wallet.getAddress();
-		const response = await wallet.getClient().getEvents({
+	async getTransactions(limit = 20) {
+		const address = this.wallet.getAddress();
+		const response = await this.wallet.getClient().getEvents({
 			account: address,
 			limit
 		});
@@ -88781,49 +88279,16 @@ var McpWalletService = class {
 		return results;
 	}
 	/**
-	* Send TON (with optional confirmation flow)
-	*/
-	async sendTon(userSigner, userStorage, walletName, toAddress, amountNano, amountTon, comment) {
-		const limitCheck = await this.limitsManager.checkTransactionLimit(userStorage, parseFloat(amountTon));
-		if (!limitCheck.allowed) return {
-			success: false,
-			message: limitCheck.reason
-		};
-		if (this.requiresConfirmation()) {
-			const pending = await this.pendingManager.createPending(userStorage, {
-				type: "send_ton",
-				walletName,
-				description: `Send ${amountTon} TON to ${toAddress}${comment ? ` (${comment})` : ""}`,
-				data: {
-					type: "send_ton",
-					toAddress,
-					amountNano,
-					amountTon,
-					comment
-				}
-			});
-			return {
-				success: true,
-				message: `Transaction pending confirmation. ID: ${pending.id}`,
-				pendingTransactionId: pending.id
-			};
-		}
-		return this.executeTonTransfer(userSigner, userStorage, walletName, toAddress, amountNano, comment);
-	}
-	/**
-	* Execute TON transfer (internal)
+	* Send TON
 	*/
-	async executeTonTransfer(userSigner, userStorage, walletName, toAddress, amountNano, comment) {
+	async sendTon(toAddress, amountNano, comment) {
 		try {
-			const wallet = await this.getWalletForOperations(userSigner, walletName);
-			const tx = await wallet.createTransferTonTransaction({
+			const tx = await this.wallet.createTransferTonTransaction({
 				recipientAddress: toAddress,
 				transferAmount: amountNano,
 				comment
 			});
-			await wallet.sendTransaction(tx);
-			const amountTon = Number(BigInt(amountNano)) / 1e9;
-			await this.limitsManager.recordTransaction(userStorage, amountTon);
+			await this.wallet.sendTransaction(tx);
 			return {
 				success: true,
 				message: `Successfully sent ${amountNano} nanoTON to ${toAddress}`
@@ -88836,49 +88301,37 @@ var McpWalletService = class {
 		}
 	}
 	/**
-	* Send Jetton (with optional confirmation flow)
+	* Send Jetton
 	*/
-	async sendJetton(userSigner, userStorage, walletName, toAddress, jettonAddress, amountRaw, amountHuman, symbol, decimals, comment) {
-		if (this.requiresConfirmation()) {
-			const pending = await this.pendingManager.createPending(userStorage, {
-				type: "send_jetton",
-				walletName,
-				description: `Send ${amountHuman} ${symbol ?? "tokens"} to ${toAddress}${comment ? ` (${comment})` : ""}`,
-				data: {
-					type: "send_jetton",
-					toAddress,
-					jettonAddress,
-					amountRaw,
-					amountHuman,
-					symbol,
-					decimals,
-					comment
-				}
+	async sendJetton(toAddress, jettonAddress, amountRaw, comment) {
+		try {
+			const tx = await this.wallet.createTransferJettonTransaction({
+				recipientAddress: toAddress,
+				jettonAddress,
+				transferAmount: amountRaw,
+				comment
 			});
+			await this.wallet.sendTransaction(tx);
 			return {
 				success: true,
-				message: `Transaction pending confirmation. ID: ${pending.id}`,
-				pendingTransactionId: pending.id
+				message: `Successfully sent jettons to ${toAddress}`
+			};
+		} catch (error) {
+			return {
+				success: false,
+				message: error instanceof Error ? error.message : "Unknown error"
 			};
 		}
-		return this.executeJettonTransfer(userSigner, walletName, toAddress, jettonAddress, amountRaw, comment);
 	}
 	/**
-	* Execute Jetton transfer (internal)
+	* Send a raw transaction request directly
 	*/
-	async executeJettonTransfer(userSigner, walletName, toAddress, jettonAddress, amountRaw, comment) {
+	async sendRawTransaction(request) {
 		try {
-			const wallet = await this.getWalletForOperations(userSigner, walletName);
-			const tx = await wallet.createTransferJettonTransaction({
-				recipientAddress: toAddress,
-				jettonAddress,
-				transferAmount: amountRaw,
-				comment
-			});
-			await wallet.sendTransaction(tx);
+			await this.wallet.sendTransaction(request);
 			return {
 				success: true,
-				message: `Successfully sent jettons to ${toAddress}`
+				message: `Successfully sent transaction with ${request.messages.length} message(s)`
 			};
 		} catch (error) {
 			return {
@@ -88888,80 +88341,114 @@ var McpWalletService = class {
 		}
 	}
 	/**
-	* Get swap quote
+	* Get swap quote with transaction params ready to execute
 	*/
-	async getSwapQuote(userSigner, walletName, fromToken, toToken, amount, slippageBps) {
-		const walletInfo = await userSigner.getWallet(walletName);
-		if (!walletInfo) throw new Error("Wallet not found");
-		const network = this.getNetwork(walletInfo.network);
+	async getSwapQuote(fromToken, toToken, amount, slippageBps) {
+		const network = this.wallet.getNetwork();
 		const kit = await this.getKit();
 		const params = {
-			fromToken: fromToken === "TON" ? "TON" : fromToken,
-			toToken: toToken === "TON" ? "TON" : toToken,
-			amountFrom: amount,
+			fromToken: fromToken === "TON" ? { type: "ton" } : {
+				type: "jetton",
+				value: fromToken
+			},
+			toToken: toToken === "TON" ? { type: "ton" } : {
+				type: "jetton",
+				value: toToken
+			},
+			amount,
 			network,
 			slippageBps
 		};
 		const quote = await kit.swap.getQuote(params);
-		return {
+		const swapParams = {
 			quote,
-			fromToken: typeof quote.fromToken === "string" ? quote.fromToken : quote.fromToken,
-			toToken: typeof quote.toToken === "string" ? quote.toToken : quote.toToken,
+			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.provider,
-			expiresAt: quote.expiresAt
+			provider: quote.providerId,
+			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
+			}
 		};
 	}
 	/**
-	* Execute swap (with optional confirmation flow)
+	* Get all NFTs
 	*/
-	async executeSwap(userSigner, userStorage, walletName, quote) {
-		if (this.requiresConfirmation()) {
-			const pending = await this.pendingManager.createPending(userStorage, {
-				type: "swap",
-				walletName,
-				description: `Swap ${quote.fromAmount} ${quote.fromToken} for ${quote.toAmount} ${quote.toToken}`,
-				data: {
-					type: "swap",
-					fromToken: String(quote.fromToken),
-					toToken: String(quote.toToken),
-					fromAmount: quote.fromAmount,
-					toAmount: quote.toAmount,
-					minReceived: quote.minReceived,
-					provider: quote.provider,
-					quoteJson: JSON.stringify(quote)
-				}
-			});
-			return {
-				success: true,
-				message: `Swap pending confirmation. ID: ${pending.id}`,
-				pendingTransactionId: pending.id
-			};
-		}
-		return this.executeSwapInternal(userSigner, walletName, quote);
+	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
+		}));
 	}
 	/**
-	* Execute swap (internal)
+	* Get a specific NFT by address
 	*/
-	async executeSwapInternal(userSigner, walletName, quote) {
+	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
+		};
+	}
+	/**
+	* Send NFT
+	*/
+	async sendNft(nftAddress, toAddress, comment) {
 		try {
-			const [wallet, kit, walletInfo] = await Promise.all([
-				this.getWalletForOperations(userSigner, walletName),
-				this.getKit(),
-				userSigner.getWallet(walletName)
-			]);
-			if (!walletInfo) throw new Error("Wallet not found");
-			const params = {
-				quote,
-				userAddress: walletInfo.address
-			};
-			const tx = await kit.swap.buildSwapTransaction(params);
-			await wallet.sendTransaction(tx);
+			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 {
@@ -88971,52 +88458,11 @@ var McpWalletService = class {
 		}
 	}
 	/**
-	* Confirm a pending transaction
-	*/
-	async confirmTransaction(userSigner, userStorage, transactionId) {
-		const pending = await this.pendingManager.confirmPending(userStorage, transactionId);
-		if (!pending) return {
-			success: false,
-			message: "Transaction not found or expired"
-		};
-		switch (pending.data.type) {
-			case "send_ton": {
-				const data = pending.data;
-				return this.executeTonTransfer(userSigner, userStorage, pending.walletName, data.toAddress, data.amountNano, data.comment);
-			}
-			case "send_jetton": {
-				const data = pending.data;
-				return this.executeJettonTransfer(userSigner, pending.walletName, data.toAddress, data.jettonAddress, data.amountRaw, data.comment);
-			}
-			case "swap": {
-				const data = pending.data;
-				const quote = JSON.parse(data.quoteJson);
-				return this.executeSwapInternal(userSigner, pending.walletName, quote);
-			}
-			default: return {
-				success: false,
-				message: "Unknown transaction type"
-			};
-		}
-	}
-	/**
-	* Cancel a pending transaction
-	*/
-	async cancelTransaction(userStorage, transactionId) {
-		return this.pendingManager.cancelPending(userStorage, transactionId);
-	}
-	/**
-	* List pending transactions
-	*/
-	async listPendingTransactions(userStorage) {
-		return this.pendingManager.listPending(userStorage);
-	}
-	/**
 	* Resolve contact name to address
 	*/
-	async resolveContact(userId, name) {
+	async resolveContact(name) {
 		if (!this.config.contacts) return null;
-		return this.config.contacts.resolve(userId, name);
+		return this.config.contacts.resolve("default", name);
 	}
 	/**
 	* Close and cleanup
@@ -89026,12 +88472,11 @@ var McpWalletService = class {
 			await this.kit.close();
 			this.kit = null;
 		}
-		this.loadedWallets.clear();
 	}
 };
 
 //#endregion
-//#region src/tools/mcp-tools.ts
+//#region src/tools/balance-tools.ts
 /**
 * Copyright (c) TonTech.
 *
@@ -89039,185 +88484,24 @@ var McpWalletService = class {
 * LICENSE file in the root directory of this source tree.
 *
 */
-/**
-* MCP tools for multi-user deployments with authentication
-*
-* These tools wrap the McpWalletService with user isolation.
-* They are used by the createTonWalletMCP factory.
-*/
-/**
-* Converts a human-readable amount to raw units.
-*/
-function toRawAmount(amount, decimals) {
-	const [intPart, fracPart = ""] = amount.split(".");
-	return (intPart + fracPart.padEnd(decimals, "0").slice(0, decimals)).replace(/^0+/, "") || "0";
-}
-const TON_DECIMALS = 9;
-const createWalletSchema = z.object({
-	name: z.string().min(1).describe("Unique name for the wallet"),
-	version: z.enum(["v5r1", "v4r2"]).optional().describe("Wallet version (v5r1 recommended, v4r2 for legacy compatibility). Defaults to v5r1."),
-	network: z.enum(["mainnet", "testnet"]).optional().describe("Network to create the wallet on. Defaults to the server configured network.")
-});
-const importWalletSchema = z.object({
-	name: z.string().min(1).describe("Unique name for the wallet"),
-	mnemonic: z.string().describe("24-word mnemonic phrase separated by spaces"),
-	version: z.enum(["v5r1", "v4r2"]).optional().describe("Wallet version (v5r1 recommended, v4r2 for legacy compatibility). Defaults to v5r1."),
-	network: z.enum(["mainnet", "testnet"]).optional().describe("Network to import the wallet on. Defaults to the server configured network.")
-});
-const removeWalletSchema = z.object({ name: z.string().min(1).describe("Name of the wallet to remove") });
-function createMcpWalletTools(_walletService, wrapHandler) {
-	return {
-		create_wallet: {
-			description: "Create a new TON wallet. The wallet is created securely and you will receive the address. No seed phrase is exposed.",
-			inputSchema: createWalletSchema,
-			handler: wrapHandler(async (args, userId, service) => {
-				const userSigner = service.createUserSigner(userId);
-				const userStorage = service.createUserStorage(userId);
-				try {
-					const result = await service.createWallet(userSigner, userStorage, args.name, args.version, args.network);
-					return { content: [{
-						type: "text",
-						text: JSON.stringify({
-							success: true,
-							wallet: {
-								name: result.name,
-								address: result.address,
-								network: result.network
-							}
-						}, null, 2)
-					}] };
-				} catch (error) {
-					return {
-						content: [{
-							type: "text",
-							text: JSON.stringify({
-								success: false,
-								error: error instanceof Error ? error.message : "Unknown error"
-							})
-						}],
-						isError: true
-					};
-				}
-			})
-		},
-		import_wallet: {
-			description: "Import an existing TON wallet using a 24-word mnemonic phrase. The mnemonic is stored securely and never exposed.",
-			inputSchema: importWalletSchema,
-			handler: wrapHandler(async (args, userId, service) => {
-				const mnemonicWords = args.mnemonic.trim().split(/\s+/);
-				if (mnemonicWords.length !== 24) return {
-					content: [{
-						type: "text",
-						text: JSON.stringify({
-							success: false,
-							error: `Invalid mnemonic: expected 24 words, got ${mnemonicWords.length}`
-						})
-					}],
-					isError: true
-				};
-				const userSigner = service.createUserSigner(userId);
-				const userStorage = service.createUserStorage(userId);
-				try {
-					const result = await service.importWallet(userSigner, userStorage, args.name, mnemonicWords, args.version, args.network);
-					return { content: [{
-						type: "text",
-						text: JSON.stringify({
-							success: true,
-							wallet: {
-								name: result.name,
-								address: result.address,
-								network: result.network
-							}
-						}, null, 2)
-					}] };
-				} catch (error) {
-					return {
-						content: [{
-							type: "text",
-							text: JSON.stringify({
-								success: false,
-								error: error instanceof Error ? error.message : "Unknown error"
-							})
-						}],
-						isError: true
-					};
-				}
-			})
-		},
-		list_wallets: {
-			description: "List all your stored TON wallets with their addresses and metadata.",
-			inputSchema: z.object({}),
-			handler: wrapHandler(async (_args, userId, service) => {
-				const userSigner = service.createUserSigner(userId);
-				const wallets = await service.listWallets(userSigner);
-				return { content: [{
-					type: "text",
-					text: JSON.stringify({
-						success: true,
-						wallets: wallets.map((w) => ({
-							name: w.name,
-							address: w.address,
-							network: w.network,
-							version: w.version,
-							createdAt: w.createdAt
-						})),
-						count: wallets.length
-					}, null, 2)
-				}] };
-			})
-		},
-		remove_wallet: {
-			description: "Remove a wallet from storage. This action cannot be undone!",
-			inputSchema: removeWalletSchema,
-			handler: wrapHandler(async (args, userId, service) => {
-				const userSigner = service.createUserSigner(userId);
-				const userStorage = service.createUserStorage(userId);
-				if (!await service.removeWallet(userSigner, userStorage, args.name)) return {
-					content: [{
-						type: "text",
-						text: JSON.stringify({
-							success: false,
-							error: "Wallet not found"
-						})
-					}],
-					isError: true
-				};
-				return { content: [{
-					type: "text",
-					text: JSON.stringify({
-						success: true,
-						message: `Wallet "${args.name}" has been removed`
-					})
-				}] };
-			})
-		}
-	};
-}
-const getBalanceSchema = z.object({ wallet: z.string().min(1).describe("Name of the wallet to check balance") });
-const getJettonBalanceSchema = z.object({
-	wallet: z.string().min(1).describe("Name of the wallet"),
-	jettonAddress: z.string().min(1).describe("Jetton master contract address")
-});
-const getJettonsSchema = z.object({ wallet: z.string().min(1).describe("Name of the wallet") });
-const getTransactionsSchema = z.object({
-	wallet: z.string().min(1).describe("Name of the wallet to get transactions for"),
-	limit: z.number().min(1).max(100).optional().describe("Maximum number of transactions to return (default: 20, max: 100)")
-});
-function createMcpBalanceTools(_walletService, wrapHandler) {
+const getBalanceSchema = z.object({});
+const getJettonBalanceSchema = z.object({ jettonAddress: z.string().min(1).describe("Jetton master contract address") });
+const getJettonsSchema = z.object({});
+const getTransactionsSchema = z.object({ limit: z.number().min(1).max(100).optional().describe("Maximum number of transactions to return (default: 20, max: 100)") });
+function createMcpBalanceTools(service) {
 	return {
 		get_balance: {
-			description: "Get the TON balance of a wallet. Returns both human-readable and raw (nanoTON) amounts.",
+			description: "Get the TON balance of the wallet. Returns both human-readable and raw (nanoTON) amounts.",
 			inputSchema: getBalanceSchema,
-			handler: wrapHandler(async (args, userId, service) => {
-				const userSigner = service.createUserSigner(userId);
+			handler: async () => {
 				try {
-					const balance = await service.getBalance(userSigner, args.wallet);
+					const balance = await service.getBalance();
 					const balanceTon = Number(BigInt(balance)) / 1e9;
 					return { content: [{
 						type: "text",
 						text: JSON.stringify({
 							success: true,
-							wallet: args.wallet,
+							address: service.getAddress(),
 							balance: `${balanceTon} TON`,
 							balanceNano: balance
 						}, null, 2)
@@ -89234,20 +88518,18 @@ function createMcpBalanceTools(_walletService, wrapHandler) {
 						isError: true
 					};
 				}
-			})
+			}
 		},
 		get_jetton_balance: {
-			description: "Get the balance of a specific Jetton (token) in a wallet.",
+			description: "Get the balance of a specific Jetton (token) in the wallet.",
 			inputSchema: getJettonBalanceSchema,
-			handler: wrapHandler(async (args, userId, service) => {
-				const userSigner = service.createUserSigner(userId);
+			handler: async (args) => {
 				try {
-					const balance = await service.getJettonBalance(userSigner, args.wallet, args.jettonAddress);
+					const balance = await service.getJettonBalance(args.jettonAddress);
 					return { content: [{
 						type: "text",
 						text: JSON.stringify({
 							success: true,
-							wallet: args.wallet,
 							jettonAddress: args.jettonAddress,
 							balance
 						}, null, 2)
@@ -89264,20 +88546,18 @@ function createMcpBalanceTools(_walletService, wrapHandler) {
 						isError: true
 					};
 				}
-			})
+			}
 		},
 		get_jettons: {
-			description: "List all Jettons (tokens) in a wallet with their balances and metadata.",
+			description: "List all Jettons (tokens) in the wallet with their balances and metadata.",
 			inputSchema: getJettonsSchema,
-			handler: wrapHandler(async (args, userId, service) => {
-				const userSigner = service.createUserSigner(userId);
+			handler: async () => {
 				try {
-					const jettons = await service.getJettons(userSigner, args.wallet);
+					const jettons = await service.getJettons();
 					return { content: [{
 						type: "text",
 						text: JSON.stringify({
 							success: true,
-							wallet: args.wallet,
 							jettons,
 							count: jettons.length
 						}, null, 2)
@@ -89294,20 +88574,18 @@ function createMcpBalanceTools(_walletService, wrapHandler) {
 						isError: true
 					};
 				}
-			})
+			}
 		},
 		get_transactions: {
-			description: "Get recent transaction history for a wallet. Returns events with actions like TON transfers, Jetton transfers, swaps, and more.",
+			description: "Get recent transaction history for the wallet. Returns events with actions like TON transfers, Jetton transfers, swaps, and more.",
 			inputSchema: getTransactionsSchema,
-			handler: wrapHandler(async (args, userId, service) => {
-				const userSigner = service.createUserSigner(userId);
+			handler: async (args) => {
 				try {
-					const transactions = await service.getTransactions(userSigner, args.wallet, args.limit ?? 20);
+					const transactions = await service.getTransactions(args.limit ?? 20);
 					return { content: [{
 						type: "text",
 						text: JSON.stringify({
 							success: true,
-							wallet: args.wallet,
 							transactions: transactions.map((tx) => ({
 								eventId: tx.eventId,
 								timestamp: tx.timestamp,
@@ -89355,33 +88633,61 @@ function createMcpBalanceTools(_walletService, wrapHandler) {
 						isError: true
 					};
 				}
-			})
+			}
 		}
 	};
 }
+
+//#endregion
+//#region src/tools/types.ts
+/**
+* Converts a human-readable amount to raw units.
+*/
+function toRawAmount(amount, decimals) {
+	const [intPart, fracPart = ""] = amount.split(".");
+	return (intPart + fracPart.padEnd(decimals, "0").slice(0, decimals)).replace(/^0+/, "") || "0";
+}
+const TON_DECIMALS = 9;
+
+//#endregion
+//#region src/tools/transfer-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 sendTonSchema = z.object({
-	wallet: z.string().min(1).describe("Name of the wallet to send from"),
 	toAddress: z.string().min(1).describe("Recipient TON address"),
 	amount: z.string().min(1).describe("Amount of TON to send (e.g., \"1.5\" for 1.5 TON)"),
 	comment: z.string().optional().describe("Optional comment/memo for the transaction")
 });
 const sendJettonSchema = z.object({
-	wallet: z.string().min(1).describe("Name of the wallet to send from"),
 	toAddress: z.string().min(1).describe("Recipient TON address"),
 	jettonAddress: z.string().min(1).describe("Jetton master contract address"),
 	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")
 });
-function createMcpTransferTools(_walletService, wrapHandler) {
+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: {
-			description: "Send TON from a wallet to an address. Amount is in TON (e.g., \"1.5\" means 1.5 TON). May require confirmation if enabled.",
+			description: "Send TON from the wallet to an address. Amount is in TON (e.g., \"1.5\" means 1.5 TON).",
 			inputSchema: sendTonSchema,
-			handler: wrapHandler(async (args, userId, service) => {
-				const userSigner = service.createUserSigner(userId);
-				const userStorage = service.createUserStorage(userId);
+			handler: async (args) => {
 				const rawAmount = toRawAmount(args.amount, TON_DECIMALS);
-				const result = await service.sendTon(userSigner, userStorage, args.wallet, args.toAddress, rawAmount, args.amount, args.comment);
+				const result = await service.sendTon(args.toAddress, rawAmount, args.comment);
 				if (!result.success) return {
 					content: [{
 						type: "text",
@@ -89398,26 +88704,22 @@ function createMcpTransferTools(_walletService, wrapHandler) {
 						success: true,
 						message: result.message,
 						details: {
-							from: args.wallet,
 							to: args.toAddress,
 							amount: `${args.amount} TON`,
-							comment: args.comment || null,
-							pendingTransactionId: result.pendingTransactionId || null
+							comment: args.comment || null
 						}
 					}, null, 2)
 				}] };
-			})
+			}
 		},
 		send_jetton: {
-			description: "Send Jettons (tokens) from a wallet to an address. Amount is in human-readable format. May require confirmation if enabled.",
+			description: "Send Jettons (tokens) from the wallet to an address. Amount is in human-readable format.",
 			inputSchema: sendJettonSchema,
-			handler: wrapHandler(async (args, userId, service) => {
-				const userSigner = service.createUserSigner(userId);
-				const userStorage = service.createUserStorage(userId);
+			handler: async (args) => {
 				let decimals;
 				let symbol;
 				try {
-					const jetton = (await service.getJettons(userSigner, args.wallet)).find((j) => j.address.toLowerCase() === args.jettonAddress.toLowerCase());
+					const jetton = (await service.getJettons()).find((j) => j.address.toLowerCase() === args.jettonAddress.toLowerCase());
 					if (jetton) {
 						decimals = jetton.decimals;
 						symbol = jetton.symbol;
@@ -89445,7 +88747,7 @@ function createMcpTransferTools(_walletService, wrapHandler) {
 					isError: true
 				};
 				const rawAmount = toRawAmount(args.amount, decimals);
-				const result = await service.sendJetton(userSigner, userStorage, args.wallet, args.toAddress, args.jettonAddress, rawAmount, args.amount, symbol, decimals, args.comment);
+				const result = await service.sendJetton(args.toAddress, args.jettonAddress, rawAmount, args.comment);
 				if (!result.success) return {
 					content: [{
 						type: "text",
@@ -89462,68 +88764,209 @@ function createMcpTransferTools(_walletService, wrapHandler) {
 						success: true,
 						message: result.message,
 						details: {
-							from: args.wallet,
 							to: args.toAddress,
 							jettonAddress: args.jettonAddress,
 							amount: `${args.amount} ${symbol || "tokens"}`,
-							comment: args.comment || null,
-							pendingTransactionId: result.pendingTransactionId || null
+							comment: args.comment || null
 						}
 					}, 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)
+				}] };
+			}
 		}
 	};
 }
-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);
-}
+
+//#endregion
+//#region src/tools/swap-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 getSwapQuoteSchema = z.object({
-	wallet: z.string().min(1).describe("Name of the wallet to swap from"),
 	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({
-	wallet: z.string().min(1).describe("Name of the wallet to execute swap from"),
-	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 createMcpSwapTools(_walletService, wrapHandler) {
+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,
-			handler: wrapHandler(async (args, userId, service) => {
-				const userSigner = service.createUserSigner(userId);
+		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(userSigner, args.wallet, 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,
-						userId
-					});
+					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) {
@@ -89538,156 +88981,87 @@ function createMcpSwapTools(_walletService, wrapHandler) {
 						isError: true
 					};
 				}
-			})
+			}
 		},
-		execute_swap: {
-			description: "Execute a token swap using a quote. May require confirmation if enabled.",
-			inputSchema: executeSwapSchema,
-			handler: wrapHandler(async (args, userId, service) => {
-				const userSigner = service.createUserSigner(userId);
-				const userStorage = service.createUserStorage(userId);
-				cleanExpiredQuotes();
-				const cachedQuote = quoteCache.get(args.quoteId);
-				if (!cachedQuote) return {
-					content: [{
-						type: "text",
-						text: JSON.stringify({
-							success: false,
-							error: "Quote not found or expired. Please get a new quote."
-						})
-					}],
-					isError: true
-				};
-				if (cachedQuote.userId !== userId) return {
-					content: [{
+		get_nft: {
+			description: "Get detailed information about a specific NFT by its address.",
+			inputSchema: getNftSchema,
+			handler: async (args) => {
+				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(userSigner, userStorage, args.wallet, cachedQuote.quote);
-				quoteCache.delete(args.quoteId);
-				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: {
-							fromToken: cachedQuote.quote.fromToken,
-							toToken: cachedQuote.quote.toToken,
-							fromAmount: cachedQuote.quote.fromAmount,
-							toAmount: cachedQuote.quote.toAmount,
-							provider: cachedQuote.quote.provider,
-							pendingTransactionId: result.pendingTransactionId || null
-						}
-					}, null, 2)
-				}] };
-			})
-		}
-	};
-}
-const confirmTransactionSchema = z.object({ transactionId: z.string().min(1).describe("ID of the pending transaction to confirm") });
-const cancelTransactionSchema = z.object({ transactionId: z.string().min(1).describe("ID of the pending transaction to cancel") });
-function createMcpPendingTools(_walletService, wrapHandler) {
-	return {
-		confirm_transaction: {
-			description: "Confirm and execute a pending transaction.",
-			inputSchema: confirmTransactionSchema,
-			handler: wrapHandler(async (args, userId, service) => {
-				const userSigner = service.createUserSigner(userId);
-				const userStorage = service.createUserStorage(userId);
-				const result = await service.confirmTransaction(userSigner, userStorage, args.transactionId);
-				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
-					}, null, 2)
-				}] };
-			})
-		},
-		cancel_transaction: {
-			description: "Cancel a pending transaction.",
-			inputSchema: cancelTransactionSchema,
-			handler: wrapHandler(async (args, userId, service) => {
-				const userStorage = service.createUserStorage(userId);
-				if (!await service.cancelTransaction(userStorage, args.transactionId)) return {
-					content: [{
-						type: "text",
-						text: JSON.stringify({
-							success: false,
-							error: "Transaction not found or already processed"
-						})
-					}],
-					isError: true
-				};
-				return { content: [{
-					type: "text",
-					text: JSON.stringify({
-						success: true,
-						message: "Transaction cancelled"
-					})
-				}] };
-			})
+			}
 		},
-		list_pending_transactions: {
-			description: "List all pending transactions awaiting confirmation.",
-			inputSchema: z.object({}),
-			handler: wrapHandler(async (_args, userId, service) => {
-				const userStorage = service.createUserStorage(userId);
-				const pending = await service.listPendingTransactions(userStorage);
-				return { content: [{
-					type: "text",
-					text: JSON.stringify({
-						success: true,
-						transactions: pending.map((tx) => ({
-							id: tx.id,
-							type: tx.type,
-							wallet: tx.walletName,
-							description: tx.description,
-							createdAt: tx.createdAt,
-							expiresAt: tx.expiresAt
-						})),
-						count: pending.length
-					}, null, 2)
-				}] };
-			})
+		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
+					};
+				}
+			}
 		}
 	};
 }
@@ -89709,403 +89083,63 @@ const SERVER_VERSION = "0.1.0";
 /**
 * Create a configured TON Wallet MCP server
 *
-* @param config - Configuration with adapters and limits
+* @param config - Configuration with wallet instance
 * @returns Configured McpServer instance
 *
 * @example
 * ```typescript
-* import { createTonWalletMCP, InMemoryStorageAdapter, LocalSignerAdapter } from '@ton/mcp';
+* import { createTonWalletMCP } from '@ton/mcp';
+* import { Signer, WalletV5R1Adapter, TonWalletKit, Network } from '@ton/walletkit';
 *
-* const server = createTonWalletMCP({
-*   storage: new InMemoryStorageAdapter(),
-*   signer: new LocalSignerAdapter(),
-*   userContext: {
-*     getUserId: async (ctx) => ctx.headers?.['x-user-id'] ?? null,
-*   },
-*   limits: {
-*     maxTransactionTon: 100,
-*     dailyLimitTon: 1000,
-*     maxWalletsPerUser: 10,
-*   },
-*   requireConfirmation: true,
+* // Create wallet adapter
+* const kit = new TonWalletKit({ ... });
+* const signer = await Signer.fromMnemonic(mnemonic, { type: 'ton' });
+* const walletAdapter = await WalletV5R1Adapter.create(signer, {
+*   client: kit.getApiClient(Network.mainnet()),
+*   network: Network.mainnet(),
 * });
+* const wallet = await kit.addWallet(walletAdapter);
+*
+* // Create MCP server
+* const server = createTonWalletMCP({ wallet });
 * ```
 */
-function createTonWalletMCP(config) {
-	const walletService = new McpWalletService({
-		storage: config.storage,
-		signer: config.signer,
+async function createTonWalletMCP(config) {
+	const walletService = await McpWalletService.create({
+		wallet: config.wallet,
 		contacts: config.contacts,
-		defaultNetwork: config.network,
-		limits: config.limits,
-		requireConfirmation: config.requireConfirmation
+		networks: config.networks
 	});
 	const server = new McpServer({
 		name: SERVER_NAME$1,
 		version: SERVER_VERSION
 	});
-	const authenticateUser = async (requestContext) => {
-		const userId = await config.userContext.getUserId(requestContext);
-		if (!userId) throw new Error("User authentication required");
-		return userId;
-	};
-	const createAuthenticatedHandler = (handler) => {
-		return async (args, extra) => {
-			const extraObj = extra;
-			return handler(args, await authenticateUser({
-				headers: extraObj?.headers,
-				metadata: extraObj?.meta
-			}), walletService);
-		};
-	};
-	const walletTools = createMcpWalletTools(walletService, createAuthenticatedHandler);
-	const balanceTools = createMcpBalanceTools(walletService, createAuthenticatedHandler);
-	const transferTools = createMcpTransferTools(walletService, createAuthenticatedHandler);
-	const swapTools = createMcpSwapTools(walletService, createAuthenticatedHandler);
-	const pendingTools = createMcpPendingTools(walletService, createAuthenticatedHandler);
+	const balanceTools = createMcpBalanceTools(walletService);
+	const transferTools = createMcpTransferTools(walletService);
+	const swapTools = createMcpSwapTools(walletService);
+	const knownJettonsTools = createMcpKnownJettonsTools();
+	const nftTools = createMcpNftTools(walletService);
 	const registerTool = (name, tool) => {
 		server.registerTool(name, {
 			description: tool.description,
 			inputSchema: tool.inputSchema
 		}, tool.handler);
 	};
-	registerTool("create_wallet", walletTools.create_wallet);
-	registerTool("import_wallet", walletTools.import_wallet);
-	registerTool("list_wallets", walletTools.list_wallets);
-	registerTool("remove_wallet", walletTools.remove_wallet);
 	registerTool("get_balance", balanceTools.get_balance);
 	registerTool("get_jetton_balance", balanceTools.get_jetton_balance);
 	registerTool("get_jettons", balanceTools.get_jettons);
 	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);
-	if (config.requireConfirmation) {
-		registerTool("confirm_transaction", pendingTools.confirm_transaction);
-		registerTool("cancel_transaction", pendingTools.cancel_transaction);
-		registerTool("list_pending_transactions", pendingTools.list_pending_transactions);
-	}
+	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);
 	return server;
 }
 
-//#endregion
-//#region src/adapters/InMemoryStorageAdapter.ts
-/**
-* In-memory storage adapter for testing and development.
-* Data is not persistent and will be lost on process restart.
-*/
-var InMemoryStorageAdapter = class {
-	data = /* @__PURE__ */ new Map();
-	timers = /* @__PURE__ */ new Map();
-	/**
-	* Get a value by key
-	*/
-	async get(key) {
-		return this.data.get(key) ?? null;
-	}
-	/**
-	* Set a value with optional TTL
-	*/
-	async set(key, value, ttlSeconds) {
-		const existingTimer = this.timers.get(key);
-		if (existingTimer) {
-			clearTimeout(existingTimer);
-			this.timers.delete(key);
-		}
-		this.data.set(key, value);
-		if (ttlSeconds !== void 0 && ttlSeconds > 0) {
-			const timer = setTimeout(() => {
-				this.data.delete(key);
-				this.timers.delete(key);
-			}, ttlSeconds * 1e3);
-			this.timers.set(key, timer);
-		}
-	}
-	/**
-	* Delete a key
-	*/
-	async delete(key) {
-		const timer = this.timers.get(key);
-		if (timer) {
-			clearTimeout(timer);
-			this.timers.delete(key);
-		}
-		return this.data.delete(key);
-	}
-	/**
-	* List keys matching prefix
-	*/
-	async list(prefix) {
-		const keys = [];
-		for (const key of this.data.keys()) if (key.startsWith(prefix)) keys.push(key);
-		return keys;
-	}
-	/**
-	* Clear all data (useful for testing)
-	*/
-	clear() {
-		for (const timer of this.timers.values()) clearTimeout(timer);
-		this.timers.clear();
-		this.data.clear();
-	}
-	/**
-	* Get the number of stored items (useful for testing)
-	*/
-	size() {
-		return this.data.size;
-	}
-};
-
-//#endregion
-//#region src/adapters/LocalSignerAdapter.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.
-*
-*/
-/**
-* LocalSignerAdapter - Local signer using @ton/walletkit
-*
-* This adapter uses TonWalletKit for wallet operations.
-* For production use with encryption, extend this class or implement
-* your own ISignerAdapter with proper key encryption.
-*
-* Note: This is a reference implementation. For production custody,
-* consider using HSM, KMS, or Vault-based signers.
-*/
-/**
-* Local signer adapter using TonWalletKit.
-*
-* This implementation stores mnemonics in memory. For production use,
-* implement encryption or use a secure key management system.
-*/
-var LocalSignerAdapter = class {
-	wallets = /* @__PURE__ */ new Map();
-	kit = null;
-	loadedWallets = /* @__PURE__ */ new Map();
-	/**
-	* Get Network instance from network name
-	*/
-	getNetwork(networkName) {
-		return networkName === "mainnet" ? Network.mainnet() : Network.testnet();
-	}
-	/**
-	* Initialize or get TonWalletKit instance
-	*/
-	async getKit() {
-		if (!this.kit) {
-			this.kit = new TonWalletKit({
-				networks: {
-					[Network.mainnet().chainId]: {},
-					[Network.testnet().chainId]: {}
-				},
-				storage: new MemoryStorageAdapter()
-			});
-			await this.kit.waitForReady();
-		}
-		return this.kit;
-	}
-	/**
-	* Create wallet adapter from mnemonic
-	*/
-	async createWalletAdapter(mnemonic, version, network) {
-		const kit = await this.getKit();
-		const signer = await Signer.fromMnemonic(mnemonic, { type: "ton" });
-		return {
-			adapter: version === "v5r1" ? await WalletV5R1Adapter.create(signer, {
-				client: kit.getApiClient(network),
-				network
-			}) : await WalletV4R2Adapter.create(signer, {
-				client: kit.getApiClient(network),
-				network
-			}),
-			publicKey: Buffer.from(signer.publicKey).toString("hex")
-		};
-	}
-	/**
-	* Create a new wallet with generated mnemonic
-	*/
-	async createWallet(params) {
-		const { walletId, version, network: networkName } = params;
-		if (this.wallets.has(walletId)) throw new Error(`Wallet "${walletId}" already exists`);
-		const network = this.getNetwork(networkName);
-		const mnemonic = await CreateTonMnemonic();
-		const { adapter, publicKey } = await this.createWalletAdapter(mnemonic, version, network);
-		const address = adapter.getAddress();
-		const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-		const storedWallet = {
-			walletId,
-			mnemonic,
-			publicKey,
-			address,
-			network: networkName,
-			version,
-			createdAt
-		};
-		this.wallets.set(walletId, storedWallet);
-		const wallet = await (await this.getKit()).addWallet(adapter);
-		if (wallet) this.loadedWallets.set(walletId, wallet);
-		return {
-			walletId,
-			publicKey,
-			address,
-			network: networkName,
-			version,
-			createdAt
-		};
-	}
-	/**
-	* Import a wallet from mnemonic
-	*/
-	async importWallet(params) {
-		const { walletId, mnemonic, version, network: networkName } = params;
-		if (this.wallets.has(walletId)) throw new Error(`Wallet "${walletId}" already exists`);
-		if (mnemonic.length !== 24) throw new Error(`Invalid mnemonic: expected 24 words, got ${mnemonic.length}`);
-		const network = this.getNetwork(networkName);
-		const { adapter, publicKey } = await this.createWalletAdapter(mnemonic, version, network);
-		const address = adapter.getAddress();
-		const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-		const storedWallet = {
-			walletId,
-			mnemonic,
-			publicKey,
-			address,
-			network: networkName,
-			version,
-			createdAt
-		};
-		this.wallets.set(walletId, storedWallet);
-		const wallet = await (await this.getKit()).addWallet(adapter);
-		if (wallet) this.loadedWallets.set(walletId, wallet);
-		return {
-			walletId,
-			publicKey,
-			address,
-			network: networkName,
-			version,
-			createdAt
-		};
-	}
-	/**
-	* Get wallet info by ID
-	*/
-	async getWallet(walletId) {
-		const stored = this.wallets.get(walletId);
-		if (!stored) return null;
-		return {
-			walletId: stored.walletId,
-			publicKey: stored.publicKey,
-			address: stored.address,
-			network: stored.network,
-			version: stored.version,
-			createdAt: stored.createdAt
-		};
-	}
-	/**
-	* List all wallet IDs
-	*/
-	async listWalletIds() {
-		return Array.from(this.wallets.keys());
-	}
-	/**
-	* Delete a wallet
-	*/
-	async deleteWallet(walletId) {
-		if (!this.wallets.get(walletId)) return false;
-		this.loadedWallets.delete(walletId);
-		return this.wallets.delete(walletId);
-	}
-	/**
-	* Get or load a wallet for signing
-	*/
-	async getWalletForSigning(walletId) {
-		if (this.loadedWallets.has(walletId)) return this.loadedWallets.get(walletId);
-		const stored = this.wallets.get(walletId);
-		if (!stored) throw new Error("Wallet not found");
-		const network = this.getNetwork(stored.network);
-		const { adapter } = await this.createWalletAdapter(stored.mnemonic, stored.version, network);
-		const kit = await this.getKit();
-		let wallet = await kit.addWallet(adapter);
-		if (!wallet) {
-			const kitWalletId = `${network.chainId}:${stored.address}`;
-			wallet = kit.getWallet(kitWalletId);
-			if (!wallet) throw new Error("Failed to load wallet");
-		}
-		this.loadedWallets.set(walletId, wallet);
-		return wallet;
-	}
-	/**
-	* Sign a transaction
-	*/
-	async signTransaction(_walletId, _unsignedBoc) {
-		throw new Error("signTransaction with BOC not implemented. Use the wallet service for transaction signing.");
-	}
-	/**
-	* Sign a message
-	*/
-	async signMessage(walletId, message) {
-		const stored = this.wallets.get(walletId);
-		if (!stored) throw new Error("Wallet not found");
-		const signature = await (await Signer.fromMnemonic(stored.mnemonic, { type: "ton" })).sign(message);
-		return Buffer.from(signature, "hex");
-	}
-	/**
-	* Close and cleanup
-	*/
-	async close() {
-		if (this.kit) {
-			await this.kit.close();
-			this.kit = null;
-		}
-		this.loadedWallets.clear();
-	}
-	/**
-	* Get TonWalletKit instance for direct wallet operations
-	* Used by WalletService for balance/transfer operations
-	*/
-	async getKitInstance() {
-		return this.getKit();
-	}
-	/**
-	* Get a loaded wallet by ID for direct operations
-	* Used by WalletService for balance/transfer operations
-	*/
-	async getLoadedWallet(walletId) {
-		return this.getWalletForSigning(walletId);
-	}
-	/**
-	* Get stored wallet data (internal use only)
-	*/
-	getStoredWallet(walletId) {
-		return this.wallets.get(walletId);
-	}
-};
-
-//#endregion
-//#region src/adapters/TelegramUserContextProvider.ts
-/**
-* Simple user context provider that always returns a fixed user ID.
-* Useful for single-user CLI applications or testing.
-*/
-var StaticUserContextProvider = class {
-	userId;
-	constructor(userId) {
-		this.userId = userId;
-	}
-	async getUserId() {
-		return this.userId;
-	}
-	async getUserMetadata() {
-		return {
-			provider: "static",
-			userId: this.userId
-		};
-	}
-};
-
 //#endregion
 //#region src/cli.ts
 /**
@@ -90122,12 +89156,21 @@ var StaticUserContextProvider = class {
 * TON wallet management tools for use with Claude Desktop or other MCP clients.
 *
 * Usage:
-*   npx @ton/mcp              # stdio mode (default)
-*   npx @ton/mcp --http       # HTTP server on port 3000
-*   npx @ton/mcp --http 8080  # HTTP server on custom port
+*   npx @ton/mcp                          # stdio mode (default)
+*   npx @ton/mcp --http                   # HTTP server on 0.0.0.0:3000
+*   npx @ton/mcp --http 8080              # HTTP server on custom port
+*   npx @ton/mcp --http --host 127.0.0.1  # HTTP server on custom host
+*
+* Environment variables:
+*   NETWORK - Network to use (mainnet or testnet, default: mainnet)
+*   MNEMONIC - 24-word mnemonic phrase for wallet (if not provided, a new wallet is created)
+*   WALLET_VERSION - Wallet version (v5r1 or v4r2, default: v5r1)
 */
 const SERVER_NAME = "ton-mcp";
 const NETWORK = process.env.NETWORK || "mainnet";
+const MNEMONIC = process.env.MNEMONIC;
+const WALLET_VERSION = process.env.WALLET_VERSION || "v5r1";
+const TONCENTER_API_KEY = process.env.TONCENTER_API_KEY;
 function log(message) {
 	console.error(`[${SERVER_NAME}] ${message}`);
 }
@@ -90136,33 +89179,66 @@ function parseArgs() {
 	const httpIndex = args.indexOf("--http");
 	if (httpIndex === -1) return { mode: "stdio" };
 	const nextArg = args[httpIndex + 1];
+	const port = nextArg && !nextArg.startsWith("-") ? parseInt(nextArg, 10) : 3e3;
+	const hostIndex = args.indexOf("--host");
+	const hostArg = hostIndex !== -1 ? args[hostIndex + 1] : void 0;
 	return {
 		mode: "http",
-		port: nextArg && !nextArg.startsWith("-") ? parseInt(nextArg, 10) : 3e3
+		port,
+		host: hostArg && !hostArg.startsWith("-") ? hostArg : "0.0.0.0"
 	};
 }
-function createAdaptersAndServer() {
-	const storage = new InMemoryStorageAdapter();
-	const signer = new LocalSignerAdapter();
+async function createWalletAndServer() {
+	const network = NETWORK === "mainnet" ? Network.mainnet() : Network.testnet();
+	const apiConfig = {};
+	if (TONCENTER_API_KEY) {
+		apiConfig.url = NETWORK === "mainnet" ? "https://toncenter.com" : "https://testnet.toncenter.com";
+		apiConfig.key = TONCENTER_API_KEY;
+	}
+	const kit = new TonWalletKit({
+		networks: { [network.chainId]: { apiClient: apiConfig } },
+		storage: new MemoryStorageAdapter()
+	});
+	await kit.waitForReady();
+	let mnemonic;
+	if (MNEMONIC) {
+		mnemonic = MNEMONIC.trim().split(/\s+/);
+		if (mnemonic.length !== 24) throw new Error(`Invalid mnemonic: expected 24 words, got ${mnemonic.length}`);
+		log("Using provided mnemonic");
+	} else throw new Error("MNEMONIC is required");
+	const signer = await Signer.fromMnemonic(mnemonic, { type: "ton" });
+	const walletAdapter = WALLET_VERSION === "v5r1" ? await WalletV5R1Adapter.create(signer, {
+		client: kit.getApiClient(network),
+		network
+	}) : await WalletV4R2Adapter.create(signer, {
+		client: kit.getApiClient(network),
+		network
+	});
+	let wallet = await kit.addWallet(walletAdapter);
+	if (!wallet) wallet = kit.getWallet(walletAdapter.getWalletId());
+	if (!wallet) throw new Error("Failed to create wallet");
+	log(`Wallet address: ${wallet.getAddress()}`);
+	log(`Network: ${NETWORK}`);
+	log(`Version: ${WALLET_VERSION}`);
 	return {
-		server: createTonWalletMCP({
-			storage,
-			signer,
-			userContext: new StaticUserContextProvider("cli-user"),
-			network: NETWORK,
-			requireConfirmation: false
+		server: await createTonWalletMCP({
+			wallet,
+			networks: {
+				mainnet: TONCENTER_API_KEY && NETWORK === "mainnet" ? { apiKey: TONCENTER_API_KEY } : void 0,
+				testnet: TONCENTER_API_KEY && NETWORK === "testnet" ? { apiKey: TONCENTER_API_KEY } : void 0
+			}
 		}),
-		signer
+		kit,
+		wallet
 	};
 }
 async function startStdio() {
 	log("Starting in stdio mode...");
-	log(`Network: ${NETWORK}`);
-	const { server, signer } = createAdaptersAndServer();
+	const { server, kit } = await createWalletAndServer();
 	const transport = new StdioServerTransport();
 	const shutdown = async () => {
 		log("Shutting down...");
-		await signer.close();
+		await kit.close();
 		log("Shutdown complete");
 		process.exit(0);
 	};
@@ -90171,32 +89247,31 @@ async function startStdio() {
 	await server.connect(transport);
 	log("Server connected and ready to accept requests");
 }
-async function startHttp(port) {
-	log(`Starting in HTTP mode on port ${port}...`);
-	log(`Network: ${NETWORK}`);
-	const { server, signer } = createAdaptersAndServer();
+async function startHttp(port, host) {
+	log(`Starting in HTTP mode on ${host}:${port}...`);
+	const { server, kit } = await createWalletAndServer();
 	const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => randomUUID() });
 	await server.connect(transport);
 	const httpServer = createServer(async (req, res) => {
-		if (new URL(req.url ?? "/", `http://localhost:${port}`).pathname === "/mcp") await transport.handleRequest(req, res);
+		if (new URL(req.url ?? "/", `http://${host}:${port}`).pathname === "/mcp") await transport.handleRequest(req, res);
 		else res.writeHead(404).end("Not Found");
 	});
 	const shutdown = async () => {
 		log("Shutting down...");
 		httpServer.close();
 		await transport.close();
-		await signer.close();
+		await kit.close();
 		log("Shutdown complete");
 		process.exit(0);
 	};
 	process.on("SIGINT", shutdown);
 	process.on("SIGTERM", shutdown);
-	httpServer.listen(port, () => {
-		log(`HTTP server listening on http://localhost:${port}/mcp`);
+	httpServer.listen(port, host, () => {
+		log(`HTTP server listening on http://${host}:${port}/mcp`);
 	});
 }
 const config = parseArgs();
-if (config.mode === "http") startHttp(config.port).catch((error) => {
+if (config.mode === "http") startHttp(config.port, config.host).catch((error) => {
 	console.error(`[${SERVER_NAME}] Fatal error:`, error);
 	process.exit(1);
 });