@dynamic-labs-sdk/ton 0.0.0 → 0.22.1

package/dist/addWaasTonExtension-Dzrb4rja.cjs.js

@@ -0,0 +1,717 @@
+let _dynamic_labs_sdk_client_core = require("@dynamic-labs-sdk/client/core");
+let _ton_ton = require("@ton/ton");
+let _dynamic_labs_sdk_client_waas_core = require("@dynamic-labs-sdk/client/waas/core");
+let _dynamic_labs_sdk_api_core = require("@dynamic-labs/sdk-api-core");
+let _tonconnect_sdk = require("@tonconnect/sdk");
+let _dynamic_labs_sdk_client = require("@dynamic-labs-sdk/client");
+let _ton_core = require("@ton/core");
+let _ton_crypto = require("@ton/crypto");
+
+//#region package.json
+var name = "@dynamic-labs-sdk/ton";
+var version = "0.22.1";
+
+//#endregion
+//#region src/utils/createTonClient/createTonClient.ts
+/** @not-instrumented */
+const createTonClient = ({ rpcUrl }) => new _ton_ton.TonClient({ endpoint: rpcUrl });
+
+//#endregion
+//#region src/utils/fetchTonBalance/fetchTonBalance.ts
+/** @not-instrumented */
+const fetchTonBalance = async ({ address, client }) => {
+	try {
+		return (0, _ton_ton.fromNano)(await client.getBalance(_ton_ton.Address.parse(address)));
+	} catch {
+		return null;
+	}
+};
+
+//#endregion
+//#region src/utils/createTonNetworkProvider/createTonNetworkProvider.ts
+/** @not-instrumented */
+const createTonNetworkProvider = (networkData) => ({
+	...(0, _dynamic_labs_sdk_client_core.createBaseNetworkProvider)("TON", networkData),
+	getBalance: async ({ address }) => ({ balance: await fetchTonBalance({
+		address,
+		client: createTonClient({ rpcUrl: networkData.rpcUrls.http[0] })
+	}) })
+});
+
+//#endregion
+//#region src/registerTonNetworkProviderBuilder/registerTonNetworkProviderBuilder.ts
+/** @not-instrumented */
+const registerTonNetworkProviderBuilder = (client) => {
+	const networkProviderBuilderRegistry = (0, _dynamic_labs_sdk_client_core.getNetworkProviderBuilderRegistry)(client);
+	if (networkProviderBuilderRegistry.get().get("TON")) return;
+	networkProviderBuilderRegistry.register({
+		builder: createTonNetworkProvider,
+		chain: "TON"
+	});
+};
+
+//#endregion
+//#region src/errors/TransactionExecutionFailedError.ts
+var TransactionExecutionFailedError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor(message) {
+		super({
+			cause: null,
+			code: "transaction_execution_failed_error",
+			details: message,
+			docsUrl: null,
+			name: "TransactionExecutionFailedError",
+			shortMessage: "Failed to execute TON transaction"
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/constants.ts
+const DEFAULT_TIMEOUT = 60;
+const DEFAULT_JETTON_GAS = BigInt(5e7);
+const NANOTON_PER_TON = BigInt(1e9);
+const TON_PROOF_PREFIX = "ton-proof-item-v2/";
+const TON_CONNECT_PREFIX = "ton-connect";
+
+//#endregion
+//#region src/utils/convertTonSendTransactionRequest/createInternalMessage/createInternalMessage.ts
+/** @not-instrumented */
+const createInternalMessage = (destAddr, amount, body, bounce, init) => ({
+	body,
+	info: {
+		bounce,
+		bounced: false,
+		createdAt: 0,
+		createdLt: BigInt(0),
+		dest: destAddr,
+		forwardFee: BigInt(0),
+		ihrDisabled: true,
+		ihrFee: BigInt(0),
+		src: null,
+		type: "internal",
+		value: { coins: amount }
+	},
+	...init && { init }
+});
+
+//#endregion
+//#region src/utils/convertTonSendTransactionRequest/createSendMsgAction/createSendMsgAction.ts
+/** @not-instrumented */
+const createSendMsgAction = (internalMessage) => ({
+	mode: _ton_core.SendMode.PAY_GAS_SEPARATELY | _ton_core.SendMode.IGNORE_ERRORS,
+	outMsg: internalMessage,
+	type: "sendMsg"
+});
+
+//#endregion
+//#region src/utils/convertTonSendTransactionRequest/determineBounceFlag/determineBounceFlag.ts
+/** @not-instrumented */
+const determineBounceFlag = (address) => !address.startsWith("UQ") && !address.startsWith("0Q");
+
+//#endregion
+//#region src/errors/InvalidBocError.ts
+var InvalidBocError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor({ cause, type }) {
+		super({
+			cause,
+			code: "invalid_boc_error",
+			docsUrl: null,
+			name: "InvalidBocError",
+			shortMessage: `Invalid ${type} BOC`
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/convertTonSendTransactionRequest/parsePayload/parsePayload.ts
+/** @not-instrumented */
+const parsePayload = (payload) => {
+	if (!payload) return (0, _ton_ton.beginCell)().endCell();
+	try {
+		return _ton_ton.Cell.fromBase64(payload);
+	} catch (e) {
+		throw new InvalidBocError({
+			cause: e instanceof Error ? e : null,
+			type: "payload"
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/convertTonSendTransactionRequest/parseStateInit/parseStateInit.ts
+/** @not-instrumented */
+const parseStateInit = (stateInit) => {
+	if (!stateInit) return;
+	try {
+		const slice = _ton_ton.Cell.fromBase64(stateInit).beginParse();
+		slice.skip(2);
+		return {
+			code: slice.loadRef(),
+			data: slice.loadRef()
+		};
+	} catch (e) {
+		throw new InvalidBocError({
+			cause: e instanceof Error ? e : null,
+			type: "stateInit"
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/convertTonSendTransactionRequest/convertTonSendTransactionRequest.ts
+/** @not-instrumented */
+const convertTonSendTransactionRequest = (request) => {
+	const actions = [];
+	for (const msg of request.messages) {
+		const destAddr = _ton_ton.Address.parse(msg.address);
+		const amount = BigInt(msg.amount);
+		const body = parsePayload(msg.payload);
+		const init = parseStateInit(msg.stateInit);
+		const internalMessage = createInternalMessage(destAddr, amount, body, determineBounceFlag(msg.address), init);
+		actions.push(createSendMsgAction(internalMessage));
+	}
+	return actions;
+};
+
+//#endregion
+//#region src/utils/createTonWalletStateInit/createTonWalletStateInit.ts
+/** @not-instrumented */
+const createTonWalletStateInit = ({ publicKey, workchain = 0 }) => {
+	return _ton_ton.WalletContractV5R1.create({
+		publicKey,
+		workchain
+	}).init;
+};
+
+//#endregion
+//#region src/errors/InvalidSignatureLengthError.ts
+var InvalidSignatureLengthError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor({ actual, expected }) {
+		super({
+			cause: null,
+			code: "invalid_signature_length_error",
+			docsUrl: null,
+			name: "InvalidSignatureLengthError",
+			shortMessage: `Invalid signature length: expected ${expected} bytes, got ${actual}`
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/executeTonTransaction/executeTonTransaction.ts
+/** @not-instrumented */
+const executeTonTransaction = async ({ transactionData, signature, client, stateInit }) => {
+	const signatureBuffer = (0, _dynamic_labs_sdk_client_core.getBuffer)().from(signature, "base64");
+	if (signatureBuffer.length !== 64) throw new InvalidSignatureLengthError({
+		actual: signatureBuffer.length,
+		expected: 64
+	});
+	const signingMessageCell = _ton_ton.Cell.fromBase64(transactionData.messageBody);
+	const externalMsg = (0, _ton_core.external)({
+		body: (0, _ton_ton.beginCell)().storeSlice(signingMessageCell.beginParse()).storeBuffer(signatureBuffer).endCell(),
+		to: _ton_ton.Address.parse(transactionData.address),
+		...stateInit ? { init: stateInit } : {}
+	});
+	const externalMessage = (0, _ton_ton.beginCell)().store((0, _ton_core.storeMessage)(externalMsg, { forceRef: true })).endCell();
+	const boc = externalMessage.toBoc();
+	await client.sendFile(boc);
+	return { transactionHash: externalMessage.hash().toString("hex") };
+};
+
+//#endregion
+//#region src/utils/generateTonConnectProofHash/generateTonConnectProofMessage/generateTonConnectProofMessage.ts
+/** @not-instrumented */
+const generateTonConnectProofMessage = ({ address: addressStr, domain, payload, timestamp }) => {
+	const BufferImpl = (0, _dynamic_labs_sdk_client_core.getBuffer)();
+	const address = _ton_ton.Address.parse(addressStr);
+	const domainBytes = BufferImpl.from(domain.value);
+	const wc = BufferImpl.alloc(4);
+	wc.writeUInt32BE(address.workChain, 0);
+	const ts = BufferImpl.alloc(8);
+	ts.writeBigUInt64LE(BigInt(timestamp), 0);
+	const dl = BufferImpl.alloc(4);
+	dl.writeUInt32LE(domain.lengthBytes, 0);
+	return BufferImpl.concat([
+		BufferImpl.from(TON_PROOF_PREFIX),
+		wc,
+		address.hash,
+		dl,
+		domainBytes,
+		ts,
+		BufferImpl.from(payload)
+	]);
+};
+
+//#endregion
+//#region src/utils/generateTonConnectProofHash/generateTonConnectProofHash.ts
+/** @not-instrumented */
+const generateTonConnectProofHash = async ({ address, domain, payload, timestamp }) => {
+	const BufferImpl = (0, _dynamic_labs_sdk_client_core.getBuffer)();
+	const message = generateTonConnectProofMessage({
+		address,
+		domain,
+		payload,
+		timestamp
+	});
+	const messageHash = BufferImpl.from(await (0, _ton_crypto.sha256)(message));
+	const fullMsg = BufferImpl.concat([
+		BufferImpl.from([255, 255]),
+		BufferImpl.from(TON_CONNECT_PREFIX),
+		messageHash
+	]);
+	return BufferImpl.from(await (0, _ton_crypto.sha256)(fullMsg)).toString("hex");
+};
+
+//#endregion
+//#region src/utils/getTonWalletSeqno/getTonWalletSeqno.ts
+/** @not-instrumented */
+const getTonWalletSeqno = async ({ walletAddress, client }) => {
+	const address = _ton_ton.Address.parse(walletAddress);
+	return (await client.runMethod(address, "seqno")).stack.readNumber();
+};
+
+//#endregion
+//#region src/utils/isTonWalletDeployed/isTonWalletDeployed.ts
+/** @not-instrumented */
+const isTonWalletDeployed = async ({ walletAddress, client }) => {
+	const address = _ton_ton.Address.parse(walletAddress);
+	return (await client.getContractState(address)).state === "active";
+};
+
+//#endregion
+//#region src/utils/getJettonWalletAddress/getJettonWalletAddress.ts
+/** @not-instrumented */
+const getJettonWalletAddress = async ({ jettonMasterAddress, ownerAddress, client }) => {
+	const masterAddress = _ton_ton.Address.parse(jettonMasterAddress);
+	const owner = _ton_ton.Address.parse(ownerAddress);
+	const ownerCell = (0, _ton_ton.beginCell)().storeAddress(owner).endCell();
+	return (await client.runMethod(masterAddress, "get_wallet_address", [{
+		cell: ownerCell,
+		type: "slice"
+	}])).stack.readAddress().toString({
+		bounceable: true,
+		testOnly: false,
+		urlSafe: true
+	});
+};
+
+//#endregion
+//#region src/utils/prepareJettonTransfer/prepareJettonTransfer.ts
+/** @not-instrumented */
+const prepareJettonTransfer = async ({ walletAddress, jettonMasterAddress, recipientAddress, jettonAmount, forwardTonAmount, client, forwardPayload = "", timeout = DEFAULT_TIMEOUT, gasAmount = DEFAULT_JETTON_GAS, network = _tonconnect_sdk.CHAIN.MAINNET }) => {
+	const validUntil = Math.floor(Date.now() / 1e3) + timeout;
+	const jettonWalletAddr = _ton_ton.Address.parse(await getJettonWalletAddress({
+		client,
+		jettonMasterAddress,
+		ownerAddress: walletAddress
+	}));
+	const recipientAddr = _ton_ton.Address.parse(recipientAddress);
+	const walletAddr = _ton_ton.Address.parse(walletAddress);
+	const isTestnet = network === _tonconnect_sdk.CHAIN.TESTNET;
+	const forwardPayloadCell = forwardPayload ? (0, _ton_ton.beginCell)().storeUint(0, 32).storeStringTail(forwardPayload).endCell() : (0, _ton_ton.beginCell)().endCell();
+	const jettonTransferBody = (0, _ton_ton.beginCell)().storeUint(260734629, 32).storeUint(0, 64).storeCoins(jettonAmount).storeAddress(recipientAddr).storeAddress(walletAddr).storeBit(0).storeCoins(forwardTonAmount).storeBit(0).storeSlice(forwardPayloadCell.beginParse()).endCell();
+	const totalAmount = forwardTonAmount + gasAmount;
+	const message = {
+		address: jettonWalletAddr.toString({
+			bounceable: true,
+			testOnly: isTestnet,
+			urlSafe: true
+		}),
+		amount: totalAmount.toString(),
+		payload: jettonTransferBody.toBoc().toString("base64")
+	};
+	return {
+		from: walletAddr.toString({
+			bounceable: false,
+			testOnly: isTestnet,
+			urlSafe: true
+		}),
+		messages: [message],
+		network,
+		validUntil
+	};
+};
+
+//#endregion
+//#region src/utils/prepareTonTransaction/prepareTonTransaction.ts
+/** @not-instrumented */
+const prepareTonTransaction = ({ actionsArray, walletAddress, seqno, validUntil, timeout, networkGlobalId = _tonconnect_sdk.CHAIN.MAINNET }) => {
+	const walletAddr = _ton_ton.Address.parse(walletAddress);
+	const actionsCell = (0, _ton_ton.beginCell)().store((0, _ton_core.storeOutList)(actionsArray)).endCell();
+	const actions = (0, _ton_ton.beginCell)().storeBit(1).storeRef(actionsCell).storeBit(0).endCell();
+	const context = (0, _ton_ton.beginCell)().storeUint(1, 1).storeInt(walletAddr.workChain, 8).storeUint(0, 8).storeUint(0, 15).endCell().beginParse().loadInt(32);
+	const walletIdValue = BigInt(networkGlobalId) ^ BigInt(context);
+	const signingMessage = (0, _ton_ton.beginCell)().storeUint(_ton_ton.WalletContractV5R1.OpCodes.auth_signed_external, 32).storeInt(walletIdValue, 32);
+	if (seqno === 0) for (let i = 0; i < 32; i++) signingMessage.storeBit(1);
+	else signingMessage.storeUint(validUntil, 32);
+	signingMessage.storeUint(seqno, 32).storeSlice(actions.beginParse());
+	const dataToSign = signingMessage.endCell();
+	const hashToSign = dataToSign.hash();
+	return {
+		hashToSign,
+		hashToSignHex: hashToSign.toString("hex"),
+		transactionData: {
+			address: walletAddress,
+			messageBody: dataToSign.toBoc().toString("base64"),
+			seqno,
+			timeout
+		}
+	};
+};
+
+//#endregion
+//#region src/utils/prepareTonNativeTransfer/prepareTonNativeTransfer.ts
+/** @not-instrumented */
+const prepareTonNativeTransfer = ({ walletAddress, recipient, amountInNanoton, timeout = DEFAULT_TIMEOUT, network = _tonconnect_sdk.CHAIN.MAINNET }) => {
+	const validUntil = Math.floor(Date.now() / 1e3) + timeout;
+	const recipientAddress = _ton_ton.Address.parse(recipient);
+	const walletAddr = _ton_ton.Address.parse(walletAddress);
+	const isTestnet = network === _tonconnect_sdk.CHAIN.TESTNET;
+	const message = {
+		address: recipientAddress.toString({
+			bounceable: false,
+			testOnly: isTestnet,
+			urlSafe: true
+		}),
+		amount: amountInNanoton
+	};
+	return {
+		from: walletAddr.toString({
+			bounceable: false,
+			testOnly: isTestnet,
+			urlSafe: true
+		}),
+		messages: [message],
+		network,
+		validUntil
+	};
+};
+
+//#endregion
+//#region src/errors/NotTonProviderError.ts
+var NotTonProviderError = class extends _dynamic_labs_sdk_client.BaseError {
+	providerKey;
+	constructor(params) {
+		super({
+			cause: null,
+			code: "not_ton_provider_error",
+			docsUrl: null,
+			name: "NotTonProviderError",
+			shortMessage: "Provider is not a TON wallet provider"
+		});
+		this.providerKey = params.providerKey;
+	}
+};
+
+//#endregion
+//#region src/isTonWalletProvider/isTonWalletProvider.ts
+/**
+* Type guard function to check if a wallet provider is a TON wallet provider.
+*
+* @param provider - The wallet provider to check.
+* @returns True if the wallet provider is a TON wallet provider, false otherwise.
+* @not-instrumented
+*/
+const isTonWalletProvider = (provider) => provider.chain === "TON";
+
+//#endregion
+//#region src/utils/tonTransferAmount/tonTransferAmount.ts
+const DEFAULT_DECIMALS = 9;
+/** @not-instrumented */
+const tonTransferAmount = async ({ amount, recipient, token, walletAccount }, client) => {
+	const provider = (0, _dynamic_labs_sdk_client_core.getWalletProviderFromWalletAccount)({ walletAccount }, client);
+	if (!isTonWalletProvider(provider)) throw new NotTonProviderError({ providerKey: provider.key });
+	if (token) {
+		const rawAmount$1 = (0, _dynamic_labs_sdk_client_core.parseAmountToSmallestUnit)({
+			amount,
+			decimals: token.decimals ?? DEFAULT_DECIMALS
+		});
+		return provider.sendJetton({
+			transaction: {
+				amount: rawAmount$1,
+				jettonMasterAddress: token.address,
+				recipientAddress: recipient
+			},
+			walletAccount
+		});
+	}
+	const rawAmount = (0, _dynamic_labs_sdk_client_core.parseAmountToSmallestUnit)({
+		amount,
+		decimals: DEFAULT_DECIMALS
+	});
+	return provider.sendTon({
+		transaction: {
+			amount: rawAmount,
+			recipientAddress: recipient
+		},
+		walletAccount
+	});
+};
+
+//#endregion
+//#region src/errors/PublicKeyNotFoundError.ts
+var PublicKeyNotFoundError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor(address) {
+		super({
+			cause: null,
+			code: "public_key_not_found_error",
+			docsUrl: null,
+			name: "PublicKeyNotFoundError",
+			shortMessage: `No public key found for address ${address}`
+		});
+	}
+};
+
+//#endregion
+//#region src/waas/utils/getPublicKeyForWalletAccount/getPublicKeyForWalletAccount.ts
+/**
+* Gets the public key for a wallet account from the user's verified credentials
+* @not-instrumented
+*/
+const getPublicKeyForWalletAccount = (walletAccount, client) => {
+	const user = (0, _dynamic_labs_sdk_client_core.getCore)(client).state.get().user;
+	for (const credential of user?.verifiedCredentials ?? []) {
+		const additionalAddress = credential.walletAdditionalAddresses?.find((addr) => addr.address === walletAccount.address);
+		if (additionalAddress?.publicKey) return additionalAddress.publicKey;
+	}
+	throw new PublicKeyNotFoundError(walletAccount.address);
+};
+
+//#endregion
+//#region src/waas/utils/createWalletProviderForWaasTon/createWalletProviderForWaasTon.ts
+/** @not-instrumented */
+const createWalletProviderForWaasTon = (sdkClient) => {
+	const chain = "TON";
+	const walletProviderType = _dynamic_labs_sdk_api_core.WalletProviderEnum.EmbeddedWallet;
+	const key = (0, _dynamic_labs_sdk_client_core.formatWalletProviderKey)({
+		chain,
+		displayName: _dynamic_labs_sdk_client_waas_core.DYNAMIC_WAAS_METADATA.displayName,
+		walletProviderType
+	});
+	const waasProvider = (0, _dynamic_labs_sdk_client_waas_core.createWaasProvider)({
+		chain,
+		sdkClient
+	});
+	const getTonClientForActiveNetwork = async () => {
+		const { networkId } = await getActiveNetworkId();
+		return createTonClient({ rpcUrl: (0, _dynamic_labs_sdk_client_core.getNetworkProviderFromNetworkId)({
+			chain: "TON",
+			networkId
+		}, sdkClient).rpcUrls.http[0] });
+	};
+	const getActiveNetworkId = async () => (0, _dynamic_labs_sdk_client_core.getActiveNetworkIdFromLastKnownRegistry)({
+		client: sdkClient,
+		walletProviderKey: key
+	});
+	const switchActiveNetwork = async ({ networkId }) => (0, _dynamic_labs_sdk_client_core.switchActiveNetworkInLastKnownRegistry)({
+		client: sdkClient,
+		networkId,
+		walletProviderKey: key
+	});
+	const getConnectedAddresses = async () => ({ addresses: (0, _dynamic_labs_sdk_client_waas_core.getAllUserWaasAddressesForChain)({ chain }, sdkClient) });
+	const signMessage = async ({ message, walletAccount }) => {
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(walletAccount, "Wallet account is required");
+		return waasProvider.signMessage({
+			message,
+			walletAccount
+		});
+	};
+	const sendTransaction = async ({ request, walletAccount }) => {
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(walletAccount, "Wallet account is required");
+		const client = await getTonClientForActiveNetwork();
+		const walletAddress = request.from || walletAccount.address;
+		const deployed = await isTonWalletDeployed({
+			client,
+			walletAddress
+		});
+		const seqno = deployed ? await getTonWalletSeqno({
+			client,
+			walletAddress
+		}) : 0;
+		const publicKeyHex = getPublicKeyForWalletAccount(walletAccount, sdkClient);
+		const stateInit = deployed ? void 0 : createTonWalletStateInit({
+			publicKey: (0, _dynamic_labs_sdk_client_core.getBuffer)().from(publicKeyHex, "hex"),
+			workchain: 0
+		});
+		const actionsArray = convertTonSendTransactionRequest(request);
+		const timeoutSeconds = request.validUntil - Math.floor(Date.now() / 1e3);
+		if (timeoutSeconds <= 0) throw new TransactionExecutionFailedError("Transaction validUntil is in the past");
+		const { hashToSignHex, transactionData } = prepareTonTransaction({
+			actionsArray,
+			networkGlobalId: request.network || _tonconnect_sdk.CHAIN.MAINNET,
+			seqno,
+			timeout: timeoutSeconds,
+			validUntil: request.validUntil,
+			walletAddress
+		});
+		const waasClient = await waasProvider.getWaasClient();
+		const { signature: signedSessionId } = await (0, _dynamic_labs_sdk_client_core.getSignedSessionId)(sdkClient);
+		const mfaToken = await (0, _dynamic_labs_sdk_client_core.consumeMfaTokenIfRequiredForAction)({ mfaAction: _dynamic_labs_sdk_api_core.MFAAction.WalletWaasSign }, sdkClient);
+		return executeTonTransaction({
+			client,
+			signature: await waasClient.signTransaction({
+				authToken: sdkClient.token ?? void 0,
+				mfaToken,
+				senderAddress: walletAccount.address,
+				signedSessionId,
+				transaction: hashToSignHex
+			}),
+			stateInit,
+			transactionData
+		});
+	};
+	const sendTon = async ({ transaction, walletAccount }) => {
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(walletAccount, "Wallet account is required");
+		return sendTransaction({
+			request: prepareTonNativeTransfer({
+				amountInNanoton: transaction.amount.toString(),
+				recipient: transaction.recipientAddress,
+				timeout: DEFAULT_TIMEOUT,
+				walletAddress: walletAccount.address
+			}),
+			walletAccount
+		});
+	};
+	const sendJetton = async ({ transaction, walletAccount }) => {
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(walletAccount, "Wallet account is required");
+		return sendTransaction({
+			request: await prepareJettonTransfer({
+				client: await getTonClientForActiveNetwork(),
+				forwardTonAmount: transaction.forwardTonAmount ?? BigInt(0),
+				gasAmount: transaction.gasAmount ?? DEFAULT_JETTON_GAS,
+				jettonAmount: transaction.amount,
+				jettonMasterAddress: transaction.jettonMasterAddress,
+				recipientAddress: transaction.recipientAddress,
+				timeout: DEFAULT_TIMEOUT,
+				walletAddress: walletAccount.address
+			}),
+			walletAccount
+		});
+	};
+	const generateTonConnectProof = async ({ payload, walletAccount }) => {
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(walletAccount, "Wallet account is required");
+		const host = globalThis.location?.host || "";
+		const timestamp = Math.floor(Date.now() / 1e3);
+		const domain = {
+			lengthBytes: new TextEncoder().encode(host).length,
+			value: host
+		};
+		const { signature } = await signMessage({
+			message: await generateTonConnectProofHash({
+				address: walletAccount.address,
+				domain,
+				payload,
+				timestamp
+			}),
+			walletAccount
+		});
+		return {
+			address: walletAccount.address,
+			domain,
+			payload,
+			signature,
+			timestamp
+		};
+	};
+	return {
+		...waasProvider,
+		chain,
+		generateTonConnectProof,
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: (0, _dynamic_labs_sdk_client_core.formatWalletProviderGroupKey)(_dynamic_labs_sdk_client_waas_core.DYNAMIC_WAAS_METADATA.displayName),
+		key,
+		metadata: {
+			displayName: _dynamic_labs_sdk_client_waas_core.DYNAMIC_WAAS_METADATA.displayName,
+			icon: _dynamic_labs_sdk_client_waas_core.DYNAMIC_WAAS_METADATA.icon
+		},
+		sendJetton,
+		sendTon,
+		sendTransaction,
+		signMessage,
+		switchActiveNetwork,
+		transferAmount: (args) => tonTransferAmount(args, sdkClient),
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/waas/addWaasTonExtension/addWaasTonExtension.ts
+const WAAS_TON_EXTENSION_KEY = "waasTon";
+/**
+* Adds the Dynamic WaaS (Wallet as a Service) TON extension to the Dynamic client.
+*
+* This extension enables embedded wallet functionality for the TON blockchain,
+* allowing users to have wallets managed by Dynamic's infrastructure.
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @not-instrumented
+*/
+const addWaasTonExtension = (client = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
+	if ((0, _dynamic_labs_sdk_client_core.hasExtension)({ extensionKey: WAAS_TON_EXTENSION_KEY }, client)) return;
+	(0, _dynamic_labs_sdk_client_core.registerExtension)({ extensionKey: WAAS_TON_EXTENSION_KEY }, client);
+	registerTonNetworkProviderBuilder(client);
+	const walletProviderRegistry = (0, _dynamic_labs_sdk_client_core.getWalletProviderRegistry)(client);
+	const walletProvider = createWalletProviderForWaasTon(client);
+	walletProviderRegistry.register({
+		priority: _dynamic_labs_sdk_client_core.WalletProviderPriority.WALLET_SDK,
+		walletProvider
+	});
+};
+
+//#endregion
+Object.defineProperty(exports, 'NANOTON_PER_TON', {
+  enumerable: true,
+  get: function () {
+    return NANOTON_PER_TON;
+  }
+});
+Object.defineProperty(exports, 'NotTonProviderError', {
+  enumerable: true,
+  get: function () {
+    return NotTonProviderError;
+  }
+});
+Object.defineProperty(exports, 'TransactionExecutionFailedError', {
+  enumerable: true,
+  get: function () {
+    return TransactionExecutionFailedError;
+  }
+});
+Object.defineProperty(exports, 'addWaasTonExtension', {
+  enumerable: true,
+  get: function () {
+    return addWaasTonExtension;
+  }
+});
+Object.defineProperty(exports, 'isTonWalletProvider', {
+  enumerable: true,
+  get: function () {
+    return isTonWalletProvider;
+  }
+});
+Object.defineProperty(exports, 'name', {
+  enumerable: true,
+  get: function () {
+    return name;
+  }
+});
+Object.defineProperty(exports, 'prepareJettonTransfer', {
+  enumerable: true,
+  get: function () {
+    return prepareJettonTransfer;
+  }
+});
+Object.defineProperty(exports, 'prepareTonNativeTransfer', {
+  enumerable: true,
+  get: function () {
+    return prepareTonNativeTransfer;
+  }
+});
+Object.defineProperty(exports, 'version', {
+  enumerable: true,
+  get: function () {
+    return version;
+  }
+});
+//# sourceMappingURL=addWaasTonExtension-Dzrb4rja.cjs.js.map