@truecarry/mcp 0.1.5 → 0.1.7

package/dist/index.js

@@ -2,6 +2,7 @@ import { createRequire } from "node:module";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { randomFillSync } from "node:crypto";
 import { z } from "zod";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -21705,6 +21706,16 @@ function asAddressFriendly(data) {
 	} catch {}
 	throw new Error(`Can not convert to AddressFriendly from "${data}"`);
 }
+function formatWalletAddress(address, isTestnet = false) {
+	if (typeof address === "string") return import_dist$2.Address.parse(address).toString({
+		bounceable: false,
+		testOnly: isTestnet
+	});
+	return address.toString({
+		bounceable: false,
+		testOnly: isTestnet
+	});
+}
 function isValidAddress(address) {
 	if (typeof address !== "string") return false;
 	try {
@@ -21958,6 +21969,9 @@ function Base64ToBigInt(data) {
 	for (let i = 0; i < len; i++) result = (result << 8n) + BigInt(binary.charCodeAt(i));
 	return result;
 }
+function HexToBigInt(data) {
+	return BigInt(data);
+}
 /**
 * Convert hash to Uint8Array
 * @param data Hash (hex string starting with 0x)
@@ -65897,6 +65911,31 @@ var EventRouter = class {
 * LICENSE file in the root directory of this source tree.
 *
 */
+const tonProofPrefix = "ton-proof-item-v2/";
+const tonConnectPrefix = "ton-connect";
+async function CreateTonProofMessageBytes(message) {
+	const wc = Buffer.alloc(4);
+	wc.writeUInt32BE(message.workchain);
+	const ts = Buffer.alloc(8);
+	ts.writeBigUInt64LE(BigInt(message.timestamp));
+	const dl = Buffer.alloc(4);
+	dl.writeUInt32LE(message.domain.lengthBytes);
+	const messageHash = (0, import_dist$1.sha256_sync)(Buffer.concat([
+		Buffer.from(tonProofPrefix),
+		wc,
+		HexToUint8Array(message.addressHash),
+		dl,
+		Buffer.from(message.domain.value),
+		ts,
+		Buffer.from(message.payload)
+	]));
+	const res = (0, import_dist$1.sha256_sync)(Buffer.concat([
+		Buffer.from([255, 255]),
+		Buffer.from(tonConnectPrefix),
+		Buffer.from(messageHash)
+	]));
+	return Buffer.from(res);
+}
 function CreateTonProofMessage({ address, domain, payload, stateInit, timestamp }) {
 	return {
 		workchain: address.workChain,
@@ -67360,6 +67399,710 @@ var MessageHandlerRegistry = class {
 */
 const messageHandlerRegistry = new MessageHandlerRegistry();
 
+//#endregion
+//#region ../../node_modules/@scure/bip39/node_modules/@noble/hashes/utils.js
+/**
+* Utilities for hex, bytes, CSPRNG.
+* @module
+*/
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+function isBytes(a) {
+	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+/** Asserts something is positive integer. */
+function anumber(n, title = "") {
+	if (!Number.isSafeInteger(n) || n < 0) {
+		const prefix = title && `"${title}" `;
+		throw new Error(`${prefix}expected integer >= 0, got ${n}`);
+	}
+}
+/** Asserts something is Uint8Array. */
+function abytes(value, length, title = "") {
+	const bytes = isBytes(value);
+	const len = value?.length;
+	const needsLen = length !== void 0;
+	if (!bytes || needsLen && len !== length) {
+		const prefix = title && `"${title}" `;
+		const ofLen = needsLen ? ` of length ${length}` : "";
+		const got = bytes ? `length=${len}` : `type=${typeof value}`;
+		throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+	}
+	return value;
+}
+/** Asserts something is hash */
+function ahash(h) {
+	if (typeof h !== "function" || typeof h.create !== "function") throw new Error("Hash must wrapped by utils.createHasher");
+	anumber(h.outputLen);
+	anumber(h.blockLen);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+function aexists(instance, checkFinished = true) {
+	if (instance.destroyed) throw new Error("Hash instance has been destroyed");
+	if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
+}
+/** Asserts output is properly-sized byte array */
+function aoutput(out, instance) {
+	abytes(out, void 0, "digestInto() output");
+	const min = instance.outputLen;
+	if (out.length < min) throw new Error("\"digestInto() output\" expected to be of length >=" + min);
+}
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+function clean(...arrays) {
+	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
+}
+/** Create DataView of an array for easy byte-level manipulation. */
+function createView(arr) {
+	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+const isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+const hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
+/**
+* There is no setImmediate in browser and setTimeout is slow.
+* Call of async fn will return Promise, which will be fullfiled only on
+* next scheduler queue processing step and this is exactly what we need.
+*/
+const nextTick = async () => {};
+/** Returns control to thread each 'tick' ms to avoid blocking. */
+async function asyncLoop(iters, tick, cb) {
+	let ts = Date.now();
+	for (let i = 0; i < iters; i++) {
+		cb(i);
+		const diff = Date.now() - ts;
+		if (diff >= 0 && diff < tick) continue;
+		await /* @__PURE__ */ nextTick();
+		ts += diff;
+	}
+}
+/**
+* Converts string to bytes using UTF8 encoding.
+* Built-in doesn't validate input to be string: we do the check.
+* @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+*/
+function utf8ToBytes(str) {
+	if (typeof str !== "string") throw new Error("string expected");
+	return new Uint8Array(new TextEncoder().encode(str));
+}
+/**
+* Helper for KDFs: consumes uint8array or string.
+* When string is passed, does utf8 decoding, using TextDecoder.
+*/
+function kdfInputToBytes(data, errorTitle = "") {
+	if (typeof data === "string") return utf8ToBytes(data);
+	return abytes(data, void 0, errorTitle);
+}
+/** Merges default options and passed options. */
+function checkOpts(defaults, opts) {
+	if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]") throw new Error("options must be object or undefined");
+	return Object.assign(defaults, opts);
+}
+/** Creates function with outputLen, blockLen, create properties from a class constructor. */
+function createHasher(hashCons, info = {}) {
+	const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+	const tmp = hashCons(void 0);
+	hashC.outputLen = tmp.outputLen;
+	hashC.blockLen = tmp.blockLen;
+	hashC.create = (opts) => hashCons(opts);
+	Object.assign(hashC, info);
+	return Object.freeze(hashC);
+}
+/** Creates OID opts for NIST hashes, with prefix 06 09 60 86 48 01 65 03 04 02. */
+const oidNist = (suffix) => ({ oid: Uint8Array.from([
+	6,
+	9,
+	96,
+	134,
+	72,
+	1,
+	101,
+	3,
+	4,
+	2,
+	suffix
+]) });
+
+//#endregion
+//#region ../../node_modules/@scure/bip39/node_modules/@noble/hashes/hmac.js
+/**
+* HMAC: RFC2104 message authentication code.
+* @module
+*/
+/** Internal class for HMAC. */
+var _HMAC = class {
+	oHash;
+	iHash;
+	blockLen;
+	outputLen;
+	finished = false;
+	destroyed = false;
+	constructor(hash, key) {
+		ahash(hash);
+		abytes(key, void 0, "key");
+		this.iHash = hash.create();
+		if (typeof this.iHash.update !== "function") throw new Error("Expected instance of class which extends utils.Hash");
+		this.blockLen = this.iHash.blockLen;
+		this.outputLen = this.iHash.outputLen;
+		const blockLen = this.blockLen;
+		const pad = new Uint8Array(blockLen);
+		pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+		for (let i = 0; i < pad.length; i++) pad[i] ^= 54;
+		this.iHash.update(pad);
+		this.oHash = hash.create();
+		for (let i = 0; i < pad.length; i++) pad[i] ^= 106;
+		this.oHash.update(pad);
+		clean(pad);
+	}
+	update(buf) {
+		aexists(this);
+		this.iHash.update(buf);
+		return this;
+	}
+	digestInto(out) {
+		aexists(this);
+		abytes(out, this.outputLen, "output");
+		this.finished = true;
+		this.iHash.digestInto(out);
+		this.oHash.update(out);
+		this.oHash.digestInto(out);
+		this.destroy();
+	}
+	digest() {
+		const out = new Uint8Array(this.oHash.outputLen);
+		this.digestInto(out);
+		return out;
+	}
+	_cloneInto(to) {
+		to ||= Object.create(Object.getPrototypeOf(this), {});
+		const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+		to = to;
+		to.finished = finished;
+		to.destroyed = destroyed;
+		to.blockLen = blockLen;
+		to.outputLen = outputLen;
+		to.oHash = oHash._cloneInto(to.oHash);
+		to.iHash = iHash._cloneInto(to.iHash);
+		return to;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+	destroy() {
+		this.destroyed = true;
+		this.oHash.destroy();
+		this.iHash.destroy();
+	}
+};
+/**
+* HMAC: RFC2104 message authentication code.
+* @param hash - function that would be used e.g. sha256
+* @param key - message key
+* @param message - message data
+* @example
+* import { hmac } from '@noble/hashes/hmac';
+* import { sha256 } from '@noble/hashes/sha2';
+* const mac1 = hmac(sha256, 'key', 'message');
+*/
+const hmac = (hash, key, message) => new _HMAC(hash, key).update(message).digest();
+hmac.create = (hash, key) => new _HMAC(hash, key);
+
+//#endregion
+//#region ../../node_modules/@scure/bip39/node_modules/@noble/hashes/pbkdf2.js
+/**
+* PBKDF (RFC 2898). Can be used to create a key from password and salt.
+* @module
+*/
+function pbkdf2Init(hash, _password, _salt, _opts) {
+	ahash(hash);
+	const { c, dkLen, asyncTick } = checkOpts({
+		dkLen: 32,
+		asyncTick: 10
+	}, _opts);
+	anumber(c, "c");
+	anumber(dkLen, "dkLen");
+	anumber(asyncTick, "asyncTick");
+	if (c < 1) throw new Error("iterations (c) must be >= 1");
+	const password = kdfInputToBytes(_password, "password");
+	const salt = kdfInputToBytes(_salt, "salt");
+	const DK = new Uint8Array(dkLen);
+	const PRF = hmac.create(hash, password);
+	return {
+		c,
+		dkLen,
+		asyncTick,
+		DK,
+		PRF,
+		PRFSalt: PRF._cloneInto().update(salt)
+	};
+}
+function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
+	PRF.destroy();
+	PRFSalt.destroy();
+	if (prfW) prfW.destroy();
+	clean(u);
+	return DK;
+}
+/**
+* PBKDF2-HMAC: RFC 2898 key derivation function. Async version.
+* @example
+* await pbkdf2Async(sha256, 'password', 'salt', { dkLen: 32, c: 500_000 });
+*/
+async function pbkdf2Async(hash, password, salt, opts) {
+	const { c, dkLen, asyncTick, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
+	let prfW;
+	const arr = new Uint8Array(4);
+	const view = createView(arr);
+	const u = new Uint8Array(PRF.outputLen);
+	for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+		const Ti = DK.subarray(pos, pos + PRF.outputLen);
+		view.setInt32(0, ti, false);
+		(prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+		Ti.set(u.subarray(0, Ti.length));
+		await asyncLoop(c - 1, asyncTick, () => {
+			PRF._cloneInto(prfW).update(u).digestInto(u);
+			for (let i = 0; i < Ti.length; i++) Ti[i] ^= u[i];
+		});
+	}
+	return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+}
+
+//#endregion
+//#region ../../node_modules/@scure/bip39/node_modules/@noble/hashes/_md.js
+/**
+* Internal Merkle-Damgard hash utils.
+* @module
+*/
+/**
+* Merkle-Damgard hash construction base class.
+* Could be used to create MD5, RIPEMD, SHA1, SHA2.
+*/
+var HashMD = class {
+	blockLen;
+	outputLen;
+	padOffset;
+	isLE;
+	buffer;
+	view;
+	finished = false;
+	length = 0;
+	pos = 0;
+	destroyed = false;
+	constructor(blockLen, outputLen, padOffset, isLE) {
+		this.blockLen = blockLen;
+		this.outputLen = outputLen;
+		this.padOffset = padOffset;
+		this.isLE = isLE;
+		this.buffer = new Uint8Array(blockLen);
+		this.view = createView(this.buffer);
+	}
+	update(data) {
+		aexists(this);
+		abytes(data);
+		const { view, buffer, blockLen } = this;
+		const len = data.length;
+		for (let pos = 0; pos < len;) {
+			const take = Math.min(blockLen - this.pos, len - pos);
+			if (take === blockLen) {
+				const dataView = createView(data);
+				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
+				continue;
+			}
+			buffer.set(data.subarray(pos, pos + take), this.pos);
+			this.pos += take;
+			pos += take;
+			if (this.pos === blockLen) {
+				this.process(view, 0);
+				this.pos = 0;
+			}
+		}
+		this.length += data.length;
+		this.roundClean();
+		return this;
+	}
+	digestInto(out) {
+		aexists(this);
+		aoutput(out, this);
+		this.finished = true;
+		const { buffer, view, blockLen, isLE } = this;
+		let { pos } = this;
+		buffer[pos++] = 128;
+		clean(this.buffer.subarray(pos));
+		if (this.padOffset > blockLen - pos) {
+			this.process(view, 0);
+			pos = 0;
+		}
+		for (let i = pos; i < blockLen; i++) buffer[i] = 0;
+		view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+		this.process(view, 0);
+		const oview = createView(out);
+		const len = this.outputLen;
+		if (len % 4) throw new Error("_sha2: outputLen must be aligned to 32bit");
+		const outLen = len / 4;
+		const state = this.get();
+		if (outLen > state.length) throw new Error("_sha2: outputLen bigger than state");
+		for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
+	}
+	digest() {
+		const { buffer, outputLen } = this;
+		this.digestInto(buffer);
+		const res = buffer.slice(0, outputLen);
+		this.destroy();
+		return res;
+	}
+	_cloneInto(to) {
+		to ||= new this.constructor();
+		to.set(...this.get());
+		const { blockLen, buffer, length, finished, destroyed, pos } = this;
+		to.destroyed = destroyed;
+		to.finished = finished;
+		to.length = length;
+		to.pos = pos;
+		if (length % blockLen) to.buffer.set(buffer);
+		return to;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+};
+/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */
+const SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	4089235720,
+	3144134277,
+	2227873595,
+	1013904242,
+	4271175723,
+	2773480762,
+	1595750129,
+	1359893119,
+	2917565137,
+	2600822924,
+	725511199,
+	528734635,
+	4215389547,
+	1541459225,
+	327033209
+]);
+
+//#endregion
+//#region ../../node_modules/@scure/bip39/node_modules/@noble/hashes/_u64.js
+/**
+* Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+* @todo re-check https://issues.chromium.org/issues/42212588
+* @module
+*/
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+	if (le) return {
+		h: Number(n & U32_MASK64),
+		l: Number(n >> _32n & U32_MASK64)
+	};
+	return {
+		h: Number(n >> _32n & U32_MASK64) | 0,
+		l: Number(n & U32_MASK64) | 0
+	};
+}
+function split(lst, le = false) {
+	const len = lst.length;
+	let Ah = new Uint32Array(len);
+	let Al = new Uint32Array(len);
+	for (let i = 0; i < len; i++) {
+		const { h, l } = fromBig(lst[i], le);
+		[Ah[i], Al[i]] = [h, l];
+	}
+	return [Ah, Al];
+}
+const shrSH = (h, _l, s) => h >>> s;
+const shrSL = (h, l, s) => h << 32 - s | l >>> s;
+const rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+const rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+const rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+const rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+function add(Ah, Al, Bh, Bl) {
+	const l = (Al >>> 0) + (Bl >>> 0);
+	return {
+		h: Ah + Bh + (l / 2 ** 32 | 0) | 0,
+		l: l | 0
+	};
+}
+const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+const add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+const add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+const add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+
+//#endregion
+//#region ../../node_modules/@scure/bip39/node_modules/@noble/hashes/sha2.js
+/**
+* SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+* SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+* Check out [RFC 4634](https://www.rfc-editor.org/rfc/rfc4634) and
+* [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+* @module
+*/
+const K512 = split([
+	"0x428a2f98d728ae22",
+	"0x7137449123ef65cd",
+	"0xb5c0fbcfec4d3b2f",
+	"0xe9b5dba58189dbbc",
+	"0x3956c25bf348b538",
+	"0x59f111f1b605d019",
+	"0x923f82a4af194f9b",
+	"0xab1c5ed5da6d8118",
+	"0xd807aa98a3030242",
+	"0x12835b0145706fbe",
+	"0x243185be4ee4b28c",
+	"0x550c7dc3d5ffb4e2",
+	"0x72be5d74f27b896f",
+	"0x80deb1fe3b1696b1",
+	"0x9bdc06a725c71235",
+	"0xc19bf174cf692694",
+	"0xe49b69c19ef14ad2",
+	"0xefbe4786384f25e3",
+	"0x0fc19dc68b8cd5b5",
+	"0x240ca1cc77ac9c65",
+	"0x2de92c6f592b0275",
+	"0x4a7484aa6ea6e483",
+	"0x5cb0a9dcbd41fbd4",
+	"0x76f988da831153b5",
+	"0x983e5152ee66dfab",
+	"0xa831c66d2db43210",
+	"0xb00327c898fb213f",
+	"0xbf597fc7beef0ee4",
+	"0xc6e00bf33da88fc2",
+	"0xd5a79147930aa725",
+	"0x06ca6351e003826f",
+	"0x142929670a0e6e70",
+	"0x27b70a8546d22ffc",
+	"0x2e1b21385c26c926",
+	"0x4d2c6dfc5ac42aed",
+	"0x53380d139d95b3df",
+	"0x650a73548baf63de",
+	"0x766a0abb3c77b2a8",
+	"0x81c2c92e47edaee6",
+	"0x92722c851482353b",
+	"0xa2bfe8a14cf10364",
+	"0xa81a664bbc423001",
+	"0xc24b8b70d0f89791",
+	"0xc76c51a30654be30",
+	"0xd192e819d6ef5218",
+	"0xd69906245565a910",
+	"0xf40e35855771202a",
+	"0x106aa07032bbd1b8",
+	"0x19a4c116b8d2d0c8",
+	"0x1e376c085141ab53",
+	"0x2748774cdf8eeb99",
+	"0x34b0bcb5e19b48a8",
+	"0x391c0cb3c5c95a63",
+	"0x4ed8aa4ae3418acb",
+	"0x5b9cca4f7763e373",
+	"0x682e6ff3d6b2b8a3",
+	"0x748f82ee5defb2fc",
+	"0x78a5636f43172f60",
+	"0x84c87814a1f0ab72",
+	"0x8cc702081a6439ec",
+	"0x90befffa23631e28",
+	"0xa4506cebde82bde9",
+	"0xbef9a3f7b2c67915",
+	"0xc67178f2e372532b",
+	"0xca273eceea26619c",
+	"0xd186b8c721c0c207",
+	"0xeada7dd6cde0eb1e",
+	"0xf57d4f7fee6ed178",
+	"0x06f067aa72176fba",
+	"0x0a637dc5a2c898a6",
+	"0x113f9804bef90dae",
+	"0x1b710b35131c471b",
+	"0x28db77f523047d84",
+	"0x32caab7b40c72493",
+	"0x3c9ebe0a15c9bebc",
+	"0x431d67c49c100d4c",
+	"0x4cc5d4becb3e42b6",
+	"0x597f299cfc657e2a",
+	"0x5fcb6fab3ad6faec",
+	"0x6c44198c4a475817"
+].map((n) => BigInt(n)));
+const SHA512_Kh = K512[0];
+const SHA512_Kl = K512[1];
+const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+/** Internal 64-byte base SHA2 hash class. */
+var SHA2_64B = class extends HashMD {
+	constructor(outputLen) {
+		super(128, outputLen, 16, false);
+	}
+	get() {
+		const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+		return [
+			Ah,
+			Al,
+			Bh,
+			Bl,
+			Ch,
+			Cl,
+			Dh,
+			Dl,
+			Eh,
+			El,
+			Fh,
+			Fl,
+			Gh,
+			Gl,
+			Hh,
+			Hl
+		];
+	}
+	set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+		this.Ah = Ah | 0;
+		this.Al = Al | 0;
+		this.Bh = Bh | 0;
+		this.Bl = Bl | 0;
+		this.Ch = Ch | 0;
+		this.Cl = Cl | 0;
+		this.Dh = Dh | 0;
+		this.Dl = Dl | 0;
+		this.Eh = Eh | 0;
+		this.El = El | 0;
+		this.Fh = Fh | 0;
+		this.Fl = Fl | 0;
+		this.Gh = Gh | 0;
+		this.Gl = Gl | 0;
+		this.Hh = Hh | 0;
+		this.Hl = Hl | 0;
+	}
+	process(view, offset) {
+		for (let i = 0; i < 16; i++, offset += 4) {
+			SHA512_W_H[i] = view.getUint32(offset);
+			SHA512_W_L[i] = view.getUint32(offset += 4);
+		}
+		for (let i = 16; i < 80; i++) {
+			const W15h = SHA512_W_H[i - 15] | 0;
+			const W15l = SHA512_W_L[i - 15] | 0;
+			const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
+			const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
+			const W2h = SHA512_W_H[i - 2] | 0;
+			const W2l = SHA512_W_L[i - 2] | 0;
+			const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
+			const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
+			const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+			SHA512_W_H[i] = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]) | 0;
+			SHA512_W_L[i] = SUMl | 0;
+		}
+		let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+		for (let i = 0; i < 80; i++) {
+			const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
+			const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
+			const CHIh = Eh & Fh ^ ~Eh & Gh;
+			const CHIl = El & Fl ^ ~El & Gl;
+			const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+			const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+			const T1l = T1ll | 0;
+			const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
+			const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
+			const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
+			const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
+			Hh = Gh | 0;
+			Hl = Gl | 0;
+			Gh = Fh | 0;
+			Gl = Fl | 0;
+			Fh = Eh | 0;
+			Fl = El | 0;
+			({h: Eh, l: El} = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+			Dh = Ch | 0;
+			Dl = Cl | 0;
+			Ch = Bh | 0;
+			Cl = Bl | 0;
+			Bh = Ah | 0;
+			Bl = Al | 0;
+			const All = add3L(T1l, sigma0l, MAJl);
+			Ah = add3H(All, T1h, sigma0h, MAJh);
+			Al = All | 0;
+		}
+		({h: Ah, l: Al} = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+		({h: Bh, l: Bl} = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+		({h: Ch, l: Cl} = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+		({h: Dh, l: Dl} = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+		({h: Eh, l: El} = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+		({h: Fh, l: Fl} = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+		({h: Gh, l: Gl} = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+		({h: Hh, l: Hl} = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+		this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+	}
+	roundClean() {
+		clean(SHA512_W_H, SHA512_W_L);
+	}
+	destroy() {
+		clean(this.buffer);
+		this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	}
+};
+/** Internal SHA2-512 hash class. */
+var _SHA512 = class extends SHA2_64B {
+	Ah = SHA512_IV[0] | 0;
+	Al = SHA512_IV[1] | 0;
+	Bh = SHA512_IV[2] | 0;
+	Bl = SHA512_IV[3] | 0;
+	Ch = SHA512_IV[4] | 0;
+	Cl = SHA512_IV[5] | 0;
+	Dh = SHA512_IV[6] | 0;
+	Dl = SHA512_IV[7] | 0;
+	Eh = SHA512_IV[8] | 0;
+	El = SHA512_IV[9] | 0;
+	Fh = SHA512_IV[10] | 0;
+	Fl = SHA512_IV[11] | 0;
+	Gh = SHA512_IV[12] | 0;
+	Gl = SHA512_IV[13] | 0;
+	Hh = SHA512_IV[14] | 0;
+	Hl = SHA512_IV[15] | 0;
+	constructor() {
+		super(64);
+	}
+};
+/** SHA2-512 hash function from RFC 4634. */
+const sha512 = /* @__PURE__ */ createHasher(() => new _SHA512(), /* @__PURE__ */ oidNist(3));
+
+//#endregion
+//#region ../../node_modules/@scure/bip39/index.js
+/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */
+function nfkd(str) {
+	if (typeof str !== "string") throw new TypeError("invalid mnemonic type: " + typeof str);
+	return str.normalize("NFKD");
+}
+function normalize(str) {
+	const norm = nfkd(str);
+	const words = norm.split(" ");
+	if (![
+		12,
+		15,
+		18,
+		21,
+		24
+	].includes(words.length)) throw new Error("Invalid mnemonic");
+	return {
+		nfkd: norm,
+		words
+	};
+}
+const psalt = (passphrase) => nfkd("mnemonic" + passphrase);
+/**
+* Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+* @param mnemonic 12-24 words
+* @param passphrase string that will additionally protect the key
+* @returns 64 bytes of key data
+* @example
+* const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+* await mnemonicToSeed(mnem, 'password');
+* // new Uint8Array([...64 bytes])
+*/
+function mnemonicToSeed(mnemonic, passphrase = "") {
+	return pbkdf2Async(sha512, normalize(mnemonic).nfkd, psalt(passphrase), {
+		c: 2048,
+		dkLen: 64
+	});
+}
+
 //#endregion
 //#region ../walletkit/dist/esm/utils/mnemonic.js
 /**
@@ -67369,6 +68112,42 @@ const messageHandlerRegistry = new MessageHandlerRegistry();
 * LICENSE file in the root directory of this source tree.
 *
 */
+async function bip39ToPrivateKey(mnemonic) {
+	const seed = await mnemonicToSeed(mnemonic.join(" "));
+	return (0, import_dist$1.keyPairFromSeed)((await (0, import_dist$1.deriveEd25519Path)(Buffer.from(seed), [
+		44,
+		607,
+		0
+	])).subarray(0, 32));
+}
+/**
+* Convert a mnemonic to a key pair
+* @param mnemonic - The mnemonic to convert, can be an array of strings or a string. 12 or 24 words
+* @param mnemonicType - The type of mnemonic to convert, can be 'ton' or 'bip39'
+* @returns The key pair
+*/
+async function MnemonicToKeyPair(mnemonic, mnemonicType = "ton") {
+	const mnemonicArray = Array.isArray(mnemonic) ? mnemonic : mnemonic.split(" ");
+	if (mnemonicArray.length !== 12 && mnemonicArray.length !== 24) throw new WalletKitError(ERROR_CODES.VALIDATION_ERROR, `Invalid mnemonic length: expected 12 or 24 words, got ${mnemonicArray.length}`);
+	if (mnemonicType === "ton") {
+		const key = await (0, import_dist$1.mnemonicToWalletKey)(mnemonicArray);
+		return {
+			publicKey: new Uint8Array(key.publicKey),
+			secretKey: new Uint8Array(key.secretKey)
+		};
+	}
+	if (mnemonicType === "bip39") {
+		const key = await bip39ToPrivateKey(mnemonicArray);
+		return {
+			publicKey: new Uint8Array(key.publicKey),
+			secretKey: new Uint8Array(key.secretKey)
+		};
+	}
+	throw new WalletKitError(ERROR_CODES.VALIDATION_ERROR, `Invalid mnemonic type: expected "ton" or "bip39", got "${mnemonicType}"`, void 0, {
+		receivedType: mnemonicType,
+		supportedTypes: ["ton", "bip39"]
+	});
+}
 
 //#endregion
 //#region ../walletkit/dist/esm/utils/sign.js
@@ -67379,7 +68158,20 @@ const messageHandlerRegistry = new MessageHandlerRegistry();
 * LICENSE file in the root directory of this source tree.
 *
 */
+function DefaultSignature(data, privateKey) {
+	let fullKey = privateKey;
+	if (fullKey.length === 32) fullKey = (0, import_dist$1.keyPairFromSeed)(Buffer.from(fullKey)).secretKey;
+	return Uint8ArrayToHex((0, import_dist$1.sign)(Buffer.from(Uint8Array.from(data)), Buffer.from(fullKey)));
+}
+function createWalletSigner(privateKey) {
+	return async (data) => {
+		return DefaultSignature(Uint8Array.from(data), privateKey);
+	};
+}
 const fakeKeyPair = (0, import_dist$1.keyPairFromSeed)(Buffer.alloc(32, 0));
+function FakeSignature(data) {
+	return Uint8ArrayToHex([...(0, import_dist$1.sign)(Buffer.from(Uint8Array.from(data)), Buffer.from(fakeKeyPair.secretKey))]);
+}
 
 //#endregion
 //#region ../walletkit/dist/esm/utils/Signer.js
@@ -67390,6 +68182,37 @@ const fakeKeyPair = (0, import_dist$1.keyPairFromSeed)(Buffer.alloc(32, 0));
 * LICENSE file in the root directory of this source tree.
 *
 */
+/**
+* Utility class for creating wallet signers from various sources
+*/
+var Signer = class {
+	/**
+	* Create a signer from a mnemonic phrase
+	* @param mnemonic - Mnemonic phrase as string or array of words
+	* @param options - Optional configuration for mnemonic type
+	* @returns Signer function with publicKey property
+	*/
+	static async fromMnemonic(mnemonic, options) {
+		const keyPair = await MnemonicToKeyPair(mnemonic, options?.type ?? "ton");
+		return {
+			sign: createWalletSigner(keyPair.secretKey),
+			publicKey: Uint8ArrayToHex(keyPair.publicKey)
+		};
+	}
+	/**
+	* Create a signer from a private key
+	* @param privateKey - Private key as hex string or Uint8Array
+	* @returns Signer function with publicKey property
+	*/
+	static async fromPrivateKey(privateKey) {
+		const privateKeyBytes = typeof privateKey === "string" ? Uint8Array.from(Buffer.from(privateKey.replace("0x", ""), "hex")) : privateKey;
+		const keyPair = (0, import_dist$1.keyPairFromSeed)(Buffer.from(privateKeyBytes));
+		return {
+			sign: createWalletSigner(keyPair.secretKey),
+			publicKey: Uint8ArrayToHex(keyPair.publicKey)
+		};
+	}
+};
 
 //#endregion
 //#region ../walletkit/dist/esm/utils/cell.js
@@ -67446,6 +68269,12 @@ function getEventsSubsystem() {
 * LICENSE file in the root directory of this source tree.
 *
 */
+/**
+* Creates a wallet ID from network and address
+*/
+function createWalletId(network, address) {
+	return (0, import_dist$1.sha256_sync)(`${network.chainId}:${address}`).toString("base64");
+}
 
 //#endregion
 //#region ../walletkit/dist/esm/core/wallet/extensions/jetton.js
@@ -70172,7 +71001,7 @@ async function dnsLookup(client, domain, category, resolver) {
 		type: "int",
 		value: toTonDnsCategory(category)
 	}];
-	const { stack, exitCode } = await client.runGetMethod(asAddressFriendly(resolver), "dnsresolve", SerializeStack(param));
+	const { stack, exitCode } = await CallForSuccess(() => client.runGetMethod(asAddressFriendly(resolver), "dnsresolve", SerializeStack(param)));
 	if (stack?.length !== 2) return null;
 	const parsedStack = ParseStack(stack);
 	if (exitCode !== 0) return null;
@@ -71170,6 +71999,90 @@ const WalletV5R1CodeCell = import_dist$2.Cell.fromBoc(Buffer.from(WalletV5R1Code
 * LICENSE file in the root directory of this source tree.
 *
 */
+var ActionSendMsg = class ActionSendMsg {
+	mode;
+	outMsg;
+	static tag = 247711853;
+	tag = ActionSendMsg.tag;
+	constructor(mode, outMsg) {
+		this.mode = mode;
+		this.outMsg = outMsg;
+	}
+	serialize() {
+		return (0, import_dist$2.beginCell)().storeUint(this.tag, 32).storeUint(this.mode | import_dist$2.SendMode.IGNORE_ERRORS, 8).storeRef((0, import_dist$2.beginCell)().store((0, import_dist$2.storeMessageRelaxed)(this.outMsg)).endCell()).endCell();
+	}
+};
+var ActionAddExtension = class ActionAddExtension {
+	address;
+	static tag = 2;
+	tag = ActionAddExtension.tag;
+	constructor(address) {
+		this.address = address;
+	}
+	serialize() {
+		return (0, import_dist$2.beginCell)().storeUint(this.tag, 8).storeAddress(this.address).endCell();
+	}
+};
+var ActionRemoveExtension = class ActionRemoveExtension {
+	address;
+	static tag = 3;
+	tag = ActionRemoveExtension.tag;
+	constructor(address) {
+		this.address = address;
+	}
+	serialize() {
+		return (0, import_dist$2.beginCell)().storeUint(this.tag, 8).storeAddress(this.address).endCell();
+	}
+};
+var ActionSetSignatureAuthAllowed = class ActionSetSignatureAuthAllowed {
+	allowed;
+	static tag = 4;
+	tag = ActionSetSignatureAuthAllowed.tag;
+	constructor(allowed) {
+		this.allowed = allowed;
+	}
+	serialize() {
+		return (0, import_dist$2.beginCell)().storeUint(this.tag, 8).storeUint(this.allowed ? 1 : 0, 1).endCell();
+	}
+};
+function isExtendedAction(action) {
+	return action.tag === ActionAddExtension.tag || action.tag === ActionRemoveExtension.tag || action.tag === ActionSetSignatureAuthAllowed.tag;
+}
+function packActionsListOut(actions) {
+	if (actions.length === 0) return (0, import_dist$2.beginCell)().endCell();
+	const [action, ...rest] = actions;
+	if (isExtendedAction(action)) throw new Error("Actions bust be in an order: all extended actions, all out actions");
+	return (0, import_dist$2.beginCell)().storeRef(packActionsListOut(rest)).storeSlice(action.serialize().beginParse()).endCell();
+}
+function packExtendedActions(extendedActions) {
+	const first = extendedActions[0];
+	const rest = extendedActions.slice(1);
+	let builder = (0, import_dist$2.beginCell)().storeSlice(first.serialize().beginParse());
+	if (rest.length > 0) builder = builder.storeRef(packExtendedActions(extendedActions.slice(1)));
+	return builder.endCell();
+}
+function packActionsListExtended(actions) {
+	const extendedActions = [];
+	const outActions = [];
+	actions.forEach((action) => {
+		if (isExtendedAction(action)) extendedActions.push(action);
+		else outActions.push(action);
+	});
+	let builder = (0, import_dist$2.beginCell)();
+	if (outActions.length === 0) builder = builder.storeUint(0, 1);
+	else builder = builder.storeMaybeRef(packActionsListOut(outActions.slice().reverse()));
+	if (extendedActions.length === 0) builder = builder.storeUint(0, 1);
+	else {
+		const first = extendedActions[0];
+		const rest = extendedActions.slice(1);
+		builder = builder.storeUint(1, 1).storeSlice(first.serialize().beginParse());
+		if (rest.length > 0) builder = builder.storeRef(packExtendedActions(rest));
+	}
+	return builder.endCell();
+}
+function packActionsList(actions) {
+	return packActionsListExtended(actions);
+}
 
 //#endregion
 //#region ../walletkit/dist/esm/contracts/w5/WalletV5R1Adapter.js
@@ -71181,6 +72094,201 @@ const WalletV5R1CodeCell = import_dist$2.Cell.fromBoc(Buffer.from(WalletV5R1Code
 *
 */
 const log$2 = globalLogger.createChild("WalletV5R1Adapter");
+const defaultWalletIdV5R1 = 2147483409;
+/**
+* WalletV5R1 adapter that implements WalletInterface for WalletV5 contracts
+*/
+var WalletV5R1Adapter = class WalletV5R1Adapter {
+	signer;
+	config;
+	walletContract;
+	client;
+	publicKey;
+	version = "v5r1";
+	/**
+	* Static factory method to create a WalletV5R1Adapter
+	* @param signer - Signer function with publicKey property (from Signer utility)
+	* @param options - Configuration options for the wallet
+	*/
+	static async create(signer, options) {
+		return new WalletV5R1Adapter({
+			signer,
+			publicKey: signer.publicKey,
+			tonClient: options.client,
+			network: options.network,
+			walletId: options.walletId,
+			workchain: options.workchain
+		});
+	}
+	constructor(config) {
+		this.config = config;
+		this.client = config.tonClient;
+		this.signer = config.signer;
+		this.publicKey = this.config.publicKey;
+		this.walletContract = WalletV5.createFromConfig({
+			publicKey: HexToBigInt(this.publicKey),
+			seqno: 0,
+			signatureAllowed: true,
+			walletId: typeof config.walletId === "bigint" ? Number(config.walletId) : config.walletId ?? defaultWalletIdV5R1,
+			extensions: import_dist$2.Dictionary.empty()
+		}, {
+			code: WalletV5R1CodeCell,
+			workchain: config.workchain ?? 0,
+			client: this.client
+		});
+	}
+	getPublicKey() {
+		return this.publicKey;
+	}
+	getClient() {
+		return this.client;
+	}
+	/**
+	* Sign raw bytes with wallet's private key
+	*/
+	async sign(bytes) {
+		return this.signer.sign(bytes);
+	}
+	getNetwork() {
+		return this.config.network;
+	}
+	/**
+	* Get wallet's TON address
+	*/
+	getAddress(options) {
+		return formatWalletAddress(this.walletContract.address, options?.testnet);
+	}
+	getWalletId() {
+		return createWalletId(this.getNetwork(), this.getAddress());
+	}
+	async getSignedSendTransaction(input, options) {
+		const actions = packActionsList(input.messages.map((m) => {
+			let bounce = true;
+			if (import_dist$2.Address.parseFriendly(m.address).isBounceable === false) bounce = false;
+			const msg = (0, import_dist$2.internal)({
+				to: m.address,
+				value: BigInt(m.amount),
+				bounce,
+				extracurrency: m.extraCurrency ? Object.fromEntries(Object.entries(m.extraCurrency).map(([k, v]) => [Number(k), BigInt(v)])) : void 0
+			});
+			if (m.payload) try {
+				msg.body = import_dist$2.Cell.fromBase64(m.payload);
+			} catch (error) {
+				log$2.warn("Failed to load payload", { error });
+				throw WalletKitError.fromError(ERROR_CODES.CONTRACT_VALIDATION_FAILED, "Failed to parse transaction payload", error);
+			}
+			if (m.stateInit) try {
+				msg.init = (0, import_dist$2.loadStateInit)(import_dist$2.Cell.fromBase64(m.stateInit).asSlice());
+			} catch (error) {
+				log$2.warn("Failed to load state init", { error });
+				throw WalletKitError.fromError(ERROR_CODES.CONTRACT_VALIDATION_FAILED, "Failed to parse state init", error);
+			}
+			return new ActionSendMsg(import_dist$2.SendMode.PAY_GAS_SEPARATELY + import_dist$2.SendMode.IGNORE_ERRORS, msg);
+		}));
+		const createBodyOptions = {
+			...options,
+			validUntil: void 0
+		};
+		if (input.validUntil) {
+			const now = Math.floor(Date.now() / 1e3);
+			const maxValidUntil = now + 600;
+			if (input.validUntil < now) throw new WalletKitError(ERROR_CODES.VALIDATION_ERROR, "Transaction valid_until timestamp is in the past", void 0, {
+				validUntil: input.validUntil,
+				currentTime: now
+			});
+			else if (input.validUntil > maxValidUntil) createBodyOptions.validUntil = maxValidUntil;
+			else createBodyOptions.validUntil = input.validUntil;
+		}
+		let seqno = 0;
+		try {
+			seqno = await CallForSuccess(async () => this.getSeqno(), 5, 1e3);
+		} catch (_) {}
+		const walletId = (await this.walletContract.walletId).serialized;
+		if (!walletId) throw new Error("Failed to get seqno or walletId");
+		const transfer = await this.createBodyV5(seqno, walletId, actions, createBodyOptions);
+		const ext = (0, import_dist$2.external)({
+			to: this.walletContract.address,
+			init: this.walletContract.init,
+			body: transfer
+		});
+		return (0, import_dist$2.beginCell)().store((0, import_dist$2.storeMessage)(ext)).endCell().toBoc().toString("base64");
+	}
+	/**
+	* Get state init for wallet deployment
+	*/
+	async getStateInit() {
+		if (!this.walletContract.init) throw new Error("Wallet contract not properly initialized");
+		return (0, import_dist$2.beginCell)().store((0, import_dist$2.storeStateInit)(this.walletContract.init)).endCell().toBoc().toString("base64");
+	}
+	/**
+	* Get the underlying WalletV5 contract
+	*/
+	getContract() {
+		return this.walletContract;
+	}
+	/**
+	* Get current sequence number
+	*/
+	async getSeqno() {
+		try {
+			return await this.walletContract.seqno;
+		} catch (error) {
+			log$2.warn("Failed to get seqno", { error });
+			throw error;
+		}
+	}
+	/**
+	* Get wallet ID
+	*/
+	async getWalletV5R1Id() {
+		try {
+			return this.walletContract.walletId;
+		} catch (error) {
+			log$2.warn("Failed to get wallet ID", { error });
+			const walletId = this.config.walletId;
+			return new WalletV5R1Id({ subwalletNumber: typeof walletId === "bigint" ? Number(walletId) : walletId || 0 });
+		}
+	}
+	/**
+	* Check if wallet is deployed on the network
+	*/
+	async isDeployed() {
+		try {
+			return (await this.client.getAccountState(asAddressFriendly(this.walletContract.address))).status === "active";
+		} catch (error) {
+			log$2.warn("Failed to check deployment status", { error });
+			return false;
+		}
+	}
+	async createBodyV5(seqno, walletId, actionsList, options) {
+		const Opcodes = { auth_signed: 1936287598 };
+		const expireAt = options.validUntil ?? Math.floor(Date.now() / 1e3) + 300;
+		const payload = (0, import_dist$2.beginCell)().storeUint(Opcodes.auth_signed, 32).storeUint(walletId, 32).storeUint(expireAt, 32).storeUint(seqno, 32).storeSlice(actionsList.beginParse()).endCell();
+		const signingData = payload.hash();
+		const signature = options.fakeSignature ? FakeSignature(signingData) : await this.sign(signingData);
+		return (0, import_dist$2.beginCell)().storeSlice(payload.beginParse()).storeBuffer(Buffer.from(HexToUint8Array(signature))).endCell();
+	}
+	async getSignedSignData(input) {
+		return await this.sign(HexToUint8Array(input.hash));
+	}
+	async getSignedTonProof(input) {
+		const message = await CreateTonProofMessageBytes(input);
+		return await this.sign(message);
+	}
+	getSupportedFeatures() {
+		return [{
+			name: "SendTransaction",
+			maxMessages: 255
+		}, {
+			name: "SignData",
+			types: [
+				"binary",
+				"cell",
+				"text"
+			]
+		}];
+	}
+};
 
 //#endregion
 //#region ../walletkit/dist/esm/contracts/w5/WalletV5R1.js
@@ -71191,6 +72299,129 @@ const log$2 = globalLogger.createChild("WalletV5R1Adapter");
 * LICENSE file in the root directory of this source tree.
 *
 */
+function walletV5ConfigToCell(config) {
+	return (0, import_dist$2.beginCell)().storeBit(config.signatureAllowed).storeUint(config.seqno, 32).storeUint(config.walletId, 32).storeUint(config.publicKey, 256).storeDict(config.extensions, import_dist$2.Dictionary.Keys.BigUint(256), import_dist$2.Dictionary.Values.BigInt(1)).endCell();
+}
+const Opcodes = {
+	action_send_msg: 247711853,
+	action_set_code: 2907562126,
+	action_extended_set_data: 536406539,
+	action_extended_add_extension: 2,
+	action_extended_remove_extension: 3,
+	action_extended_set_signature_auth_allowed: 4,
+	auth_extension: 1702392942,
+	auth_signed: 1936287598,
+	auth_signed_internal: 1936289396
+};
+var WalletV5R1Id = class WalletV5R1Id {
+	static deserialize(walletId) {
+		return new WalletV5R1Id({ subwalletNumber: walletId });
+	}
+	subwalletNumber;
+	serialized;
+	constructor(args) {
+		this.subwalletNumber = args?.subwalletNumber ?? 0;
+		this.serialized = BigInt(this.subwalletNumber);
+	}
+};
+var WalletV5 = class WalletV5 {
+	client;
+	address;
+	init;
+	subwalletId;
+	constructor(client, address, init) {
+		this.client = client;
+		this.address = address;
+		this.init = init;
+	}
+	static createFromAddress(client, address) {
+		return new WalletV5(client, address);
+	}
+	static createFromConfig(config, options) {
+		const data = walletV5ConfigToCell(config);
+		const init = {
+			code: options.code,
+			data
+		};
+		const wallet = new WalletV5(options.client, (0, import_dist$2.contractAddress)(options.workchain, init), init);
+		wallet.subwalletId = config.walletId;
+		return wallet;
+	}
+	async sendDeploy(provider, via, value) {
+		await provider.internal(via, {
+			value,
+			sendMode: import_dist$2.SendMode.PAY_GAS_SEPARATELY,
+			body: (0, import_dist$2.beginCell)().endCell()
+		});
+	}
+	async sendInternalSignedMessage(provider, via, opts) {
+		await provider.internal(via, {
+			value: opts.value,
+			sendMode: import_dist$2.SendMode.PAY_GAS_SEPARATELY,
+			body: (0, import_dist$2.beginCell)().storeSlice(opts.body.beginParse()).endCell()
+		});
+	}
+	async sendInternalMessageFromExtension(provider, via, opts) {
+		await provider.internal(via, {
+			value: opts.value,
+			sendMode: import_dist$2.SendMode.PAY_GAS_SEPARATELY,
+			body: (0, import_dist$2.beginCell)().storeUint(Opcodes.auth_extension, 32).storeUint(0, 64).storeSlice(opts.body.beginParse()).endCell()
+		});
+	}
+	async sendInternal(provider, via, opts) {
+		await provider.internal(via, opts);
+	}
+	async sendExternalSignedMessage(provider, body) {
+		await provider.external(body);
+	}
+	async sendExternal(provider, body) {
+		await provider.external(body);
+	}
+	get publicKey() {
+		return this.client.runGetMethod(asAddressFriendly(this.address), "get_public_key").then((data) => {
+			if (data.exitCode === 0) {
+				const parsedStack = ParseStack(data.stack);
+				if (parsedStack[0]?.type === "int") return parsedStack[0].value;
+				else throw new Error("Stack is not an int");
+			} else if (this.init) return this.init.data.asSlice().skip(65).loadUintBig(256);
+			else return 0n;
+		});
+	}
+	get status() {
+		return this.client.getAccountState(asAddressFriendly(this.address)).then((state) => state.status);
+	}
+	get seqno() {
+		return this.client.runGetMethod(asAddressFriendly(this.address), "seqno").then((data) => {
+			if (data.exitCode === 0) {
+				const parsedStack = ParseStack(data.stack);
+				if (parsedStack[0]?.type === "int") return Number(parsedStack[0].value);
+				else throw new Error("Stack is not an int");
+			} else return 0;
+		});
+	}
+	get isSignatureAuthAllowed() {
+		return this.client.runGetMethod(asAddressFriendly(this.address), "is_signature_allowed").then((data) => {
+			if (data.exitCode === 0) {
+				const parsedStack = ParseStack(data.stack);
+				if (parsedStack[0]?.type === "int") return Boolean(parsedStack[0].value);
+				else throw new Error("Stack is not an int");
+			} else return false;
+		});
+	}
+	get walletId() {
+		if (this.subwalletId !== void 0) return new Promise((resolve) => {
+			resolve(WalletV5R1Id.deserialize(this.subwalletId));
+		});
+		else return this.client.runGetMethod(asAddressFriendly(this.address), "get_subwallet_id").then((data) => {
+			if (data.exitCode === 0) {
+				const parsedStack = ParseStack(data.stack);
+				if (parsedStack[0]?.type === "int") this.subwalletId = Number(parsedStack[0].value);
+				else throw new Error("Stack is not an int");
+				return WalletV5R1Id.deserialize(this.subwalletId);
+			} else return WalletV5R1Id.deserialize(defaultWalletIdV5R1);
+		});
+	}
+};
 
 //#endregion
 //#region ../walletkit/dist/esm/contracts/v4r2/WalletV4R2.js
@@ -86943,6 +88174,18 @@ var McpWalletService = class McpWalletService {
 		return this.config.contacts.resolve("default", name);
 	}
 	/**
+	* Resolve a TON DNS domain (e.g., "wallet.ton") to a wallet address
+	*/
+	async resolveDns(domain) {
+		return this.wallet.getClient().resolveDnsWallet(domain);
+	}
+	/**
+	* Reverse resolve a wallet address to a TON DNS domain
+	*/
+	async backResolveDns(address) {
+		return this.wallet.getClient().backResolveDnsWallet(address);
+	}
+	/**
 	* Close and cleanup
 	*/
 	async close() {
@@ -87544,6 +88787,97 @@ function createMcpNftTools(service) {
 	};
 }
 
+//#endregion
+//#region src/tools/dns-tools.ts
+/**
+* Copyright (c) TonTech.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+const resolveDnsSchema = z.object({ domain: z.string().min(1).describe("TON DNS domain to resolve (e.g., \"foundation.ton\")") });
+const backResolveDnsSchema = z.object({ address: z.string().min(1).describe("TON wallet address to reverse resolve") });
+function createMcpDnsTools(service) {
+	return {
+		resolve_dns: {
+			description: "Resolve a TON DNS domain (e.g., \"foundation.ton\") to a wallet address. Use this when the user provides a .ton domain instead of a raw address.",
+			inputSchema: resolveDnsSchema,
+			handler: async (args) => {
+				try {
+					const address = await service.resolveDns(args.domain);
+					if (!address) return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({
+								success: false,
+								error: `Could not resolve domain "${args.domain}". The domain may not exist or may not have a wallet record.`
+							})
+						}],
+						isError: true
+					};
+					return { content: [{
+						type: "text",
+						text: JSON.stringify({
+							success: true,
+							domain: args.domain,
+							address
+						}, null, 2)
+					}] };
+				} catch (error) {
+					return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({
+								success: false,
+								error: `Failed to resolve domain: ${error instanceof Error ? error.message : "Unknown error"}`
+							})
+						}],
+						isError: true
+					};
+				}
+			}
+		},
+		back_resolve_dns: {
+			description: "Reverse resolve a TON wallet address to its DNS domain (e.g., find the .ton domain associated with an address).",
+			inputSchema: backResolveDnsSchema,
+			handler: async (args) => {
+				try {
+					const domain = await service.backResolveDns(args.address);
+					if (!domain) return { content: [{
+						type: "text",
+						text: JSON.stringify({
+							success: true,
+							address: args.address,
+							domain: null,
+							message: "No DNS domain found for this address."
+						})
+					}] };
+					return { content: [{
+						type: "text",
+						text: JSON.stringify({
+							success: true,
+							address: args.address,
+							domain
+						}, null, 2)
+					}] };
+				} catch (error) {
+					return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({
+								success: false,
+								error: `Failed to reverse resolve address: ${error instanceof Error ? error.message : "Unknown error"}`
+							})
+						}],
+						isError: true
+					};
+				}
+			}
+		}
+	};
+}
+
 //#endregion
 //#region src/factory.ts
 /**
@@ -87597,6 +88931,7 @@ async function createTonWalletMCP(config) {
 	const swapTools = createMcpSwapTools(walletService);
 	const knownJettonsTools = createMcpKnownJettonsTools();
 	const nftTools = createMcpNftTools(walletService);
+	const dnsTools = createMcpDnsTools(walletService);
 	const registerTool = (name, tool) => {
 		server.registerTool(name, {
 			description: tool.description,
@@ -87615,6 +88950,8 @@ async function createTonWalletMCP(config) {
 	registerTool("get_nfts", nftTools.get_nfts);
 	registerTool("get_nft", nftTools.get_nft);
 	registerTool("send_nft", nftTools.send_nft);
+	registerTool("resolve_dns", dnsTools.resolve_dns);
+	registerTool("back_resolve_dns", dnsTools.back_resolve_dns);
 	return server;
 }
 /**
@@ -87626,4 +88963,169 @@ function createShutdownHandler(walletService) {
 }
 
 //#endregion
-export { McpWalletService, createShutdownHandler, createTonWalletMCP };
+//#region src/serverless.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.
+*
+*/
+/**
+* TON MCP Serverless Handler
+*
+* Provides a simple serverless-compatible function for MCP operations.
+* Credentials are extracted from request headers.
+*
+* Headers:
+*   - MNEMONIC: 24-word mnemonic phrase
+*   - PRIVATE_KEY: Hex-encoded private key (takes priority over MNEMONIC)
+*   - NETWORK: Network to use (mainnet or testnet, default: mainnet)
+*   - TONCENTER_KEY: Optional TonCenter API key
+*/
+function getHeader(headers, name) {
+	const value = headers[name] || headers[name.toLowerCase()] || headers[name.toUpperCase()];
+	if (Array.isArray(value)) return value[0];
+	return value;
+}
+function parseCredentials(headers) {
+	const privateKeyHex = getHeader(headers, "PRIVATE_KEY") || getHeader(headers, "private-key");
+	const mnemonicStr = getHeader(headers, "MNEMONIC") || getHeader(headers, "mnemonic");
+	const networkStr = getHeader(headers, "NETWORK") || getHeader(headers, "network");
+	const toncenterKey = getHeader(headers, "TONCENTER_KEY") || getHeader(headers, "toncenter-key");
+	let privateKey;
+	let mnemonic;
+	if (privateKeyHex) {
+		privateKey = Buffer.from(privateKeyHex, "hex");
+		if (privateKey.length !== 32 && privateKey.length !== 64) return null;
+		if (privateKey.length === 64) privateKey = privateKey.subarray(0, 32);
+	} else if (mnemonicStr) {
+		mnemonic = mnemonicStr.trim().split(/\s+/);
+		if (mnemonic.length !== 24) return null;
+	} else return null;
+	return {
+		mnemonic,
+		privateKey,
+		network: networkStr === "testnet" ? "testnet" : "mainnet",
+		toncenterKey
+	};
+}
+async function createWalletFromCredentials(credentials) {
+	const network = credentials.network === "mainnet" ? Network.mainnet() : Network.testnet();
+	const apiConfig = {};
+	if (credentials.toncenterKey) {
+		apiConfig.url = credentials.network === "mainnet" ? "https://toncenter.com" : "https://testnet.toncenter.com";
+		apiConfig.key = credentials.toncenterKey;
+	}
+	const kit = new TonWalletKit({
+		networks: { [network.chainId]: { apiClient: apiConfig } },
+		storage: new MemoryStorageAdapter()
+	});
+	await kit.waitForReady();
+	let signer;
+	if (credentials.privateKey) signer = await Signer.fromPrivateKey(credentials.privateKey);
+	else if (credentials.mnemonic) signer = await Signer.fromMnemonic(credentials.mnemonic, { type: "ton" });
+	else throw new Error("No valid credentials");
+	const walletAdapter = await WalletV5R1Adapter.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");
+	return {
+		wallet,
+		kit
+	};
+}
+/**
+* Create a serverless handler for MCP requests
+*
+* @example
+* ```typescript
+* // AWS Lambda
+* import { createServerlessHandler } from '@ton/mcp/serverless';
+* export const handler = createServerlessHandler();
+*
+* // Vercel
+* import { createServerlessHandler } from '@ton/mcp/serverless';
+* export default createServerlessHandler();
+* ```
+*/
+function createServerlessHandler() {
+	return async (req) => {
+		const credentials = parseCredentials(req.headers);
+		if (!credentials) return {
+			statusCode: 403,
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				error: "Forbidden",
+				message: "Missing or invalid credentials. Provide PRIVATE_KEY or MNEMONIC header."
+			})
+		};
+		let kit = null;
+		try {
+			const { wallet, kit: walletKit } = await createWalletFromCredentials(credentials);
+			kit = walletKit;
+			const server = await createTonWalletMCP({
+				wallet,
+				networks: {
+					mainnet: credentials.toncenterKey && credentials.network === "mainnet" ? { apiKey: credentials.toncenterKey } : void 0,
+					testnet: credentials.toncenterKey && credentials.network === "testnet" ? { apiKey: credentials.toncenterKey } : void 0
+				}
+			});
+			const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => crypto.randomUUID() });
+			await server.connect(transport);
+			const responseChunks = [];
+			const mockRes = {
+				writeHead: () => mockRes,
+				write: (chunk) => {
+					responseChunks.push(Buffer.from(chunk));
+					return true;
+				},
+				end: (chunk) => {
+					if (chunk) responseChunks.push(Buffer.from(chunk));
+				},
+				setHeader: () => mockRes,
+				getHeader: () => void 0,
+				on: () => mockRes
+			};
+			const mockReq = {
+				method: req.method || "POST",
+				url: req.url || "/mcp",
+				headers: req.headers,
+				on: (event, handler) => {
+					if (event === "data" && req.body) handler(typeof req.body === "string" ? req.body : JSON.stringify(req.body));
+					if (event === "end") handler();
+					return mockReq;
+				}
+			};
+			await transport.handleRequest(mockReq, mockRes);
+			const responseBody = Buffer.concat(responseChunks).toString("utf-8");
+			await transport.close();
+			await kit.close();
+			return {
+				statusCode: 200,
+				headers: { "Content-Type": "application/json" },
+				body: responseBody
+			};
+		} catch (error) {
+			if (kit) await kit.close();
+			return {
+				statusCode: 500,
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					error: "Internal Server Error",
+					message: error instanceof Error ? error.message : "Unknown error"
+				})
+			};
+		}
+	};
+}
+/**
+* Default serverless handler
+*/
+const handler = createServerlessHandler();
+
+//#endregion
+export { McpWalletService, createServerlessHandler, createShutdownHandler, createTonWalletMCP, handler };