@dynamic-labs-sdk/ton 0.0.0 → 0.22.1

package/dist/addWaasTonExtension-B8tYiMfm.esm.js

@@ -0,0 +1,664 @@
+import { WalletProviderPriority, assertDefined, consumeMfaTokenIfRequiredForAction, createBaseNetworkProvider, formatWalletProviderGroupKey, formatWalletProviderKey, getActiveNetworkIdFromLastKnownRegistry, getBuffer, getCore, getDefaultClient, getNetworkProviderBuilderRegistry, getNetworkProviderFromNetworkId, getSignedSessionId, getWalletProviderFromWalletAccount, getWalletProviderRegistry, hasExtension, parseAmountToSmallestUnit, registerExtension, switchActiveNetworkInLastKnownRegistry } from "@dynamic-labs-sdk/client/core";
+import { Address, Cell, TonClient, WalletContractV5R1, beginCell, fromNano } from "@ton/ton";
+import { DYNAMIC_WAAS_METADATA, createWaasProvider, getAllUserWaasAddressesForChain } from "@dynamic-labs-sdk/client/waas/core";
+import { MFAAction, WalletProviderEnum } from "@dynamic-labs/sdk-api-core";
+import { CHAIN } from "@tonconnect/sdk";
+import { BaseError } from "@dynamic-labs-sdk/client";
+import { SendMode, external, storeMessage, storeOutList } from "@ton/core";
+import { sha256 } from "@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 TonClient({ endpoint: rpcUrl });
+
+//#endregion
+//#region src/utils/fetchTonBalance/fetchTonBalance.ts
+/** @not-instrumented */
+const fetchTonBalance = async ({ address, client }) => {
+	try {
+		return fromNano(await client.getBalance(Address.parse(address)));
+	} catch {
+		return null;
+	}
+};
+
+//#endregion
+//#region src/utils/createTonNetworkProvider/createTonNetworkProvider.ts
+/** @not-instrumented */
+const createTonNetworkProvider = (networkData) => ({
+	...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 = getNetworkProviderBuilderRegistry(client);
+	if (networkProviderBuilderRegistry.get().get("TON")) return;
+	networkProviderBuilderRegistry.register({
+		builder: createTonNetworkProvider,
+		chain: "TON"
+	});
+};
+
+//#endregion
+//#region src/errors/TransactionExecutionFailedError.ts
+var TransactionExecutionFailedError = class extends 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: SendMode.PAY_GAS_SEPARATELY | 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 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 beginCell().endCell();
+	try {
+		return 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 = 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 = 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 WalletContractV5R1.create({
+		publicKey,
+		workchain
+	}).init;
+};
+
+//#endregion
+//#region src/errors/InvalidSignatureLengthError.ts
+var InvalidSignatureLengthError = class extends 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 = getBuffer().from(signature, "base64");
+	if (signatureBuffer.length !== 64) throw new InvalidSignatureLengthError({
+		actual: signatureBuffer.length,
+		expected: 64
+	});
+	const signingMessageCell = Cell.fromBase64(transactionData.messageBody);
+	const externalMsg = external({
+		body: beginCell().storeSlice(signingMessageCell.beginParse()).storeBuffer(signatureBuffer).endCell(),
+		to: Address.parse(transactionData.address),
+		...stateInit ? { init: stateInit } : {}
+	});
+	const externalMessage = beginCell().store(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 = getBuffer();
+	const address = 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 = getBuffer();
+	const message = generateTonConnectProofMessage({
+		address,
+		domain,
+		payload,
+		timestamp
+	});
+	const messageHash = BufferImpl.from(await sha256(message));
+	const fullMsg = BufferImpl.concat([
+		BufferImpl.from([255, 255]),
+		BufferImpl.from(TON_CONNECT_PREFIX),
+		messageHash
+	]);
+	return BufferImpl.from(await sha256(fullMsg)).toString("hex");
+};
+
+//#endregion
+//#region src/utils/getTonWalletSeqno/getTonWalletSeqno.ts
+/** @not-instrumented */
+const getTonWalletSeqno = async ({ walletAddress, client }) => {
+	const address = 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 = 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 = Address.parse(jettonMasterAddress);
+	const owner = Address.parse(ownerAddress);
+	const ownerCell = 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 = CHAIN.MAINNET }) => {
+	const validUntil = Math.floor(Date.now() / 1e3) + timeout;
+	const jettonWalletAddr = Address.parse(await getJettonWalletAddress({
+		client,
+		jettonMasterAddress,
+		ownerAddress: walletAddress
+	}));
+	const recipientAddr = Address.parse(recipientAddress);
+	const walletAddr = Address.parse(walletAddress);
+	const isTestnet = network === CHAIN.TESTNET;
+	const forwardPayloadCell = forwardPayload ? beginCell().storeUint(0, 32).storeStringTail(forwardPayload).endCell() : beginCell().endCell();
+	const jettonTransferBody = 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 = CHAIN.MAINNET }) => {
+	const walletAddr = Address.parse(walletAddress);
+	const actionsCell = beginCell().store(storeOutList(actionsArray)).endCell();
+	const actions = beginCell().storeBit(1).storeRef(actionsCell).storeBit(0).endCell();
+	const context = 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 = beginCell().storeUint(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 = CHAIN.MAINNET }) => {
+	const validUntil = Math.floor(Date.now() / 1e3) + timeout;
+	const recipientAddress = Address.parse(recipient);
+	const walletAddr = Address.parse(walletAddress);
+	const isTestnet = network === 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 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 = getWalletProviderFromWalletAccount({ walletAccount }, client);
+	if (!isTonWalletProvider(provider)) throw new NotTonProviderError({ providerKey: provider.key });
+	if (token) {
+		const rawAmount$1 = parseAmountToSmallestUnit({
+			amount,
+			decimals: token.decimals ?? DEFAULT_DECIMALS
+		});
+		return provider.sendJetton({
+			transaction: {
+				amount: rawAmount$1,
+				jettonMasterAddress: token.address,
+				recipientAddress: recipient
+			},
+			walletAccount
+		});
+	}
+	const rawAmount = parseAmountToSmallestUnit({
+		amount,
+		decimals: DEFAULT_DECIMALS
+	});
+	return provider.sendTon({
+		transaction: {
+			amount: rawAmount,
+			recipientAddress: recipient
+		},
+		walletAccount
+	});
+};
+
+//#endregion
+//#region src/errors/PublicKeyNotFoundError.ts
+var PublicKeyNotFoundError = class extends 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 = 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 = WalletProviderEnum.EmbeddedWallet;
+	const key = formatWalletProviderKey({
+		chain,
+		displayName: DYNAMIC_WAAS_METADATA.displayName,
+		walletProviderType
+	});
+	const waasProvider = createWaasProvider({
+		chain,
+		sdkClient
+	});
+	const getTonClientForActiveNetwork = async () => {
+		const { networkId } = await getActiveNetworkId();
+		return createTonClient({ rpcUrl: getNetworkProviderFromNetworkId({
+			chain: "TON",
+			networkId
+		}, sdkClient).rpcUrls.http[0] });
+	};
+	const getActiveNetworkId = async () => getActiveNetworkIdFromLastKnownRegistry({
+		client: sdkClient,
+		walletProviderKey: key
+	});
+	const switchActiveNetwork = async ({ networkId }) => switchActiveNetworkInLastKnownRegistry({
+		client: sdkClient,
+		networkId,
+		walletProviderKey: key
+	});
+	const getConnectedAddresses = async () => ({ addresses: getAllUserWaasAddressesForChain({ chain }, sdkClient) });
+	const signMessage = async ({ message, walletAccount }) => {
+		assertDefined(walletAccount, "Wallet account is required");
+		return waasProvider.signMessage({
+			message,
+			walletAccount
+		});
+	};
+	const sendTransaction = async ({ request, walletAccount }) => {
+		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: 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 || CHAIN.MAINNET,
+			seqno,
+			timeout: timeoutSeconds,
+			validUntil: request.validUntil,
+			walletAddress
+		});
+		const waasClient = await waasProvider.getWaasClient();
+		const { signature: signedSessionId } = await getSignedSessionId(sdkClient);
+		const mfaToken = await consumeMfaTokenIfRequiredForAction({ mfaAction: 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 }) => {
+		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 }) => {
+		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 }) => {
+		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: formatWalletProviderGroupKey(DYNAMIC_WAAS_METADATA.displayName),
+		key,
+		metadata: {
+			displayName: DYNAMIC_WAAS_METADATA.displayName,
+			icon: 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 = getDefaultClient()) => {
+	if (hasExtension({ extensionKey: WAAS_TON_EXTENSION_KEY }, client)) return;
+	registerExtension({ extensionKey: WAAS_TON_EXTENSION_KEY }, client);
+	registerTonNetworkProviderBuilder(client);
+	const walletProviderRegistry = getWalletProviderRegistry(client);
+	const walletProvider = createWalletProviderForWaasTon(client);
+	walletProviderRegistry.register({
+		priority: WalletProviderPriority.WALLET_SDK,
+		walletProvider
+	});
+};
+
+//#endregion
+export { prepareJettonTransfer as a, name as c, prepareTonNativeTransfer as i, version as l, isTonWalletProvider as n, NANOTON_PER_TON as o, NotTonProviderError as r, TransactionExecutionFailedError as s, addWaasTonExtension as t };
+//# sourceMappingURL=addWaasTonExtension-B8tYiMfm.esm.js.map