@truecarry/mcp 0.1.0

package/dist/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;GAEG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC"}

package/dist/tools/mcp-tools.d.ts

@@ -0,0 +1,439 @@
+/**
+ * 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.
+ *
+ */
+/**
+ * MCP tools for multi-user deployments with authentication
+ *
+ * These tools wrap the McpWalletService with user isolation.
+ * They are used by the createTonWalletMCP factory.
+ */
+import { z } from 'zod';
+import type { McpWalletService } from '../services/McpWalletService.js';
+interface ToolResponse {
+    [key: string]: unknown;
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}
+type AuthenticatedHandlerWrapper = <TArgs, TResult>(handler: (args: TArgs, userId: string, service: McpWalletService) => Promise<TResult>) => (args: TArgs, extra: unknown) => Promise<TResult>;
+export declare const createWalletSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodEnum<["v5r1", "v4r2"]>>;
+    network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version?: "v5r1" | "v4r2" | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+}, {
+    name: string;
+    version?: "v5r1" | "v4r2" | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+}>;
+export declare const importWalletSchema: z.ZodObject<{
+    name: z.ZodString;
+    mnemonic: z.ZodString;
+    version: z.ZodOptional<z.ZodEnum<["v5r1", "v4r2"]>>;
+    network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    mnemonic: string;
+    version?: "v5r1" | "v4r2" | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+}, {
+    name: string;
+    mnemonic: string;
+    version?: "v5r1" | "v4r2" | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+}>;
+export declare const removeWalletSchema: z.ZodObject<{
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+}, {
+    name: string;
+}>;
+export declare function createMcpWalletTools(_walletService: McpWalletService, wrapHandler: AuthenticatedHandlerWrapper): {
+    create_wallet: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodEnum<["v5r1", "v4r2"]>>;
+            network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            version?: "v5r1" | "v4r2" | undefined;
+            network?: "mainnet" | "testnet" | undefined;
+        }, {
+            name: string;
+            version?: "v5r1" | "v4r2" | undefined;
+            network?: "mainnet" | "testnet" | undefined;
+        }>;
+        handler: (args: {
+            name: string;
+            version?: "v5r1" | "v4r2" | undefined;
+            network?: "mainnet" | "testnet" | undefined;
+        }, extra: unknown) => Promise<ToolResponse>;
+    };
+    import_wallet: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            name: z.ZodString;
+            mnemonic: z.ZodString;
+            version: z.ZodOptional<z.ZodEnum<["v5r1", "v4r2"]>>;
+            network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            mnemonic: string;
+            version?: "v5r1" | "v4r2" | undefined;
+            network?: "mainnet" | "testnet" | undefined;
+        }, {
+            name: string;
+            mnemonic: string;
+            version?: "v5r1" | "v4r2" | undefined;
+            network?: "mainnet" | "testnet" | undefined;
+        }>;
+        handler: (args: {
+            name: string;
+            mnemonic: string;
+            version?: "v5r1" | "v4r2" | undefined;
+            network?: "mainnet" | "testnet" | undefined;
+        }, extra: unknown) => Promise<ToolResponse>;
+    };
+    list_wallets: {
+        description: string;
+        inputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        handler: (args: Record<string, never>, extra: unknown) => Promise<ToolResponse>;
+    };
+    remove_wallet: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+        }, {
+            name: string;
+        }>;
+        handler: (args: {
+            name: string;
+        }, extra: unknown) => Promise<ToolResponse>;
+    };
+};
+export declare const getBalanceSchema: z.ZodObject<{
+    wallet: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    wallet: string;
+}, {
+    wallet: string;
+}>;
+export declare const getJettonBalanceSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    jettonAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    wallet: string;
+    jettonAddress: string;
+}, {
+    wallet: string;
+    jettonAddress: string;
+}>;
+export declare const getJettonsSchema: z.ZodObject<{
+    wallet: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    wallet: string;
+}, {
+    wallet: string;
+}>;
+export declare const getTransactionsSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    wallet: string;
+    limit?: number | undefined;
+}, {
+    wallet: string;
+    limit?: number | undefined;
+}>;
+export declare function createMcpBalanceTools(_walletService: McpWalletService, wrapHandler: AuthenticatedHandlerWrapper): {
+    get_balance: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            wallet: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            wallet: string;
+        }, {
+            wallet: string;
+        }>;
+        handler: (args: {
+            wallet: string;
+        }, extra: unknown) => Promise<ToolResponse>;
+    };
+    get_jetton_balance: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            wallet: z.ZodString;
+            jettonAddress: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            wallet: string;
+            jettonAddress: string;
+        }, {
+            wallet: string;
+            jettonAddress: string;
+        }>;
+        handler: (args: {
+            wallet: string;
+            jettonAddress: string;
+        }, extra: unknown) => Promise<ToolResponse>;
+    };
+    get_jettons: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            wallet: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            wallet: string;
+        }, {
+            wallet: string;
+        }>;
+        handler: (args: {
+            wallet: string;
+        }, extra: unknown) => Promise<ToolResponse>;
+    };
+    get_transactions: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            wallet: z.ZodString;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            wallet: string;
+            limit?: number | undefined;
+        }, {
+            wallet: string;
+            limit?: number | undefined;
+        }>;
+        handler: (args: {
+            wallet: string;
+            limit?: number | undefined;
+        }, extra: unknown) => Promise<ToolResponse>;
+    };
+};
+export declare const sendTonSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    toAddress: z.ZodString;
+    amount: z.ZodString;
+    comment: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    wallet: string;
+    toAddress: string;
+    amount: string;
+    comment?: string | undefined;
+}, {
+    wallet: string;
+    toAddress: string;
+    amount: string;
+    comment?: string | undefined;
+}>;
+export declare const sendJettonSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    toAddress: z.ZodString;
+    jettonAddress: z.ZodString;
+    amount: z.ZodString;
+    comment: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    wallet: string;
+    jettonAddress: string;
+    toAddress: string;
+    amount: string;
+    comment?: string | undefined;
+}, {
+    wallet: string;
+    jettonAddress: string;
+    toAddress: string;
+    amount: string;
+    comment?: string | undefined;
+}>;
+export declare function createMcpTransferTools(_walletService: McpWalletService, wrapHandler: AuthenticatedHandlerWrapper): {
+    send_ton: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            wallet: z.ZodString;
+            toAddress: z.ZodString;
+            amount: z.ZodString;
+            comment: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            wallet: string;
+            toAddress: string;
+            amount: string;
+            comment?: string | undefined;
+        }, {
+            wallet: string;
+            toAddress: string;
+            amount: string;
+            comment?: string | undefined;
+        }>;
+        handler: (args: {
+            wallet: string;
+            toAddress: string;
+            amount: string;
+            comment?: string | undefined;
+        }, extra: unknown) => Promise<ToolResponse>;
+    };
+    send_jetton: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            wallet: z.ZodString;
+            toAddress: z.ZodString;
+            jettonAddress: z.ZodString;
+            amount: z.ZodString;
+            comment: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            wallet: string;
+            jettonAddress: string;
+            toAddress: string;
+            amount: string;
+            comment?: string | undefined;
+        }, {
+            wallet: string;
+            jettonAddress: string;
+            toAddress: string;
+            amount: string;
+            comment?: string | undefined;
+        }>;
+        handler: (args: {
+            wallet: string;
+            jettonAddress: string;
+            toAddress: string;
+            amount: string;
+            comment?: string | undefined;
+        }, extra: unknown) => Promise<ToolResponse>;
+    };
+};
+export declare const getSwapQuoteSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    fromToken: z.ZodString;
+    toToken: z.ZodString;
+    amount: z.ZodString;
+    slippageBps: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    fromToken: string;
+    toToken: string;
+    wallet: string;
+    amount: string;
+    slippageBps?: number | undefined;
+}, {
+    fromToken: string;
+    toToken: string;
+    wallet: string;
+    amount: string;
+    slippageBps?: number | undefined;
+}>;
+export declare const executeSwapSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    quoteId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    wallet: string;
+    quoteId: string;
+}, {
+    wallet: string;
+    quoteId: string;
+}>;
+export declare function createMcpSwapTools(_walletService: McpWalletService, wrapHandler: AuthenticatedHandlerWrapper): {
+    get_swap_quote: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            wallet: z.ZodString;
+            fromToken: z.ZodString;
+            toToken: z.ZodString;
+            amount: z.ZodString;
+            slippageBps: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            fromToken: string;
+            toToken: string;
+            wallet: string;
+            amount: string;
+            slippageBps?: number | undefined;
+        }, {
+            fromToken: string;
+            toToken: string;
+            wallet: string;
+            amount: string;
+            slippageBps?: number | undefined;
+        }>;
+        handler: (args: {
+            fromToken: string;
+            toToken: string;
+            wallet: string;
+            amount: string;
+            slippageBps?: number | undefined;
+        }, extra: unknown) => Promise<ToolResponse>;
+    };
+    execute_swap: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            wallet: z.ZodString;
+            quoteId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            wallet: string;
+            quoteId: string;
+        }, {
+            wallet: string;
+            quoteId: string;
+        }>;
+        handler: (args: {
+            wallet: string;
+            quoteId: string;
+        }, extra: unknown) => Promise<ToolResponse>;
+    };
+};
+export declare const confirmTransactionSchema: z.ZodObject<{
+    transactionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    transactionId: string;
+}, {
+    transactionId: string;
+}>;
+export declare const cancelTransactionSchema: z.ZodObject<{
+    transactionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    transactionId: string;
+}, {
+    transactionId: string;
+}>;
+export declare function createMcpPendingTools(_walletService: McpWalletService, wrapHandler: AuthenticatedHandlerWrapper): {
+    confirm_transaction: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            transactionId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            transactionId: string;
+        }, {
+            transactionId: string;
+        }>;
+        handler: (args: {
+            transactionId: string;
+        }, extra: unknown) => Promise<ToolResponse>;
+    };
+    cancel_transaction: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            transactionId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            transactionId: string;
+        }, {
+            transactionId: string;
+        }>;
+        handler: (args: {
+            transactionId: string;
+        }, extra: unknown) => Promise<ToolResponse>;
+    };
+    list_pending_transactions: {
+        description: string;
+        inputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        handler: (args: Record<string, never>, extra: unknown) => Promise<ToolResponse>;
+    };
+};
+export {};
+//# sourceMappingURL=mcp-tools.d.ts.map

package/dist/tools/mcp-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tools.d.ts","sourceRoot":"","sources":["../../src/tools/mcp-tools.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAGxE,UAAU,YAAY;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAGD,KAAK,2BAA2B,GAAG,CAAC,KAAK,EAAE,OAAO,EAC9C,OAAO,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,OAAO,CAAC,KACpF,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAkBvD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAU7B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;EAW7B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;EAE7B,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,gBAAgB,EAAE,WAAW,EAAE,2BAA2B;;;;;;;;;;;;;;;;;;;;kBA/CrF,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;kBAAP,OAAO;;;;;sDAAP,OAAO;;;;;;;;;;;;;kBAAP,OAAO;;EAwQhC;AAMD,eAAO,MAAM,gBAAgB;;;;;;EAE3B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;EAGjC,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;EAE3B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;EAQhC,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,gBAAgB,EAAE,WAAW,EAAE,2BAA2B;;;;;;;;;;;;kBArStF,OAAO;;;;;;;;;;;;;;;;;kBAAP,OAAO;;;;;;;;;;;;;kBAAP,OAAO;;;;;;;;;;;;;;;;;kBAAP,OAAO;;EAihBhC;AAMD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;EAKxB,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;EAM3B,CAAC;AAEH,wBAAgB,sBAAsB,CAAC,cAAc,EAAE,gBAAgB,EAAE,WAAW,EAAE,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;kBAtiBvF,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAP,OAAO;;EA2tBhC;AAsBD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;EAM7B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;EAG5B,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,gBAAgB,EAAE,WAAW,EAAE,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA9vBnF,OAAO;;;;;;;;;;;;;;;;;kBAAP,OAAO;;EAq7BhC;AAMD,eAAO,MAAM,wBAAwB;;;;;;EAEnC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;EAElC,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,gBAAgB,EAAE,WAAW,EAAE,2BAA2B;;;;;;;;;;;;kBAn8BtF,OAAO;;;;;;;;;;;;;kBAAP,OAAO;;;;;sDAAP,OAAO;;EAwkChC"}

package/dist/tools/swap.d.ts

@@ -0,0 +1,110 @@
+/**
+ * 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.
+ *
+ */
+/**
+ * Swap MCP tools for token swapping on TON blockchain
+ *
+ * Uses the Omniston (STON.fi) protocol for swap operations.
+ * Swap flow:
+ * 1. Get a quote using get_swap_quote
+ * 2. Execute the swap using execute_swap with the quote
+ */
+import { z } from 'zod';
+import type { WalletService } from '../services/WalletService.js';
+export declare const getSwapQuoteSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    fromToken: z.ZodString;
+    toToken: z.ZodString;
+    amount: z.ZodString;
+    slippageBps: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    fromToken: string;
+    toToken: string;
+    wallet: string;
+    amount: string;
+    slippageBps?: number | undefined;
+}, {
+    fromToken: string;
+    toToken: string;
+    wallet: string;
+    amount: string;
+    slippageBps?: number | undefined;
+}>;
+export declare const executeSwapSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    quoteId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    wallet: string;
+    quoteId: string;
+}, {
+    wallet: string;
+    quoteId: string;
+}>;
+export declare function createSwapTools(walletService: WalletService): {
+    get_swap_quote: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            wallet: z.ZodString;
+            fromToken: z.ZodString;
+            toToken: z.ZodString;
+            amount: z.ZodString;
+            slippageBps: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            fromToken: string;
+            toToken: string;
+            wallet: string;
+            amount: string;
+            slippageBps?: number | undefined;
+        }, {
+            fromToken: string;
+            toToken: string;
+            wallet: string;
+            amount: string;
+            slippageBps?: number | undefined;
+        }>;
+        handler: (args: z.infer<typeof getSwapQuoteSchema>) => Promise<{
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            isError?: undefined;
+        } | {
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            isError: boolean;
+        }>;
+    };
+    execute_swap: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            wallet: z.ZodString;
+            quoteId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            wallet: string;
+            quoteId: string;
+        }, {
+            wallet: string;
+            quoteId: string;
+        }>;
+        handler: (args: z.infer<typeof executeSwapSchema>) => Promise<{
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            isError: boolean;
+        } | {
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            isError?: undefined;
+        }>;
+    };
+};
+//# sourceMappingURL=swap.d.ts.map

package/dist/tools/swap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swap.d.ts","sourceRoot":"","sources":["../../src/tools/swap.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAkBlE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;EAoB7B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;EAG5B,CAAC;AAEH,wBAAgB,eAAe,CAAC,aAAa,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;wBAM1B,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;wBAgElC,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC;;;;;;;;;;;;;;EAkFlE"}

package/dist/tools/transfer.d.ts

@@ -0,0 +1,146 @@
+/**
+ * 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.
+ *
+ */
+/**
+ * Transfer MCP tools for sending TON and Jettons
+ *
+ * Amount handling:
+ * - User provides human-readable amounts (e.g., "1.5" TON or "0.001" USDT)
+ * - Tool converts to raw units using token decimals (TON has 9 decimals, most jettons have 6-9)
+ * - Conversion: rawAmount = userAmount * 10^decimals
+ */
+import { z } from 'zod';
+import type { WalletService } from '../services/WalletService.js';
+/**
+ * Converts a human-readable amount to raw units (smallest denomination).
+ *
+ * @param amount - Human-readable amount as string (e.g., "1.5", "0.001")
+ * @param decimals - Number of decimal places for the token (e.g., 9 for TON, 6 for USDT)
+ * @returns Raw amount as string (e.g., "1500000000" for 1.5 TON)
+ *
+ * @example
+ * toRawAmount("1.5", 9)    // "1500000000" (1.5 TON)
+ * toRawAmount("0.001", 6)  // "1000" (0.001 USDT with 6 decimals)
+ * toRawAmount("100", 9)    // "100000000000" (100 TON)
+ */
+declare function toRawAmount(amount: string, decimals: number): string;
+/**
+ * Converts raw units to human-readable amount.
+ *
+ * @param rawAmount - Raw amount as string (e.g., "1500000000")
+ * @param decimals - Number of decimal places for the token
+ * @returns Human-readable amount as string (e.g., "1.5")
+ */
+declare function fromRawAmount(rawAmount: string, decimals: number): string;
+/** TON has 9 decimal places (1 TON = 1,000,000,000 nanoTON) */
+declare const TON_DECIMALS = 9;
+export declare const sendTonSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    toAddress: z.ZodString;
+    amount: z.ZodString;
+    comment: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    wallet: string;
+    toAddress: string;
+    amount: string;
+    comment?: string | undefined;
+}, {
+    wallet: string;
+    toAddress: string;
+    amount: string;
+    comment?: string | undefined;
+}>;
+export declare const sendJettonSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    toAddress: z.ZodString;
+    jettonAddress: z.ZodString;
+    amount: z.ZodString;
+    comment: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    wallet: string;
+    jettonAddress: string;
+    toAddress: string;
+    amount: string;
+    comment?: string | undefined;
+}, {
+    wallet: string;
+    jettonAddress: string;
+    toAddress: string;
+    amount: string;
+    comment?: string | undefined;
+}>;
+export declare function createTransferTools(walletService: WalletService): {
+    send_ton: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            wallet: z.ZodString;
+            toAddress: z.ZodString;
+            amount: z.ZodString;
+            comment: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            wallet: string;
+            toAddress: string;
+            amount: string;
+            comment?: string | undefined;
+        }, {
+            wallet: string;
+            toAddress: string;
+            amount: string;
+            comment?: string | undefined;
+        }>;
+        handler: (args: z.infer<typeof sendTonSchema>) => Promise<{
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            isError: boolean;
+        } | {
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            isError?: undefined;
+        }>;
+    };
+    send_jetton: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            wallet: z.ZodString;
+            toAddress: z.ZodString;
+            jettonAddress: z.ZodString;
+            amount: z.ZodString;
+            comment: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            wallet: string;
+            jettonAddress: string;
+            toAddress: string;
+            amount: string;
+            comment?: string | undefined;
+        }, {
+            wallet: string;
+            jettonAddress: string;
+            toAddress: string;
+            amount: string;
+            comment?: string | undefined;
+        }>;
+        handler: (args: z.infer<typeof sendJettonSchema>) => Promise<{
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            isError: boolean;
+        } | {
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            isError?: undefined;
+        }>;
+    };
+};
+export { toRawAmount, fromRawAmount, TON_DECIMALS };
+//# sourceMappingURL=transfer.d.ts.map