teleton 0.1.9 → 0.1.11

package/dist/{chunk-7AUS3OYB.js → chunk-4UDOZME7.js}

@@ -3548,10 +3548,10 @@ async function generateWallet() {
     workchain: 0,
     publicKey: keyPair.publicKey
   });
-  const address = wallet.address.toString({ bounceable: true, testOnly: false });
+  const address4 = wallet.address.toString({ bounceable: true, testOnly: false });
   return {
     version: "w5r1",
-    address,
+    address: address4,
     publicKey: keyPair.publicKey.toString("hex"),
     mnemonic,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -3590,10 +3590,10 @@ async function importWallet(mnemonic) {
     workchain: 0,
     publicKey: keyPair.publicKey
   });
-  const address = wallet.address.toString({ bounceable: true, testOnly: false });
+  const address4 = wallet.address.toString({ bounceable: true, testOnly: false });
   return {
     version: "w5r1",
-    address,
+    address: address4,
     publicKey: keyPair.publicKey.toString("hex"),
     mnemonic,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -3603,12 +3603,12 @@ function getWalletAddress() {
   const wallet = loadWallet();
   return wallet?.address || null;
 }
-async function getWalletBalance(address) {
+async function getWalletBalance(address4) {
   try {
     const endpoint = await getHttpEndpoint({ network: "mainnet" });
     const client = new TonClient({ endpoint });
-    const { Address: Address17 } = await import("@ton/core");
-    const addressObj = Address17.parse(address);
+    const { Address: Address20 } = await import("@ton/core");
+    const addressObj = Address20.parse(address4);
     const balance = await client.getBalance(addressObj);
     const balanceFormatted = fromNano(balance);
     return {
@@ -3953,12 +3953,12 @@ Usage:
    * /wallet - Check TON wallet balance
    */
   async handleWalletCommand() {
-    const address = getWalletAddress();
-    if (!address) return "\u274C No wallet configured.";
-    const result = await getWalletBalance(address);
+    const address4 = getWalletAddress();
+    if (!address4) return "\u274C No wallet configured.";
+    const result = await getWalletBalance(address4);
     if (!result) return "\u274C Failed to fetch balance.";
     return `\u{1F48E} **${result.balance} TON**
-\u{1F4CD} \`${address}\``;
+\u{1F4CD} \`${address4}\``;
   }
   /**
    * /help - Show available commands
@@ -4183,8 +4183,8 @@ var MarketScraperService = class {
    * Currently not implemented
    * Would require modifications to support single-collection mode
    */
-  async scrapeSingleCollection(address) {
-    console.log(`\u{1F504} Single collection scrape not yet implemented for ${address}`);
+  async scrapeSingleCollection(address4) {
+    console.log(`\u{1F504} Single collection scrape not yet implemented for ${address4}`);
     return {
       success: false,
       error: "Single collection scrape not yet implemented"
@@ -10571,8 +10571,8 @@ var tonGetAddressTool = {
 };
 var tonGetAddressExecutor = async (params, context) => {
   try {
-    const address = getWalletAddress();
-    if (!address) {
+    const address4 = getWalletAddress();
+    if (!address4) {
       return {
         success: false,
         error: "Wallet not initialized. Contact admin to generate wallet."
@@ -10581,8 +10581,8 @@ var tonGetAddressExecutor = async (params, context) => {
     return {
       success: true,
       data: {
-        address,
-        message: `Your TON wallet address: ${address}`
+        address: address4,
+        message: `Your TON wallet address: ${address4}`
       }
     };
   } catch (error) {
@@ -10604,14 +10604,14 @@ var tonGetBalanceTool = {
 };
 var tonGetBalanceExecutor = async (params, context) => {
   try {
-    const address = getWalletAddress();
-    if (!address) {
+    const address4 = getWalletAddress();
+    if (!address4) {
       return {
         success: false,
         error: "Wallet not initialized. Contact admin to generate wallet."
       };
     }
-    const balance = await getWalletBalance(address);
+    const balance = await getWalletBalance(address4);
     if (!balance) {
       return {
         success: false,
@@ -10621,7 +10621,7 @@ var tonGetBalanceExecutor = async (params, context) => {
     return {
       success: true,
       data: {
-        address,
+        address: address4,
         balance: balance.balance,
         balanceNano: balance.balanceNano,
         message: `Your wallet balance: ${balance.balance} TON`,
@@ -10825,14 +10825,14 @@ function parseMessageBody(body) {
 }
 var tonGetTransactionsExecutor = async (params, context) => {
   try {
-    const { address, limit = 10 } = params;
+    const { address: address4, limit = 10 } = params;
     let addressObj;
     try {
-      addressObj = Address2.parse(address);
+      addressObj = Address2.parse(address4);
     } catch (e) {
       return {
         success: false,
-        error: `Invalid address: ${address}`
+        error: `Invalid address: ${address4}`
       };
     }
     const endpoint = await getHttpEndpoint3({ network: "mainnet" });
@@ -10962,7 +10962,7 @@ var tonGetTransactionsExecutor = async (params, context) => {
     return {
       success: true,
       data: {
-        address,
+        address: address4,
         transactions: formatted
       }
     };
@@ -12016,10 +12016,1971 @@ var jettonBalancesExecutor = async (params, context) => {
 // src/agent/tools/jetton/swap.ts
 import { Type as Type81 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey7 } from "@ton/crypto";
-import { WalletContractV5R1 as WalletContractV5R17, TonClient as TonClient9, toNano as toNano6, internal as internal6 } from "@ton/ton";
+import { WalletContractV5R1 as WalletContractV5R17, TonClient as TonClient9, toNano as toNano18, internal as internal6 } from "@ton/ton";
 import { SendMode as SendMode6 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint9 } from "@orbs-network/ton-access";
-import { DEX, pTON } from "@ston-fi/sdk";
+
+// node_modules/@ston-fi/sdk/dist/chunk-HNMPFVZW.js
+import { Address as Address8, address } from "@ton/ton";
+function toAddress(addressValue) {
+  if (addressValue instanceof Address8) {
+    return addressValue;
+  }
+  return address(addressValue.toString());
+}
+
+// node_modules/@ston-fi/sdk/dist/chunk-3QLJQGLC.js
+var Contract = class {
+  address;
+  constructor(address4, options) {
+    this.address = toAddress(address4);
+  }
+  static create(address4) {
+    return new this(address4);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-ZZPZXK37.js
+import { beginCell as beginCell4 } from "@ton/ton";
+var JettonMinter = class extends Contract {
+  async getWalletAddress(provider, ownerAddress) {
+    const result = await provider.get("get_wallet_address", [
+      {
+        type: "slice",
+        cell: beginCell4().storeAddress(toAddress(ownerAddress)).endCell()
+      }
+    ]);
+    return result.stack.readAddress();
+  }
+  async getJettonData(provider) {
+    const result = await provider.get("get_jetton_data", []);
+    const jettonData = {
+      totalSupply: result.stack.readBigNumber(),
+      canIncSupply: Boolean(result.stack.readNumber()),
+      adminAddress: result.stack.readAddressOpt(),
+      contentRaw: result.stack.readCell(),
+      jettonWalletCode: result.stack.readCell()
+    };
+    return jettonData;
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-6OHMCTKH.js
+var JettonWallet = class extends Contract {
+  async getBalance(provider) {
+    const state = await provider.getState();
+    if (state.state.type !== "active") {
+      return BigInt(0);
+    }
+    const { balance } = await this.getWalletData(provider);
+    return balance;
+  }
+  async getWalletData(provider) {
+    const result = await provider.get("get_wallet_data", []);
+    return {
+      balance: result.stack.readBigNumber(),
+      ownerAddress: result.stack.readAddress(),
+      jettonMasterAddress: result.stack.readAddress(),
+      jettonWalletCode: result.stack.readCell()
+    };
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-7OWKQS2D.js
+import { beginCell as beginCell5 } from "@ton/ton";
+function createJettonTransferMessage(params) {
+  const builder = beginCell5();
+  builder.storeUint(260734629, 32);
+  builder.storeUint(params.queryId, 64);
+  builder.storeCoins(BigInt(params.amount));
+  builder.storeAddress(toAddress(params.destination));
+  builder.storeAddress(
+    params.responseDestination ? toAddress(params.responseDestination) : void 0
+  );
+  if (params.customPayload) {
+    builder.storeBit(true);
+    builder.storeRef(params.customPayload);
+  } else {
+    builder.storeBit(false);
+  }
+  builder.storeCoins(BigInt(params.forwardTonAmount));
+  if (params.forwardPayload) {
+    builder.storeBit(true);
+    builder.storeRef(params.forwardPayload);
+  } else {
+    builder.storeBit(false);
+  }
+  return builder.endCell();
+}
+
+// node_modules/@ston-fi/sdk/dist/chunk-MEGJZKYP.js
+var pTON_VERSION = {
+  v1: "v1",
+  v2_1: "v2_1"
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-G6J4NHH6.js
+var DEX_OP_CODES = {
+  SWAP: 630424929,
+  PROVIDE_LP: 4244235663,
+  DIRECT_ADD_LIQUIDITY: 1291331587,
+  REFUND_ME: 200537159,
+  RESET_GAS: 1117846339,
+  COLLECT_FEES: 533429565,
+  BURN: 1499400124
+};
+var ROUTER_ADDRESS = "EQB3ncyBUTjZUA5EnFKR5_EnOMI9V1tTEAAPaiU71gc4TiUt";
+
+// node_modules/@ston-fi/sdk/dist/chunk-4KVHWM75.js
+var DEX_VERSION = {
+  v1: "v1",
+  /**
+   * We recommend using `v2_1` contracts
+   * only for withdrawal functionality on already deployed contracts.
+   * @see https://t.me/stonfidex/712
+   */
+  v2_1: "v2_1",
+  v2_2: "v2_2"
+};
+var DEX_TYPE = {
+  CPI: "constant_product",
+  Stable: "stableswap",
+  WCPI: "weighted_const_product",
+  WStable: "weighted_stableswap"
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-ZPXELCC2.js
+import {
+  beginCell as beginCell6,
+  toNano as toNano6
+} from "@ton/ton";
+var LpAccountV1 = class _LpAccountV1 extends Contract {
+  static version = DEX_VERSION.v1;
+  static gasConstants = {
+    refund: toNano6("0.3"),
+    directAddLp: toNano6("0.3"),
+    resetGas: toNano6("0.3")
+  };
+  gasConstants;
+  constructor(address4, { gasConstants, ...options } = {}) {
+    super(address4, options);
+    this.gasConstants = {
+      ..._LpAccountV1.gasConstants,
+      ...gasConstants
+    };
+  }
+  async createRefundBody(params) {
+    return beginCell6().storeUint(DEX_OP_CODES.REFUND_ME, 32).storeUint(params?.queryId ?? 0, 64).endCell();
+  }
+  /**
+   * Build all data required to execute a `refund_me` transaction.
+   *
+   * @param {bigint | number | string | undefined} params.gasAmount - Optional; Custom transaction gas amount (in nanoTons)
+   * @param {bigint | number | undefined} params.queryId - Optional; query id
+   *
+   * @returns {SenderArguments} all data required to execute a `refund_me` transaction.
+   */
+  async getRefundTxParams(provider, params) {
+    const to = this.address;
+    const body = await this.createRefundBody({
+      queryId: params?.queryId
+    });
+    const value = BigInt(params?.gasAmount ?? this.gasConstants.refund);
+    return { to, value, body };
+  }
+  async sendRefund(provider, via, params) {
+    const txParams = await this.getRefundTxParams(provider, params);
+    return via.send(txParams);
+  }
+  async createDirectAddLiquidityBody(params) {
+    return beginCell6().storeUint(DEX_OP_CODES.DIRECT_ADD_LIQUIDITY, 32).storeUint(params?.queryId ?? 0, 64).storeCoins(BigInt(params.amount0)).storeCoins(BigInt(params.amount1)).storeCoins(BigInt(params.minimumLpToMint ?? 1)).endCell();
+  }
+  /**
+   * Build all data required to execute a `direct_add_liquidity` transaction.
+   *
+   * @param {bigint | number} params.amount0 - Amount of the first Jetton tokens (in basic token units)
+   * @param {bigint | number} params.amount1 - Amount of the second Jetton tokens (in basic token units)
+   * @param {bigint | number | undefined} params.minimumLpToMint - Optional; minimum amount of received liquidity tokens (in basic token units)
+   * @param {bigint | number | string | undefined} params.gasAmount - Optional; Custom transaction gas amount (in nanoTons)
+   * @param {bigint | number | undefined} params.queryId - Optional; query id
+   *
+   * @returns {SenderArguments} all data required to execute a `direct_add_liquidity` transaction.
+   */
+  async getDirectAddLiquidityTxParams(provider, params) {
+    const to = this.address;
+    const body = await this.createDirectAddLiquidityBody({
+      amount0: params.amount0,
+      amount1: params.amount1,
+      minimumLpToMint: params.minimumLpToMint,
+      queryId: params.queryId
+    });
+    const value = BigInt(params.gasAmount ?? this.gasConstants.directAddLp);
+    return { to, value, body };
+  }
+  async sendDirectAddLiquidity(provider, via, params) {
+    const txParams = await this.getDirectAddLiquidityTxParams(provider, params);
+    return via.send(txParams);
+  }
+  async createResetGasBody(params) {
+    return beginCell6().storeUint(DEX_OP_CODES.RESET_GAS, 32).storeUint(params?.queryId ?? 0, 64).endCell();
+  }
+  /**
+   * Build all data required to execute a `reset_gas` transaction.
+   *
+   * @param {bigint | number | string | undefined} params.gasAmount - Optional; Custom transaction gas amount (in nanoTons)
+   * @param {bigint | number | undefined} params.queryId - Optional; query id
+   *
+   * @returns {SenderArguments} all data required to execute a `reset_gas` transaction.
+   */
+  async getResetGasTxParams(provider, params) {
+    const to = this.address;
+    const body = await this.createResetGasBody({
+      queryId: params?.queryId
+    });
+    const value = BigInt(params?.gasAmount ?? this.gasConstants.resetGas);
+    return { to, value, body };
+  }
+  async sendResetGas(provider, via, params) {
+    const txParams = await this.getResetGasTxParams(provider, params);
+    return via.send(txParams);
+  }
+  /**
+   * @returns structure containing current state of the lp account.
+   */
+  async getLpAccountData(provider) {
+    const result = await provider.get("get_lp_account_data", []);
+    return {
+      userAddress: result.stack.readAddress(),
+      poolAddress: result.stack.readAddress(),
+      amount0: result.stack.readBigNumber(),
+      amount1: result.stack.readBigNumber()
+    };
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-OREDCISV.js
+import {
+  beginCell as beginCell7,
+  toNano as toNano7
+} from "@ton/ton";
+var PoolV1 = class _PoolV1 extends JettonMinter {
+  static version = DEX_VERSION.v1;
+  static gasConstants = {
+    collectFees: toNano7("1.1"),
+    burn: toNano7("0.5")
+  };
+  gasConstants;
+  constructor(address4, { gasConstants, ...options } = {}) {
+    super(address4, options);
+    this.gasConstants = {
+      ..._PoolV1.gasConstants,
+      ...gasConstants
+    };
+  }
+  async createCollectFeesBody(params) {
+    return beginCell7().storeUint(DEX_OP_CODES.COLLECT_FEES, 32).storeUint(params?.queryId ?? 0, 64).endCell();
+  }
+  /**
+   * Build all data required to execute a `collect_fees` transaction.
+   *
+   * @param {bigint | number | string | undefined} params.gasAmount - Optional; Custom transaction gas amount (in nanoTons)
+   * @param {bigint | number | undefined} params.queryId - Optional; query id
+   *
+   * @returns {SenderArguments} all data required to execute a `collect_fees` transaction.
+   */
+  async getCollectFeeTxParams(provider, params) {
+    const to = this.address;
+    const body = await this.createCollectFeesBody({
+      queryId: params?.queryId
+    });
+    const value = BigInt(params?.gasAmount ?? this.gasConstants.collectFees);
+    return { to, value, body };
+  }
+  async sendCollectFees(provider, via, params) {
+    const txParams = await this.getCollectFeeTxParams(provider, params);
+    return via.send(txParams);
+  }
+  async createBurnBody(params) {
+    return beginCell7().storeUint(DEX_OP_CODES.BURN, 32).storeUint(params?.queryId ?? 0, 64).storeCoins(BigInt(params.amount)).storeAddress(toAddress(params.responseAddress)).storeMaybeRef().endCell();
+  }
+  /**
+   * Build all data required to execute a `burn` transaction.
+   *
+   * @param {bigint | number} params.amount - Amount of lp tokens to burn (in basic token units)
+   * @param {Address | string} params.responseAddress - Address of a user
+   * @param {bigint | number | string | undefined} params.gasAmount - Optional; Custom transaction gas amount (in nanoTons)
+   * @param {bigint | number | undefined} params.queryId - Optional; query id
+   *
+   * @returns {SenderArguments} all data required to execute a `burn` transaction.
+   */
+  async getBurnTxParams(provider, params) {
+    const [to, body] = await Promise.all([
+      this.getWalletAddress(provider, params.responseAddress),
+      this.createBurnBody({
+        amount: params.amount,
+        responseAddress: params.responseAddress,
+        queryId: params.queryId
+      })
+    ]);
+    const value = BigInt(params.gasAmount ?? this.gasConstants.burn);
+    return { to, value, body };
+  }
+  async sendBurn(provider, via, params) {
+    const txParams = await this.getBurnTxParams(provider, params);
+    return via.send(txParams);
+  }
+  /**
+   * Estimate the expected result of the amount of jettonWallet tokens swapped to the other token of the pool
+   *
+   * @param {bigint | number} params.amount - Amount of tokens to swap (in basic token units)
+   * @param {Address | string} params.jettonWallet - jetton wallet address (owned by the router)
+   *
+   * @returns structure with the expected result of a token swap
+   */
+  async getExpectedOutputs(provider, params) {
+    const result = await provider.get("get_expected_outputs", [
+      { type: "int", value: BigInt(params.amount) },
+      {
+        type: "slice",
+        cell: beginCell7().storeAddress(toAddress(params.jettonWallet)).endCell()
+      }
+    ]);
+    return {
+      jettonToReceive: result.stack.readBigNumber(),
+      protocolFeePaid: result.stack.readBigNumber(),
+      refFeePaid: result.stack.readBigNumber()
+    };
+  }
+  /**
+   * Estimate an expected amount of lp tokens minted when providing liquidity.
+   *
+   * @param {bigint | number} params.amount0 - Amount of tokens for the first Jetton (in basic token units)
+   * @param {bigint | number} params.amount1 - Amount of tokens for the second Jetton (in basic token units)
+   *
+   * @returns {bigint} an estimated amount of liquidity tokens to be minted
+   */
+  async getExpectedTokens(provider, params) {
+    const result = await provider.get("get_expected_tokens", [
+      { type: "int", value: BigInt(params.amount0) },
+      { type: "int", value: BigInt(params.amount1) }
+    ]);
+    return result.stack.readBigNumber();
+  }
+  /**
+   * Estimate expected liquidity freed upon burning liquidity tokens.
+   *
+   * @param {bigint | number} params.jettonAmount - Amount of liquidity tokens (in basic token units)
+   *
+   * @returns structure with expected freed liquidity
+   */
+  async getExpectedLiquidity(provider, params) {
+    const result = await provider.get("get_expected_liquidity", [
+      { type: "int", value: BigInt(params.jettonAmount) }
+    ]);
+    return {
+      amount0: result.stack.readBigNumber(),
+      amount1: result.stack.readBigNumber()
+    };
+  }
+  /**
+   * @param {Address | string} params.ownerAddress - Address of a user
+   *
+   * @returns {Address} the lp account address of a user
+   */
+  async getLpAccountAddress(provider, params) {
+    const result = await provider.get("get_lp_account_address", [
+      {
+        type: "slice",
+        cell: beginCell7().storeAddress(toAddress(params.ownerAddress)).endCell()
+      }
+    ]);
+    return result.stack.readAddress();
+  }
+  /**
+   * @param {Address | string} params.ownerAddress - Address of a user
+   *
+   * @returns {JettonWallet} a JettonWallet instance with address returned by getJettonWalletAddress
+   */
+  async getJettonWallet(provider, params) {
+    const jettonWalletAddress = await this.getWalletAddress(
+      provider,
+      params.ownerAddress
+    );
+    return JettonWallet.create(jettonWalletAddress);
+  }
+  /**
+   * @returns structure containing current state of the pool.
+   */
+  async getPoolData(provider) {
+    const result = await provider.get("get_pool_data", []);
+    return {
+      reserve0: result.stack.readBigNumber(),
+      reserve1: result.stack.readBigNumber(),
+      token0WalletAddress: result.stack.readAddress(),
+      token1WalletAddress: result.stack.readAddress(),
+      lpFee: result.stack.readBigNumber(),
+      protocolFee: result.stack.readBigNumber(),
+      refFee: result.stack.readBigNumber(),
+      protocolFeeAddress: result.stack.readAddress(),
+      collectedToken0ProtocolFee: result.stack.readBigNumber(),
+      collectedToken1ProtocolFee: result.stack.readBigNumber()
+    };
+  }
+  /**
+   * @param {Address | string} params.ownerAddress - Address of a user
+   *
+   * @returns {LpAccount} object for address returned by getLpAccountAddress
+   */
+  async getLpAccount(provider, params) {
+    const lpAccountAddress = await this.getLpAccountAddress(provider, params);
+    return LpAccountV1.create(lpAccountAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-BZOLUFTK.js
+import { Address as Address9 } from "@ton/ton";
+var HOLE_ADDRESS = Address9.parse(
+  "0:0000000000000000000000000000000000000000000000000000000000000000"
+);
+
+// node_modules/@ston-fi/sdk/dist/chunk-VGVCKGFT.js
+var UnmatchedPtonVersion = class extends Error {
+  constructor({
+    expected,
+    received
+  }) {
+    super(
+      `The version of the provided pTON (${received}) does not match the expected version (${expected})`
+    );
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-QLGZ6VJX.js
+import {
+  address as address2,
+  beginCell as beginCell8,
+  toNano as toNano8
+} from "@ton/ton";
+var RouterV1 = class _RouterV1 extends Contract {
+  static version = DEX_VERSION.v1;
+  static address = address2(ROUTER_ADDRESS);
+  static gasConstants = {
+    swapJettonToJetton: {
+      gasAmount: toNano8("0.22"),
+      forwardGasAmount: toNano8("0.175")
+    },
+    swapJettonToTon: {
+      gasAmount: toNano8("0.17"),
+      forwardGasAmount: toNano8("0.125")
+    },
+    swapTonToJetton: {
+      forwardGasAmount: toNano8("0.185")
+    },
+    provideLpJetton: {
+      gasAmount: toNano8("0.3"),
+      forwardGasAmount: toNano8("0.24")
+    },
+    provideLpTon: {
+      forwardGasAmount: toNano8("0.26")
+    }
+  };
+  gasConstants;
+  constructor(address22 = _RouterV1.address, { gasConstants, ...options } = {}) {
+    super(address22, options);
+    this.gasConstants = {
+      ..._RouterV1.gasConstants,
+      ...gasConstants
+    };
+  }
+  async createSwapBody(params) {
+    const builder = beginCell8();
+    builder.storeUint(DEX_OP_CODES.SWAP, 32);
+    builder.storeAddress(toAddress(params.askJettonWalletAddress));
+    builder.storeCoins(BigInt(params.minAskAmount));
+    builder.storeAddress(toAddress(params.userWalletAddress));
+    const referralAddress = this.maybeReferralAddress(params.referralAddress);
+    if (referralAddress) {
+      builder.storeUint(1, 1);
+      builder.storeAddress(referralAddress);
+    } else {
+      builder.storeUint(0, 1);
+    }
+    return builder.endCell();
+  }
+  /**
+   * Build all data required to execute a jetton to jetton `swap` transaction
+   *
+   * @param {Address | string} params.userWalletAddress - User's address
+   * @param {Address | string} params.offerJettonAddress - Jetton address of a token to be swapped
+   * @param {Address | string} params.askJettonAddress - Jetton address of a token to be received
+   * @param {bigint | number} params.offerAmount - Amount of tokens to be swapped (in basic token units)
+   * @param {bigint | number} params.minAskAmount - Minimum amount of tokens received (in basic token units)
+   * @param {Address | string | undefined} params.referralAddress - Optional; referral address
+   * @param {bigint | number | string | undefined} params.gasAmount - Optional; Custom transaction gas amount (in nanoTons)
+   * @param {bigint | number | string | undefined} params.forwardGasAmount - Optional; Custom transaction forward gas amount (in nanoTons)
+   * @param {bigint | number | undefined} params.queryId - Optional; query id
+   * @param {Cell | undefined} params.jettonCustomPayload - Optional; custom payload for the jetton transfer message
+   * @param {Address | string | undefined} params.transferExcessAddress - Optional; address to transfer excess tokens
+   *
+   * @returns {SenderArguments} data required to execute a jetton `swap` transaction
+   */
+  async getSwapJettonToJettonTxParams(provider, params) {
+    const [offerJettonWalletAddress, askJettonWalletAddress] = await Promise.all([
+      params.offerJettonWalletAddress ? toAddress(params.offerJettonWalletAddress) : provider.open(JettonMinter.create(params.offerJettonAddress)).getWalletAddress(params.userWalletAddress),
+      params.askJettonWalletAddress ? params.askJettonWalletAddress : provider.open(JettonMinter.create(params.askJettonAddress)).getWalletAddress(this.address)
+    ]);
+    const forwardPayload = await this.createSwapBody({
+      userWalletAddress: params.userWalletAddress,
+      minAskAmount: params.minAskAmount,
+      askJettonWalletAddress,
+      referralAddress: params.referralAddress
+    });
+    const forwardTonAmount = BigInt(
+      params.forwardGasAmount ?? this.gasConstants.swapJettonToJetton.forwardGasAmount
+    );
+    const body = createJettonTransferMessage({
+      queryId: params.queryId ?? 0,
+      amount: params.offerAmount,
+      destination: this.address,
+      responseDestination: params.transferExcessAddress ?? params.userWalletAddress,
+      customPayload: params.jettonCustomPayload,
+      forwardTonAmount,
+      forwardPayload
+    });
+    const value = BigInt(
+      params.gasAmount ?? this.gasConstants.swapJettonToJetton.gasAmount
+    );
+    return {
+      to: offerJettonWalletAddress,
+      value,
+      body
+    };
+  }
+  async sendSwapJettonToJetton(provider, via, params) {
+    const txParams = await this.getSwapJettonToJettonTxParams(provider, params);
+    return via.send(txParams);
+  }
+  /**
+   * Build all data required to execute a jetton to ton `swap` transaction
+   *
+   * @param {Address | string} params.userWalletAddress - User's address
+   * @param {Address | string} params.offerJettonAddress - Jetton address of a token to be swapped
+   * @param {PtonV1} params.proxyTon - Proxy ton contract
+   * @param {bigint | number} params.offerAmount - Amount of tokens to be swapped (in basic token units)
+   * @param {bigint | number} params.minAskAmount - Minimum amount of tokens received (in basic token units)
+   * @param {Address | string | undefined} params.referralAddress - Optional; referral address
+   * @param {bigint | number | string | undefined} params.gasAmount - Optional; Custom transaction gas amount (in nanoTons)
+   * @param {bigint | number | string | undefined} params.forwardGasAmount - Optional; Custom transaction forward gas amount (in nanoTons)
+   * @param {bigint | number | undefined} params.queryId - Optional; query id
+   * @param {Cell | undefined} params.jettonCustomPayload - Optional; custom payload for the jetton transfer message
+   * @param {Address | string | undefined} params.transferExcessAddress - Optional; address to transfer excess tokens
+   *
+   * @returns {SenderArguments} data required to execute a jetton `swap` transaction
+   */
+  async getSwapJettonToTonTxParams(provider, params) {
+    this.assertProxyTon(params.proxyTon);
+    return await this.getSwapJettonToJettonTxParams(provider, {
+      ...params,
+      askJettonAddress: params.askJettonWalletAddress ?? params.proxyTon.address,
+      gasAmount: params.gasAmount ?? this.gasConstants.swapJettonToTon.gasAmount,
+      forwardGasAmount: params.forwardGasAmount ?? this.gasConstants.swapJettonToTon.forwardGasAmount
+    });
+  }
+  async sendSwapJettonToTon(provider, via, params) {
+    const txParams = await this.getSwapJettonToTonTxParams(provider, params);
+    return via.send(txParams);
+  }
+  /**
+   * Build all data required to execute a ton to jetton `swap` transaction
+   *
+   * @param {Address | string} params.userWalletAddress - User's address
+   * @param {PtonV1} params.proxyTon - Proxy ton contract
+   * @param {Address | string} params.askJettonAddress - Jetton address of a token to be received
+   * @param {bigint | number} params.offerAmount - Amount of ton to be swapped (in nanoTons)
+   * @param {bigint | number} params.minAskAmount - Minimum amount of tokens received (in basic token units)
+   * @param {Address | string | undefined} params.referralAddress - Optional; Referral address
+   * @param {bigint | number | string | undefined} params.forwardGasAmount - Optional; Custom transaction forward gas amount (in nanoTons)
+   * @param {bigint | number | undefined} params.queryId - Optional; query id
+   *
+   * @returns {SenderArguments} data required to execute a ton to jetton `swap` transaction
+   */
+  async getSwapTonToJettonTxParams(provider, params) {
+    this.assertProxyTon(params.proxyTon);
+    const askJettonWalletAddress = params.askJettonWalletAddress ?? await provider.open(JettonMinter.create(params.askJettonAddress)).getWalletAddress(this.address);
+    const forwardPayload = await this.createSwapBody({
+      userWalletAddress: params.userWalletAddress,
+      minAskAmount: params.minAskAmount,
+      askJettonWalletAddress,
+      referralAddress: params.referralAddress
+    });
+    const forwardTonAmount = BigInt(
+      params.forwardGasAmount ?? this.gasConstants.swapTonToJetton.forwardGasAmount
+    );
+    return await provider.open(params.proxyTon).getTonTransferTxParams({
+      queryId: params.queryId ?? 0,
+      tonAmount: params.offerAmount,
+      destinationAddress: this.address,
+      destinationWalletAddress: params.offerJettonWalletAddress,
+      refundAddress: params.userWalletAddress,
+      forwardPayload,
+      forwardTonAmount
+    });
+  }
+  async sendSwapTonToJetton(provider, via, params) {
+    const txParams = await this.getSwapTonToJettonTxParams(provider, params);
+    return via.send(txParams);
+  }
+  async createProvideLiquidityBody(params) {
+    return beginCell8().storeUint(DEX_OP_CODES.PROVIDE_LP, 32).storeAddress(toAddress(params.routerWalletAddress)).storeCoins(BigInt(params.minLpOut)).endCell();
+  }
+  /**
+   * Collect all data required to execute a jetton `provide_lp` transaction
+   *
+   * @param {Address | string} params.userWalletAddress - User's address
+   * @param {Address | string} params.sendTokenAddress - Address of the provided Jetton token
+   * @param {Address | string} params.otherTokenAddress - Address of the other Jetton token in pair
+   * @param {bigint | number} params.sendAmount - Amount of the first token deposited as liquidity (in basic token units)
+   * @param {bigint | number} params.minLpOut - Minimum amount of created liquidity tokens (in basic token units)
+   * @param {bigint | number | string | undefined} params.gasAmount - Optional; Custom transaction gas amount (in nanoTons)
+   * @param {bigint | number | string | undefined} params.forwardGasAmount - Optional; Custom transaction forward gas amount (in nanoTons)
+   * @param {bigint | number | undefined} params.queryId - Optional; query id
+   * @param {Cell | undefined} params.jettonCustomPayload - Optional; custom payload for the jetton transfer message
+   *
+   * @returns {SenderArguments} data required to execute a jetton `provide_lp` transaction
+   */
+  async getProvideLiquidityJettonTxParams(provider, params) {
+    const [jettonWalletAddress, routerWalletAddress] = await Promise.all([
+      provider.open(JettonMinter.create(params.sendTokenAddress)).getWalletAddress(params.userWalletAddress),
+      provider.open(JettonMinter.create(params.otherTokenAddress)).getWalletAddress(this.address)
+    ]);
+    const forwardPayload = await this.createProvideLiquidityBody({
+      routerWalletAddress,
+      minLpOut: params.minLpOut
+    });
+    const forwardTonAmount = BigInt(
+      params.forwardGasAmount ?? this.gasConstants.provideLpJetton.forwardGasAmount
+    );
+    const body = createJettonTransferMessage({
+      queryId: params.queryId ?? 0,
+      amount: params.sendAmount,
+      destination: this.address,
+      responseDestination: params.transferExcessAddress ?? params.userWalletAddress,
+      customPayload: params.jettonCustomPayload,
+      forwardTonAmount,
+      forwardPayload
+    });
+    const value = BigInt(
+      params.gasAmount ?? this.gasConstants.provideLpJetton.gasAmount
+    );
+    return {
+      to: jettonWalletAddress,
+      value,
+      body
+    };
+  }
+  async sendProvideLiquidityJetton(provider, via, params) {
+    const txParams = await this.getProvideLiquidityJettonTxParams(
+      provider,
+      params
+    );
+    return via.send(txParams);
+  }
+  /**
+   * Collect all data required to execute a proxy ton `provide_lp` transaction
+   *
+   * @param {Address | string} params.userWalletAddress - User's address
+   * @param {PtonV1} params.proxyTon - proxy ton contract
+   * @param {Address | string} params.otherTokenAddress - Address of the other Jetton token in pair
+   * @param {bigint | number} params.sendAmount - Amount of ton deposited as liquidity (in nanoTons)
+   * @param {bigint | number} params.minLpOut - Minimum amount of created liquidity tokens (in basic token units)
+   * @param {bigint | number | string | undefined} params.forwardGasAmount - Optional; Custom transaction forward gas amount (in nanoTons)
+   * @param {bigint | number | undefined} params.queryId - Optional; query id
+   *
+   * @returns {SenderArguments} data required to execute a proxy ton `provide_lp` transaction
+   */
+  async getProvideLiquidityTonTxParams(provider, params) {
+    this.assertProxyTon(params.proxyTon);
+    const routerWalletAddress = await provider.open(JettonMinter.create(params.otherTokenAddress)).getWalletAddress(this.address);
+    const forwardPayload = await this.createProvideLiquidityBody({
+      routerWalletAddress,
+      minLpOut: params.minLpOut
+    });
+    const forwardTonAmount = BigInt(
+      params.forwardGasAmount ?? this.gasConstants.provideLpTon.forwardGasAmount
+    );
+    return await provider.open(params.proxyTon).getTonTransferTxParams({
+      queryId: params.queryId ?? 0,
+      tonAmount: params.sendAmount,
+      destinationAddress: this.address,
+      refundAddress: params.userWalletAddress,
+      forwardPayload,
+      forwardTonAmount
+    });
+  }
+  async sendProvideLiquidityTon(provider, via, params) {
+    const txParams = await this.getProvideLiquidityTonTxParams(
+      provider,
+      params
+    );
+    return via.send(txParams);
+  }
+  assertProxyTon(proxyTon) {
+    if (proxyTon.version !== pTON_VERSION.v1) {
+      throw new UnmatchedPtonVersion({
+        expected: pTON_VERSION.v1,
+        received: proxyTon.version
+      });
+    }
+  }
+  /**
+   * **Note:** It's necessary to specify addresses of Jetton wallets of the router as the arguments of this method.
+   * These addresses can be retrieved with getJettonWalletAddress of the Jetton minter.
+   *
+   * @param {Address | string} params.token0 - The address of the router's wallet of first Jetton
+   * @param {Address | string} params.token1 - The address of the router's wallet of second Jetton
+   *
+   * @returns {Address} an address of a pool for a specified pair of assets.
+   */
+  async getPoolAddress(provider, params) {
+    const result = await provider.get("get_pool_address", [
+      {
+        type: "slice",
+        cell: beginCell8().storeAddress(toAddress(params.token0)).endCell()
+      },
+      {
+        type: "slice",
+        cell: beginCell8().storeAddress(toAddress(params.token1)).endCell()
+      }
+    ]);
+    return result.stack.readAddress();
+  }
+  /**
+   * @param {Address | string} params.token0 - The address of the first Jetton minter
+   * @param {Address | string} params.token1 - The address of the second Jetton minter
+   *
+   * @returns {Address} an address of a pool for a specified pair of assets.
+   */
+  async getPoolAddressByJettonMinters(provider, params) {
+    const [jetton0WalletAddress, jetton1WalletAddress] = await Promise.all([
+      provider.open(JettonMinter.create(params.token0)).getWalletAddress(this.address),
+      provider.open(JettonMinter.create(params.token1)).getWalletAddress(this.address)
+    ]);
+    const poolAddress = await this.getPoolAddress(provider, {
+      token0: jetton0WalletAddress,
+      token1: jetton1WalletAddress
+    });
+    return poolAddress;
+  }
+  /**
+   * @param {Address | string} params.token0 - The address of the first Jetton minter
+   * @param {Address | string} params.token1 - The address of the second Jetton minter
+   *
+   * @returns {PoolV1} object for a pool with specified Jetton token addresses.
+   */
+  async getPool(provider, params) {
+    const poolAddress = await this.getPoolAddressByJettonMinters(provider, {
+      token0: params.token0,
+      token1: params.token1
+    });
+    return PoolV1.create(poolAddress);
+  }
+  /**
+   * @returns current state of the router.
+   */
+  async getRouterData(provider) {
+    const result = await provider.get("get_router_data", []);
+    return {
+      isLocked: result.stack.readBoolean(),
+      adminAddress: result.stack.readAddress(),
+      tempUpgrade: result.stack.readCell(),
+      poolCode: result.stack.readCell(),
+      jettonLpWalletCode: result.stack.readCell(),
+      lpAccountCode: result.stack.readCell()
+    };
+  }
+  maybeReferralAddress(referralAddress) {
+    if (!referralAddress) return null;
+    const referralAddressParsed = toAddress(referralAddress);
+    if (referralAddressParsed.equals(HOLE_ADDRESS)) return null;
+    return referralAddressParsed;
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-WC6BMQXZ.js
+var pTON_OP_CODES = {
+  DEPLOY_WALLET: 1824798067
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-PFUMIEMI.js
+import {
+  address as address3,
+  beginCell as beginCell9,
+  toNano as toNano9
+} from "@ton/ton";
+var PtonV1 = class _PtonV1 extends JettonMinter {
+  static version = pTON_VERSION.v1;
+  static address = address3(
+    "EQCM3B12QK1e4yZSf8GtBRT0aLMNyEsBc_DhVfRRtOEffLez"
+  );
+  static gasConstants = {
+    deployWallet: toNano9("1.05")
+  };
+  version = _PtonV1.version;
+  gasConstants;
+  constructor(address22 = _PtonV1.address, { gasConstants, ...options } = {}) {
+    super(address22, options);
+    this.gasConstants = {
+      ..._PtonV1.gasConstants,
+      ...gasConstants
+    };
+  }
+  async getTonTransferTxParams(provider, params) {
+    const to = params.destinationWalletAddress ? toAddress(params.destinationWalletAddress) : await this.getWalletAddress(provider, params.destinationAddress);
+    const body = createJettonTransferMessage({
+      queryId: params.queryId ?? 0,
+      amount: params.tonAmount,
+      destination: params.destinationAddress,
+      forwardTonAmount: BigInt(params.forwardTonAmount ?? 0),
+      forwardPayload: params.forwardPayload
+    });
+    const value = BigInt(params.tonAmount) + BigInt(params.forwardTonAmount ?? 0);
+    return { to, value, body };
+  }
+  async sendTonTransfer(provider, via, params) {
+    const txParams = await this.getTonTransferTxParams(provider, params);
+    return via.send(txParams);
+  }
+  async createDeployWalletBody(params) {
+    return beginCell9().storeUint(pTON_OP_CODES.DEPLOY_WALLET, 32).storeUint(params.queryId ?? 0, 64).storeAddress(toAddress(params.ownerAddress)).endCell();
+  }
+  async getDeployWalletTxParams(provider, params) {
+    const to = this.address;
+    const body = await this.createDeployWalletBody({
+      ownerAddress: params.ownerAddress,
+      queryId: params?.queryId
+    });
+    const value = BigInt(params?.gasAmount ?? this.gasConstants.deployWallet);
+    return { to, value, body };
+  }
+  async sendDeployWallet(provider, via, params) {
+    const txParams = await this.getDeployWalletTxParams(provider, params);
+    return via.send(txParams);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-TO5IKSJT.js
+var DEX = {
+  Router: RouterV1,
+  Pool: PoolV1,
+  LpAccount: LpAccountV1,
+  pTON: PtonV1
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-CWGXHOMU.js
+var DEX_OP_CODES2 = {
+  SWAP: 1717886506,
+  CROSS_SWAP: 1775180379,
+  PROVIDE_LP: 935368415,
+  DIRECT_ADD_LIQUIDITY: 267960262,
+  REFUND_ME: 321624620,
+  RESET_GAS: 701638965,
+  COLLECT_FEES: 518295838,
+  BURN: 1499400124,
+  WITHDRAW_FEE: 894160372
+};
+var TX_DEADLINE = 15 * 60;
+
+// node_modules/@ston-fi/sdk/dist/chunk-ZREZXXSX.js
+import {
+  beginCell as beginCell10,
+  toNano as toNano10
+} from "@ton/ton";
+var VaultV2_1 = class _VaultV2_1 extends Contract {
+  static version = DEX_VERSION.v2_1;
+  static gasConstants = {
+    withdrawFee: toNano10("0.3")
+  };
+  gasConstants;
+  constructor(address4, { gasConstants, ...options } = {}) {
+    super(address4, options);
+    this.gasConstants = {
+      ..._VaultV2_1.gasConstants,
+      ...gasConstants
+    };
+  }
+  async createWithdrawFeeBody(params) {
+    return beginCell10().storeUint(DEX_OP_CODES2.WITHDRAW_FEE, 32).storeUint(params?.queryId ?? 0, 64).endCell();
+  }
+  /**
+   * Build all data required to execute a `withdraw_fee` transaction.
+   *
+   * @param {ContractProvider} provider - {@link ContractProvider} instance
+   *
+   * @param {object | undefined} params - Optional tx params
+   * @param {bigint | number | string | undefined} params.gasAmount - Optional; Custom transaction gas amount (in nanoTons)
+   * @param {bigint | number | undefined} params.queryId - Optional; query id
+   *
+   *
+   * @returns {SenderArguments} all data required to execute a `withdraw_fee` transaction.
+   */
+  async getWithdrawFeeTxParams(provider, params) {
+    const to = this.address;
+    const body = await this.createWithdrawFeeBody({
+      queryId: params?.queryId
+    });
+    const value = BigInt(params?.gasAmount ?? this.gasConstants.withdrawFee);
+    return { to, body, value };
+  }
+  async sendWithdrawFee(provider, via, params) {
+    const txParams = await this.getWithdrawFeeTxParams(provider, params);
+    return via.send(txParams);
+  }
+  /**
+   * Get the current state of the vault contract.
+   *
+   * @param {ContractProvider} provider - {@link ContractProvider} instance
+   *
+   *
+   * @returns {Promise<object>} structure containing the current state of the vault contract.
+   */
+  async getVaultData(provider) {
+    const result = await provider.get("get_vault_data", []);
+    return {
+      ownerAddress: result.stack.readAddress(),
+      tokenAddress: result.stack.readAddress(),
+      routerAddress: result.stack.readAddress(),
+      depositedAmount: result.stack.readBigNumber()
+    };
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-NYDP354Z.js
+import {
+  beginCell as beginCell11,
+  toNano as toNano11
+} from "@ton/ton";
+var LpAccountV2_1 = class _LpAccountV2_1 extends Contract {
+  static version = DEX_VERSION.v2_1;
+  static gasConstants = {
+    refund: toNano11("0.8"),
+    directAddLp: toNano11("0.3"),
+    resetGas: toNano11("0.02")
+  };
+  gasConstants;
+  constructor(address4, { gasConstants, ...options } = {}) {
+    super(address4, options);
+    this.gasConstants = {
+      ..._LpAccountV2_1.gasConstants,
+      ...gasConstants
+    };
+  }
+  async createRefundBody(params) {
+    return beginCell11().storeUint(DEX_OP_CODES2.REFUND_ME, 32).storeUint(params?.queryId ?? 0, 64).storeMaybeRef(params?.leftMaybePayload).storeMaybeRef(params?.rightMaybePayload).endCell();
+  }
+  async getRefundTxParams(provider, params) {
+    const to = this.address;
+    const body = await this.createRefundBody({
+      leftMaybePayload: params?.leftMaybePayload,
+      rightMaybePayload: params?.rightMaybePayload,
+      queryId: params?.queryId
+    });
+    const value = BigInt(params?.gasAmount ?? this.gasConstants.refund);
+    return { to, value, body };
+  }
+  async sendRefund(provider, via, params) {
+    const txParams = await this.getRefundTxParams(provider, params);
+    return via.send(txParams);
+  }
+  async createDirectAddLiquidityBody(params) {
+    return beginCell11().storeUint(DEX_OP_CODES2.DIRECT_ADD_LIQUIDITY, 32).storeUint(params?.queryId ?? 0, 64).storeCoins(BigInt(params.amount0)).storeCoins(BigInt(params.amount1)).storeCoins(BigInt(params.minimumLpToMint ?? 1)).storeCoins(BigInt(params.dexCustomPayloadForwardGasAmount ?? 0)).storeAddress(toAddress(params.userWalletAddress)).storeMaybeRef(params.dexCustomPayload).storeRef(
+      beginCell11().storeAddress(
+        toAddress(params.refundAddress ?? params.userWalletAddress)
+      ).storeAddress(
+        toAddress(
+          params.excessesAddress ?? params.refundAddress ?? params.userWalletAddress
+        )
+      ).endCell()
+    ).endCell();
+  }
+  async getDirectAddLiquidityTxParams(provider, params) {
+    const to = this.address;
+    const body = await this.createDirectAddLiquidityBody({
+      amount0: params.amount0,
+      amount1: params.amount1,
+      minimumLpToMint: params.minimumLpToMint,
+      userWalletAddress: params.userWalletAddress,
+      refundAddress: params.refundAddress,
+      excessesAddress: params.excessesAddress,
+      dexCustomPayload: params.dexCustomPayload,
+      dexCustomPayloadForwardGasAmount: params.dexCustomPayloadForwardGasAmount,
+      queryId: params.queryId
+    });
+    const value = BigInt(params.gasAmount ?? this.gasConstants.directAddLp);
+    return { to, value, body };
+  }
+  async sendDirectAddLiquidity(provider, via, params) {
+    const txParams = await this.getDirectAddLiquidityTxParams(provider, params);
+    return via.send(txParams);
+  }
+  async createResetGasBody(params) {
+    return beginCell11().storeUint(DEX_OP_CODES2.RESET_GAS, 32).storeUint(params?.queryId ?? 0, 64).endCell();
+  }
+  async getResetGasTxParams(provider, params) {
+    const to = this.address;
+    const body = await this.createResetGasBody({
+      queryId: params?.queryId
+    });
+    const value = BigInt(params?.gasAmount ?? this.gasConstants.resetGas);
+    return { to, value, body };
+  }
+  async sendResetGas(provider, via, params) {
+    const txParams = await this.getResetGasTxParams(provider, params);
+    return via.send(txParams);
+  }
+  async getLpAccountData(provider) {
+    const result = await provider.get("get_lp_account_data", []);
+    return {
+      userAddress: result.stack.readAddress(),
+      poolAddress: result.stack.readAddress(),
+      amount0: result.stack.readBigNumber(),
+      amount1: result.stack.readBigNumber()
+    };
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-DFPKM3LH.js
+import {
+  beginCell as beginCell12,
+  toNano as toNano12
+} from "@ton/ton";
+var BasePoolV2_1 = class _BasePoolV2_1 extends JettonMinter {
+  static version = DEX_VERSION.v2_1;
+  static gasConstants = {
+    collectFees: toNano12("0.4"),
+    burn: toNano12("0.8")
+  };
+  gasConstants;
+  constructor(address4, { gasConstants, ...options } = {}) {
+    super(address4, options);
+    this.gasConstants = {
+      ..._BasePoolV2_1.gasConstants,
+      ...gasConstants
+    };
+  }
+  async createCollectFeesBody(params) {
+    return beginCell12().storeUint(DEX_OP_CODES2.COLLECT_FEES, 32).storeUint(params?.queryId ?? 0, 64).endCell();
+  }
+  async getCollectFeeTxParams(provider, params) {
+    const to = this.address;
+    const body = await this.createCollectFeesBody({
+      queryId: params?.queryId
+    });
+    const value = BigInt(params?.gasAmount ?? this.gasConstants.collectFees);
+    return { to, value, body };
+  }
+  async sendCollectFees(provider, via, params) {
+    const txParams = await this.getCollectFeeTxParams(provider, params);
+    return via.send(txParams);
+  }
+  async createBurnBody(params) {
+    return beginCell12().storeUint(DEX_OP_CODES2.BURN, 32).storeUint(params?.queryId ?? 0, 64).storeCoins(BigInt(params.amount)).storeAddress(null).storeMaybeRef(params.dexCustomPayload).endCell();
+  }
+  async getBurnTxParams(provider, params) {
+    const [to, body] = await Promise.all([
+      this.getWalletAddress(provider, params.userWalletAddress),
+      this.createBurnBody({
+        amount: params.amount,
+        dexCustomPayload: params.dexCustomPayload,
+        queryId: params.queryId
+      })
+    ]);
+    const value = BigInt(params.gasAmount ?? this.gasConstants.burn);
+    return { to, value, body };
+  }
+  async sendBurn(provider, via, params) {
+    const txParams = await this.getBurnTxParams(provider, params);
+    return via.send(txParams);
+  }
+  async getPoolType(provider) {
+    const result = await provider.get("get_pool_type", []);
+    return result.stack.readString();
+  }
+  async getLpAccountAddress(provider, params) {
+    const result = await provider.get("get_lp_account_address", [
+      {
+        type: "slice",
+        cell: beginCell12().storeAddress(toAddress(params.ownerAddress)).endCell()
+      }
+    ]);
+    return result.stack.readAddress();
+  }
+  async getLpAccount(provider, params) {
+    const lpAccountAddress = await this.getLpAccountAddress(provider, params);
+    return LpAccountV2_1.create(lpAccountAddress);
+  }
+  async getJettonWallet(provider, params) {
+    const jettonWalletAddress = await this.getWalletAddress(
+      provider,
+      params.ownerAddress
+    );
+    return JettonWallet.create(jettonWalletAddress);
+  }
+  async getPoolData(provider) {
+    const data = await this.implGetPoolData(provider);
+    return data.commonPoolData;
+  }
+  async implGetPoolData(provider) {
+    const result = await provider.get("get_pool_data", []);
+    return {
+      commonPoolData: {
+        isLocked: result.stack.readBoolean(),
+        routerAddress: result.stack.readAddress(),
+        totalSupplyLP: result.stack.readBigNumber(),
+        reserve0: result.stack.readBigNumber(),
+        reserve1: result.stack.readBigNumber(),
+        token0WalletAddress: result.stack.readAddress(),
+        token1WalletAddress: result.stack.readAddress(),
+        lpFee: result.stack.readBigNumber(),
+        protocolFee: result.stack.readBigNumber(),
+        protocolFeeAddress: result.stack.readAddressOpt(),
+        collectedToken0ProtocolFee: result.stack.readBigNumber(),
+        collectedToken1ProtocolFee: result.stack.readBigNumber()
+      },
+      stack: result.stack
+    };
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-YSYMABVC.js
+import {
+  Address as Address10,
+  beginCell as beginCell13,
+  toNano as toNano13
+} from "@ton/ton";
+var BaseRouterV2_1 = class _BaseRouterV2_1 extends Contract {
+  static version = DEX_VERSION.v2_1;
+  static gasConstants = {
+    swapJettonToJetton: {
+      gasAmount: toNano13("0.3"),
+      forwardGasAmount: toNano13("0.24")
+    },
+    swapJettonToTon: {
+      gasAmount: toNano13("0.3"),
+      forwardGasAmount: toNano13("0.24")
+    },
+    swapTonToJetton: {
+      forwardGasAmount: toNano13("0.3")
+    },
+    provideLpJetton: {
+      gasAmount: toNano13("0.3"),
+      forwardGasAmount: toNano13("0.235")
+    },
+    provideLpTon: {
+      forwardGasAmount: toNano13("0.3")
+    },
+    singleSideProvideLpJetton: {
+      gasAmount: toNano13("1"),
+      forwardGasAmount: toNano13("0.8")
+    },
+    singleSideProvideLpTon: {
+      forwardGasAmount: toNano13("0.8")
+    }
+  };
+  gasConstants;
+  txDeadline;
+  constructor(address4, { gasConstants, txDeadline, ...options } = {}) {
+    super(address4, options);
+    if (this.address.equals(Address10.parse(ROUTER_ADDRESS))) {
+      throw Error(
+        [
+          "You are trying to create an instance v2.1 Router with a v1 address",
+          "Please use the appropriate class for the v1 Router. Otherwise, all the funds will be permanently lost."
+        ].join("\n")
+      );
+    }
+    this.gasConstants = {
+      ..._BaseRouterV2_1.gasConstants,
+      ...gasConstants
+    };
+    this.txDeadline = txDeadline ?? TX_DEADLINE;
+  }
+  async createSwapBody(params) {
+    if (params.referralValue && (BigInt(params.referralValue) < 0 || BigInt(params.referralValue) > 100)) {
+      throw Error(`'referralValue' should be in range [0, 100] BPS`);
+    }
+    return beginCell13().storeUint(DEX_OP_CODES2.SWAP, 32).storeAddress(toAddress(params.askJettonWalletAddress)).storeAddress(toAddress(params.refundAddress)).storeAddress(toAddress(params.excessesAddress ?? params.refundAddress)).storeUint(params.deadline ?? this.defaultDeadline, 64).storeRef(
+      beginCell13().storeCoins(BigInt(params.minAskAmount)).storeAddress(toAddress(params.receiverAddress)).storeCoins(BigInt(params.dexCustomPayloadForwardGasAmount ?? 0)).storeMaybeRef(params.dexCustomPayload).storeCoins(BigInt(params.refundForwardGasAmount ?? 0)).storeMaybeRef(params.refundPayload).storeUint(BigInt(params.referralValue ?? 10), 16).storeAddress(this.maybeReferralAddress(params.referralAddress)).endCell()
+    ).endCell();
+  }
+  async createCrossSwapBody(params) {
+    if (params.referralValue && (BigInt(params.referralValue) < 0 || BigInt(params.referralValue) > 100)) {
+      throw Error(`'referralValue' should be in range [0, 100] BPS`);
+    }
+    return beginCell13().storeUint(DEX_OP_CODES2.CROSS_SWAP, 32).storeAddress(toAddress(params.askJettonWalletAddress)).storeAddress(toAddress(params.refundAddress)).storeAddress(toAddress(params.excessesAddress ?? params.refundAddress)).storeUint(params.deadline ?? this.defaultDeadline, 64).storeRef(
+      beginCell13().storeCoins(BigInt(params.minAskAmount)).storeAddress(toAddress(params.receiverAddress)).storeCoins(BigInt(params.dexCustomPayloadForwardGasAmount ?? 0)).storeMaybeRef(params.dexCustomPayload).storeCoins(BigInt(params.refundForwardGasAmount ?? 0)).storeMaybeRef(params.refundPayload).storeUint(BigInt(params.referralValue ?? 10), 16).storeAddress(this.maybeReferralAddress(params.referralAddress)).endCell()
+    ).endCell();
+  }
+  async getSwapJettonToJettonTxParams(provider, params) {
+    const contractAddress = this.address;
+    const [offerJettonWalletAddress, askJettonWalletAddress] = await Promise.all([
+      params.offerJettonWalletAddress ? toAddress(params.offerJettonWalletAddress) : provider.open(JettonMinter.create(params.offerJettonAddress)).getWalletAddress(params.userWalletAddress),
+      params.askJettonWalletAddress ? params.askJettonWalletAddress : provider.open(JettonMinter.create(params.askJettonAddress)).getWalletAddress(this.address)
+    ]);
+    const forwardTonAmount = BigInt(
+      params.forwardGasAmount ?? this.gasConstants.swapJettonToJetton.forwardGasAmount
+    );
+    const forwardPayload = await this.createSwapBody({
+      askJettonWalletAddress,
+      receiverAddress: params.receiverAddress ?? params.userWalletAddress,
+      minAskAmount: params.minAskAmount,
+      refundAddress: params.refundAddress ?? params.userWalletAddress,
+      excessesAddress: params.excessesAddress,
+      referralAddress: params.referralAddress,
+      referralValue: params.referralValue,
+      dexCustomPayload: params.dexCustomPayload,
+      dexCustomPayloadForwardGasAmount: params.dexCustomPayloadForwardGasAmount,
+      refundPayload: params.refundPayload,
+      refundForwardGasAmount: params.refundForwardGasAmount,
+      deadline: params.deadline
+    });
+    const body = createJettonTransferMessage({
+      queryId: params.queryId ?? 0,
+      amount: params.offerAmount,
+      destination: contractAddress,
+      responseDestination: params.transferExcessAddress ?? params.userWalletAddress,
+      customPayload: params.jettonCustomPayload,
+      forwardTonAmount,
+      forwardPayload
+    });
+    const value = BigInt(
+      params.gasAmount ?? this.gasConstants.swapJettonToJetton.gasAmount
+    );
+    return {
+      to: offerJettonWalletAddress,
+      value,
+      body
+    };
+  }
+  async sendSwapJettonToJetton(provider, via, params) {
+    const txParams = await this.getSwapJettonToJettonTxParams(provider, params);
+    return via.send(txParams);
+  }
+  async getSwapJettonToTonTxParams(provider, params) {
+    this.assertProxyTon(params.proxyTon);
+    return await this.getSwapJettonToJettonTxParams(provider, {
+      ...params,
+      askJettonAddress: params.proxyTon.address,
+      askJettonWalletAddress: params.askJettonWalletAddress,
+      gasAmount: params.gasAmount ?? this.gasConstants.swapJettonToTon.gasAmount,
+      forwardGasAmount: params.forwardGasAmount ?? this.gasConstants.swapJettonToTon.forwardGasAmount
+    });
+  }
+  async sendSwapJettonToTon(provider, via, params) {
+    const txParams = await this.getSwapJettonToTonTxParams(provider, params);
+    return via.send(txParams);
+  }
+  async getSwapTonToJettonTxParams(provider, params) {
+    this.assertProxyTon(params.proxyTon);
+    const contractAddress = this.address;
+    const askJettonWalletAddress = params.askJettonWalletAddress ?? await provider.open(JettonMinter.create(params.askJettonAddress)).getWalletAddress(contractAddress);
+    const forwardPayload = await this.createSwapBody({
+      askJettonWalletAddress,
+      receiverAddress: params.receiverAddress ?? params.userWalletAddress,
+      minAskAmount: params.minAskAmount,
+      refundAddress: params.refundAddress ?? params.userWalletAddress,
+      excessesAddress: params.excessesAddress,
+      referralAddress: params.referralAddress,
+      referralValue: params.referralValue,
+      dexCustomPayload: params.dexCustomPayload,
+      dexCustomPayloadForwardGasAmount: params.dexCustomPayloadForwardGasAmount,
+      refundPayload: params.refundPayload,
+      refundForwardGasAmount: params.refundForwardGasAmount,
+      deadline: params.deadline
+    });
+    const forwardTonAmount = BigInt(
+      params.forwardGasAmount ?? this.gasConstants.swapTonToJetton.forwardGasAmount
+    );
+    return await provider.open(params.proxyTon).getTonTransferTxParams({
+      queryId: params.queryId ?? 0,
+      tonAmount: params.offerAmount,
+      destinationAddress: contractAddress,
+      destinationWalletAddress: params.offerJettonWalletAddress,
+      refundAddress: params.userWalletAddress,
+      forwardPayload,
+      forwardTonAmount
+    });
+  }
+  async sendSwapTonToJetton(provider, via, params) {
+    const txParams = await this.getSwapTonToJettonTxParams(provider, params);
+    return via.send(txParams);
+  }
+  async createProvideLiquidityBody(params) {
+    return beginCell13().storeUint(DEX_OP_CODES2.PROVIDE_LP, 32).storeAddress(toAddress(params.routerWalletAddress)).storeAddress(toAddress(params.refundAddress)).storeAddress(toAddress(params.excessesAddress ?? params.refundAddress)).storeUint(params.deadline ?? this.defaultDeadline, 64).storeRef(
+      beginCell13().storeCoins(BigInt(params.minLpOut)).storeAddress(toAddress(params.receiverAddress)).storeUint(params.bothPositive ? 1 : 0, 1).storeCoins(BigInt(params.dexCustomPayloadForwardGasAmount ?? 0)).storeMaybeRef(params.dexCustomPayload).endCell()
+    ).endCell();
+  }
+  async getProvideLiquidityJettonTxParams(provider, params) {
+    return this.implGetProvideLiquidityJettonTxParams(provider, {
+      ...params,
+      gasAmount: params.gasAmount ?? this.gasConstants.provideLpJetton.gasAmount,
+      forwardGasAmount: params.forwardGasAmount ?? this.gasConstants.provideLpJetton.forwardGasAmount,
+      bothPositive: true
+    });
+  }
+  async sendProvideLiquidityJetton(provider, via, params) {
+    const txParams = await this.getProvideLiquidityJettonTxParams(
+      provider,
+      params
+    );
+    return via.send(txParams);
+  }
+  async getSingleSideProvideLiquidityJettonTxParams(provider, params) {
+    return this.implGetProvideLiquidityJettonTxParams(provider, {
+      ...params,
+      gasAmount: params.gasAmount ?? this.gasConstants.singleSideProvideLpJetton.gasAmount,
+      forwardGasAmount: params.forwardGasAmount ?? this.gasConstants.singleSideProvideLpJetton.forwardGasAmount,
+      bothPositive: false
+    });
+  }
+  async sendSingleSideProvideLiquidityJetton(provider, via, params) {
+    const txParams = await this.getSingleSideProvideLiquidityJettonTxParams(
+      provider,
+      params
+    );
+    return via.send(txParams);
+  }
+  async implGetProvideLiquidityJettonTxParams(provider, params) {
+    const contractAddress = this.address;
+    const [jettonWalletAddress, routerWalletAddress] = await Promise.all([
+      provider.open(JettonMinter.create(params.sendTokenAddress)).getWalletAddress(params.userWalletAddress),
+      provider.open(JettonMinter.create(params.otherTokenAddress)).getWalletAddress(contractAddress)
+    ]);
+    const forwardPayload = await this.createProvideLiquidityBody({
+      routerWalletAddress,
+      receiverAddress: params.receiverAddress ?? params.userWalletAddress,
+      minLpOut: params.minLpOut,
+      refundAddress: params.refundAddress ?? params.userWalletAddress,
+      excessesAddress: params.excessesAddress,
+      dexCustomPayload: params.dexCustomPayload,
+      dexCustomPayloadForwardGasAmount: params.dexCustomPayloadForwardGasAmount,
+      bothPositive: params.bothPositive,
+      deadline: params.deadline
+    });
+    const forwardTonAmount = BigInt(params.forwardGasAmount);
+    const body = createJettonTransferMessage({
+      queryId: params.queryId ?? 0,
+      amount: params.sendAmount,
+      destination: contractAddress,
+      responseDestination: params.transferExcessAddress ?? params.userWalletAddress,
+      customPayload: params.jettonCustomPayload,
+      forwardTonAmount,
+      forwardPayload
+    });
+    const value = BigInt(params.gasAmount);
+    return {
+      to: jettonWalletAddress,
+      value,
+      body
+    };
+  }
+  async getProvideLiquidityTonTxParams(provider, params) {
+    return this.implGetProvideLiquidityTonTxParams(provider, {
+      ...params,
+      forwardGasAmount: params.forwardGasAmount ?? this.gasConstants.provideLpTon.forwardGasAmount,
+      bothPositive: true
+    });
+  }
+  async sendProvideLiquidityTon(provider, via, params) {
+    const txParams = await this.getProvideLiquidityTonTxParams(
+      provider,
+      params
+    );
+    return via.send(txParams);
+  }
+  async getSingleSideProvideLiquidityTonTxParams(provider, params) {
+    return this.implGetProvideLiquidityTonTxParams(provider, {
+      ...params,
+      forwardGasAmount: params.forwardGasAmount ?? this.gasConstants.singleSideProvideLpTon.forwardGasAmount,
+      bothPositive: false
+    });
+  }
+  async sendSingleSideProvideLiquidityTon(provider, via, params) {
+    const txParams = await this.getSingleSideProvideLiquidityTonTxParams(
+      provider,
+      params
+    );
+    return via.send(txParams);
+  }
+  async implGetProvideLiquidityTonTxParams(provider, params) {
+    this.assertProxyTon(params.proxyTon);
+    const contractAddress = this.address;
+    const routerWalletAddress = await provider.open(JettonMinter.create(params.otherTokenAddress)).getWalletAddress(contractAddress);
+    const forwardPayload = await this.createProvideLiquidityBody({
+      routerWalletAddress,
+      receiverAddress: params.receiverAddress ?? params.userWalletAddress,
+      minLpOut: params.minLpOut,
+      refundAddress: params.refundAddress ?? params.userWalletAddress,
+      excessesAddress: params.excessesAddress,
+      dexCustomPayload: params.dexCustomPayload,
+      dexCustomPayloadForwardGasAmount: params.dexCustomPayloadForwardGasAmount,
+      bothPositive: params.bothPositive,
+      deadline: params.deadline
+    });
+    const forwardTonAmount = BigInt(params.forwardGasAmount);
+    return await provider.open(params.proxyTon).getTonTransferTxParams({
+      queryId: params.queryId ?? 0,
+      tonAmount: params.sendAmount,
+      destinationAddress: contractAddress,
+      refundAddress: params.userWalletAddress,
+      forwardPayload,
+      forwardTonAmount
+    });
+  }
+  maybeReferralAddress(referralAddress) {
+    if (!referralAddress) return null;
+    const referralAddressParsed = toAddress(referralAddress);
+    if (referralAddressParsed.equals(HOLE_ADDRESS)) return null;
+    return referralAddressParsed;
+  }
+  get defaultDeadline() {
+    return Math.floor(Date.now() / 1e3) + this.txDeadline;
+  }
+  assertProxyTon(proxyTon) {
+    if (proxyTon.version !== pTON_VERSION.v2_1) {
+      throw new UnmatchedPtonVersion({
+        expected: pTON_VERSION.v2_1,
+        received: proxyTon.version
+      });
+    }
+  }
+  async getPoolAddress(provider, params) {
+    const result = await provider.get("get_pool_address", [
+      {
+        type: "slice",
+        cell: beginCell13().storeAddress(toAddress(params.token0)).endCell()
+      },
+      {
+        type: "slice",
+        cell: beginCell13().storeAddress(toAddress(params.token1)).endCell()
+      }
+    ]);
+    return result.stack.readAddress();
+  }
+  async getPoolAddressByJettonMinters(provider, params) {
+    const [jetton0WalletAddress, jetton1WalletAddress] = await Promise.all([
+      provider.open(JettonMinter.create(params.token0)).getWalletAddress(this.address),
+      provider.open(JettonMinter.create(params.token1)).getWalletAddress(this.address)
+    ]);
+    const poolAddress = await this.getPoolAddress(provider, {
+      token0: jetton0WalletAddress,
+      token1: jetton1WalletAddress
+    });
+    return poolAddress;
+  }
+  async getPool(provider, params) {
+    const poolAddress = await this.getPoolAddressByJettonMinters(
+      provider,
+      params
+    );
+    return BasePoolV2_1.create(poolAddress);
+  }
+  async getVaultAddress(provider, params) {
+    const result = await provider.get("get_vault_address", [
+      {
+        type: "slice",
+        cell: beginCell13().storeAddress(toAddress(params.user)).endCell()
+      },
+      {
+        type: "slice",
+        cell: beginCell13().storeAddress(toAddress(params.tokenWallet)).endCell()
+      }
+    ]);
+    return result.stack.readAddress();
+  }
+  async getVault(provider, params) {
+    const tokenMinter = provider.open(JettonMinter.create(params.tokenMinter));
+    const vaultAddress = await this.getVaultAddress(provider, {
+      user: params.user,
+      tokenWallet: await tokenMinter.getWalletAddress(this.address)
+    });
+    return VaultV2_1.create(vaultAddress);
+  }
+  async getRouterVersion(provider) {
+    const result = await provider.get("get_router_version", []);
+    return {
+      major: result.stack.readNumber(),
+      minor: result.stack.readNumber(),
+      development: result.stack.readString()
+    };
+  }
+  async getRouterData(provider) {
+    const result = await provider.get("get_router_data", []);
+    return {
+      routerId: result.stack.readNumber(),
+      dexType: result.stack.readString(),
+      isLocked: result.stack.readBoolean(),
+      adminAddress: result.stack.readAddress(),
+      tempUpgrade: result.stack.readCell(),
+      poolCode: result.stack.readCell(),
+      jettonLpWalletCode: result.stack.readCell(),
+      lpAccountCode: result.stack.readCell(),
+      vaultCode: result.stack.readCell()
+    };
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-PFDB63A3.js
+var CPIPoolV2_1 = class extends BasePoolV2_1 {
+  static dexType = DEX_TYPE.CPI;
+  async getPoolData(provider) {
+    const data = await this.implGetPoolData(provider);
+    return {
+      ...data.commonPoolData
+    };
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-IFMGU6GB.js
+var CPIRouterV2_1 = class extends BaseRouterV2_1 {
+  static dexType = DEX_TYPE.CPI;
+  async getPool(provider, params) {
+    const poolAddress = await this.getPoolAddressByJettonMinters(
+      provider,
+      params
+    );
+    return CPIPoolV2_1.create(poolAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-KXPOQKNK.js
+var StablePoolV2_1 = class extends BasePoolV2_1 {
+  static dexType = DEX_TYPE.Stable;
+  async getPoolData(provider) {
+    const data = await this.implGetPoolData(provider);
+    return {
+      ...data.commonPoolData,
+      amp: data.stack.readBigNumber()
+    };
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-VFE4LTGM.js
+import { toNano as toNano14 } from "@ton/ton";
+var StableRouterV2_1 = class _StableRouterV2_1 extends BaseRouterV2_1 {
+  static dexType = DEX_TYPE.Stable;
+  static gasConstants = {
+    ...BaseRouterV2_1.gasConstants,
+    swapJettonToJetton: {
+      gasAmount: toNano14("0.329"),
+      forwardGasAmount: toNano14("0.269")
+    },
+    swapJettonToTon: {
+      gasAmount: toNano14("0.329"),
+      forwardGasAmount: toNano14("0.269")
+    },
+    swapTonToJetton: {
+      forwardGasAmount: toNano14("0.329")
+    }
+  };
+  constructor(address4, { gasConstants, ...options } = {}) {
+    super(address4, {
+      ...options,
+      gasConstants: {
+        ..._StableRouterV2_1.gasConstants,
+        ...gasConstants
+      }
+    });
+  }
+  async getPool(provider, params) {
+    const poolAddress = await this.getPoolAddressByJettonMinters(
+      provider,
+      params
+    );
+    return StablePoolV2_1.create(poolAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-XEXEDC3T.js
+var WCPIPoolV2_1 = class extends BasePoolV2_1 {
+  static dexType = DEX_TYPE.WCPI;
+  async getPoolData(provider) {
+    const data = await this.implGetPoolData(provider);
+    return {
+      ...data.commonPoolData
+    };
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-FU2GQY36.js
+import { toNano as toNano15 } from "@ton/ton";
+var WCPIRouterV2_1 = class _WCPIRouterV2_1 extends BaseRouterV2_1 {
+  static dexType = DEX_TYPE.WCPI;
+  static gasConstants = {
+    ...BaseRouterV2_1.gasConstants,
+    swapJettonToJetton: {
+      gasAmount: toNano15("0.319"),
+      forwardGasAmount: toNano15("0.259")
+    },
+    swapJettonToTon: {
+      gasAmount: toNano15("0.319"),
+      forwardGasAmount: toNano15("0.259")
+    },
+    swapTonToJetton: {
+      forwardGasAmount: toNano15("0.319")
+    }
+  };
+  constructor(address4, { gasConstants, ...options } = {}) {
+    super(address4, {
+      ...options,
+      gasConstants: {
+        ..._WCPIRouterV2_1.gasConstants,
+        ...gasConstants
+      }
+    });
+  }
+  async getPool(provider, params) {
+    const poolAddress = await this.getPoolAddressByJettonMinters(
+      provider,
+      params
+    );
+    return WCPIPoolV2_1.create(poolAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-D5R4VQ3E.js
+var WStablePoolV2_1 = class extends BasePoolV2_1 {
+  static dexType = DEX_TYPE.WStable;
+  async getPoolData(provider) {
+    const data = await this.implGetPoolData(provider);
+    return {
+      ...data.commonPoolData,
+      amp: data.stack.readBigNumber(),
+      rate: data.stack.readBigNumber(),
+      w0: data.stack.readBigNumber(),
+      rateSetterAddress: data.stack.readAddressOpt()
+    };
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-KTS34XTO.js
+import { toNano as toNano16 } from "@ton/ton";
+var WStableRouterV2_1 = class _WStableRouterV2_1 extends BaseRouterV2_1 {
+  static dexType = DEX_TYPE.WStable;
+  static gasConstants = {
+    ...BaseRouterV2_1.gasConstants,
+    swapJettonToJetton: {
+      gasAmount: toNano16("0.479"),
+      forwardGasAmount: toNano16("0.419")
+    },
+    swapJettonToTon: {
+      gasAmount: toNano16("0.479"),
+      forwardGasAmount: toNano16("0.419")
+    },
+    swapTonToJetton: {
+      forwardGasAmount: toNano16("0.479")
+    }
+  };
+  constructor(address4, { gasConstants, ...options } = {}) {
+    super(address4, {
+      ...options,
+      gasConstants: {
+        ..._WStableRouterV2_1.gasConstants,
+        ...gasConstants
+      }
+    });
+  }
+  async getPool(provider, params) {
+    const poolAddress = await this.getPoolAddressByJettonMinters(
+      provider,
+      params
+    );
+    return WStablePoolV2_1.create(poolAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-ZSA5H7PV.js
+var pTON_OP_CODES2 = {
+  TON_TRANSFER: 32736093,
+  DEPLOY_WALLET: 1331643155
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-4OOOZ56G.js
+import {
+  beginCell as beginCell14,
+  toNano as toNano17
+} from "@ton/ton";
+var PtonV2_1 = class _PtonV2_1 extends PtonV1 {
+  static version = pTON_VERSION.v2_1;
+  static gasConstants = {
+    tonTransfer: toNano17("0.01"),
+    deployWallet: toNano17("0.1")
+  };
+  version = _PtonV2_1.version;
+  gasConstants;
+  constructor(address4, { gasConstants, ...options } = {}) {
+    super(address4, options);
+    this.gasConstants = {
+      ..._PtonV2_1.gasConstants,
+      ...gasConstants
+    };
+  }
+  async createTonTransferBody(params) {
+    const builder = beginCell14();
+    builder.storeUint(pTON_OP_CODES2.TON_TRANSFER, 32);
+    builder.storeUint(params.queryId ?? 0, 64);
+    builder.storeCoins(BigInt(params.tonAmount));
+    builder.storeAddress(toAddress(params.refundAddress));
+    if (params.forwardPayload) {
+      builder.storeBit(true);
+      builder.storeRef(params.forwardPayload);
+    } else {
+      builder.storeBit(false);
+    }
+    return builder.endCell();
+  }
+  async getTonTransferTxParams(provider, params) {
+    const to = params.destinationWalletAddress ? toAddress(params.destinationWalletAddress) : await this.getWalletAddress(provider, params.destinationAddress);
+    const body = await this.createTonTransferBody({
+      tonAmount: params.tonAmount,
+      refundAddress: params.refundAddress,
+      forwardPayload: params.forwardPayload,
+      queryId: params.queryId
+    });
+    const value = BigInt(params.tonAmount) + BigInt(params.forwardTonAmount ?? 0) + BigInt(this.gasConstants.tonTransfer);
+    return { to, value, body };
+  }
+  async sendTonTransfer(provider, via, params) {
+    const txParams = await this.getTonTransferTxParams(provider, params);
+    return via.send(txParams);
+  }
+  async createDeployWalletBody(params) {
+    return beginCell14().storeUint(pTON_OP_CODES2.DEPLOY_WALLET, 32).storeUint(params.queryId ?? 0, 64).storeAddress(toAddress(params.ownerAddress)).storeAddress(toAddress(params.excessAddress)).endCell();
+  }
+  async getDeployWalletTxParams(provider, params) {
+    const to = this.address;
+    const body = await this.createDeployWalletBody({
+      ownerAddress: params.ownerAddress,
+      excessAddress: params.excessAddress,
+      queryId: params?.queryId
+    });
+    const value = BigInt(params?.gasAmount ?? this.gasConstants.deployWallet);
+    return { to, value, body };
+  }
+  async sendDeployWallet(provider, via, params) {
+    const txParams = await this.getDeployWalletTxParams(provider, params);
+    return via.send(txParams);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-5LPE44J5.js
+var RouterV2_1 = class extends BaseRouterV2_1 {
+  static CPI = CPIRouterV2_1;
+  static Stable = StableRouterV2_1;
+  static WCPI = WCPIRouterV2_1;
+  static WStable = WStableRouterV2_1;
+};
+var PoolV2_1 = class extends BasePoolV2_1 {
+  static CPI = CPIPoolV2_1;
+  static Stable = StablePoolV2_1;
+  static WCPI = WCPIPoolV2_1;
+  static WStable = WStablePoolV2_1;
+};
+var DEX2 = {
+  Router: RouterV2_1,
+  Pool: PoolV2_1,
+  LpAccount: LpAccountV2_1,
+  Vault: VaultV2_1,
+  pTON: PtonV2_1
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-R6GQHPPW.js
+var VaultV2_2 = class extends VaultV2_1 {
+  static version = DEX_VERSION.v2_2;
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-XBZ6KIKA.js
+var LpAccountV2_2 = class extends LpAccountV2_1 {
+  static version = DEX_VERSION.v2_2;
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-UHNXDBA4.js
+var BasePoolV2_2 = class extends BasePoolV2_1 {
+  static version = DEX_VERSION.v2_2;
+  async getLpAccount(provider, params) {
+    const lpAccountAddress = await this.getLpAccountAddress(provider, params);
+    return LpAccountV2_2.create(lpAccountAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-W5BTFHCU.js
+var BaseRouterV2_2 = class extends BaseRouterV2_1 {
+  static version = DEX_VERSION.v2_2;
+  async getPool(provider, params) {
+    const poolAddress = await this.getPoolAddressByJettonMinters(
+      provider,
+      params
+    );
+    return BasePoolV2_2.create(poolAddress);
+  }
+  async getVault(provider, params) {
+    const tokenMinter = provider.open(JettonMinter.create(params.tokenMinter));
+    const vaultAddress = await this.getVaultAddress(provider, {
+      user: params.user,
+      tokenWallet: await tokenMinter.getWalletAddress(this.address)
+    });
+    return VaultV2_2.create(vaultAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-MVLUFHSB.js
+var CPIPoolV2_2 = class extends CPIPoolV2_1 {
+  static version = DEX_VERSION.v2_2;
+  async getLpAccount(provider, params) {
+    const lpAccountAddress = await this.getLpAccountAddress(provider, params);
+    return LpAccountV2_2.create(lpAccountAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-PGCWH6QI.js
+var CPIRouterV2_2 = class extends CPIRouterV2_1 {
+  static version = DEX_VERSION.v2_2;
+  async getPool(provider, params) {
+    const poolAddress = await this.getPoolAddressByJettonMinters(
+      provider,
+      params
+    );
+    return CPIPoolV2_2.create(poolAddress);
+  }
+  async getVault(provider, params) {
+    const tokenMinter = provider.open(JettonMinter.create(params.tokenMinter));
+    const vaultAddress = await this.getVaultAddress(provider, {
+      user: params.user,
+      tokenWallet: await tokenMinter.getWalletAddress(this.address)
+    });
+    return VaultV2_2.create(vaultAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-X3PT4LB6.js
+var StablePoolV2_2 = class extends StablePoolV2_1 {
+  static version = DEX_VERSION.v2_2;
+  async getLpAccount(provider, params) {
+    const lpAccountAddress = await this.getLpAccountAddress(provider, params);
+    return LpAccountV2_2.create(lpAccountAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-GHJFY7T3.js
+var StableRouterV2_2 = class extends StableRouterV2_1 {
+  static version = DEX_VERSION.v2_2;
+  async getPool(provider, params) {
+    const poolAddress = await this.getPoolAddressByJettonMinters(
+      provider,
+      params
+    );
+    return StablePoolV2_2.create(poolAddress);
+  }
+  async getVault(provider, params) {
+    const tokenMinter = provider.open(JettonMinter.create(params.tokenMinter));
+    const vaultAddress = await this.getVaultAddress(provider, {
+      user: params.user,
+      tokenWallet: await tokenMinter.getWalletAddress(this.address)
+    });
+    return VaultV2_2.create(vaultAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-UBOSEJWA.js
+var WCPIPoolV2_2 = class extends WCPIPoolV2_1 {
+  static version = DEX_VERSION.v2_2;
+  async getLpAccount(provider, params) {
+    const lpAccountAddress = await this.getLpAccountAddress(provider, params);
+    return LpAccountV2_2.create(lpAccountAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-OW5D6WMM.js
+var WCPIRouterV2_2 = class extends WCPIRouterV2_1 {
+  static version = DEX_VERSION.v2_2;
+  async getPool(provider, params) {
+    const poolAddress = await this.getPoolAddressByJettonMinters(
+      provider,
+      params
+    );
+    return WCPIPoolV2_2.create(poolAddress);
+  }
+  async getVault(provider, params) {
+    const tokenMinter = provider.open(JettonMinter.create(params.tokenMinter));
+    const vaultAddress = await this.getVaultAddress(provider, {
+      user: params.user,
+      tokenWallet: await tokenMinter.getWalletAddress(this.address)
+    });
+    return VaultV2_2.create(vaultAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-DCJ3CQ52.js
+var WStablePoolV2_2 = class extends WStablePoolV2_1 {
+  static version = DEX_VERSION.v2_2;
+  async getLpAccount(provider, params) {
+    const lpAccountAddress = await this.getLpAccountAddress(provider, params);
+    return LpAccountV2_2.create(lpAccountAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-5L3VBOB3.js
+var WStableRouterV2_2 = class extends WStableRouterV2_1 {
+  static version = DEX_VERSION.v2_2;
+  async getPool(provider, params) {
+    const poolAddress = await this.getPoolAddressByJettonMinters(
+      provider,
+      params
+    );
+    return WStablePoolV2_2.create(poolAddress);
+  }
+  async getVault(provider, params) {
+    const tokenMinter = provider.open(JettonMinter.create(params.tokenMinter));
+    const vaultAddress = await this.getVaultAddress(provider, {
+      user: params.user,
+      tokenWallet: await tokenMinter.getWalletAddress(this.address)
+    });
+    return VaultV2_2.create(vaultAddress);
+  }
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-UFVKG5I6.js
+var RouterV2_2 = class extends BaseRouterV2_2 {
+  static CPI = CPIRouterV2_2;
+  static Stable = StableRouterV2_2;
+  static WCPI = WCPIRouterV2_2;
+  static WStable = WStableRouterV2_2;
+};
+var PoolV2_2 = class extends BasePoolV2_2 {
+  static CPI = CPIPoolV2_2;
+  static Stable = StablePoolV2_2;
+  static WCPI = WCPIPoolV2_2;
+  static WStable = WStablePoolV2_2;
+};
+var DEX3 = {
+  Router: RouterV2_2,
+  Pool: PoolV2_2,
+  LpAccount: LpAccountV2_2,
+  Vault: VaultV2_2,
+  pTON: PtonV2_1
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-TGJ3Z7X3.js
+var DEX4 = {
+  [DEX_VERSION.v1]: DEX,
+  [DEX_VERSION.v2_1]: DEX2,
+  [DEX_VERSION.v2_2]: DEX3
+};
+
+// node_modules/@ston-fi/sdk/dist/chunk-6QVKWEJ2.js
+var pTON = {
+  [pTON_VERSION.v1]: PtonV1,
+  [pTON_VERSION.v2_1]: PtonV2_1
+};
 
 // node_modules/@ston-fi/api/dist/esm/index.js
 import { ofetch } from "ofetch";
@@ -12747,27 +14708,27 @@ var jettonSwapExecutor = async (params, context) => {
     }
     const isTonInput = from_asset.toLowerCase() === "ton";
     const fromAddress = isTonInput ? NATIVE_TON_ADDRESS : from_asset;
-    const toAddress = to_asset;
+    const toAddress2 = to_asset;
     if (!isTonInput && !fromAddress.match(/^[EUe][Qq][A-Za-z0-9_-]{46}$/)) {
       return {
         success: false,
         error: `Invalid from_asset address: ${from_asset}`
       };
     }
-    if (!toAddress.match(/^[EUe][Qq][A-Za-z0-9_-]{46}$/)) {
+    if (!toAddress2.match(/^[EUe][Qq][A-Za-z0-9_-]{46}$/)) {
       return {
         success: false,
-        error: `Invalid to_asset address: ${toAddress}`
+        error: `Invalid to_asset address: ${toAddress2}`
       };
     }
     const endpoint = await getHttpEndpoint9({ network: "mainnet" });
     const tonClient = new TonClient9({ endpoint });
     const stonApiClient = new StonApiClient();
-    console.log(`Simulating swap: ${amount} ${fromAddress} \u2192 ${toAddress}`);
+    console.log(`Simulating swap: ${amount} ${fromAddress} \u2192 ${toAddress2}`);
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
-      askAddress: toAddress,
-      offerUnits: toNano6(amount).toString(),
+      askAddress: toAddress2,
+      offerUnits: toNano18(amount).toString(),
       slippageTolerance: slippage.toString()
     });
     if (!simulationResult || !simulationResult.router) {
@@ -12777,7 +14738,7 @@ var jettonSwapExecutor = async (params, context) => {
       };
     }
     const { router: routerInfo } = simulationResult;
-    const router = tonClient.open(new DEX.v1.Router(routerInfo.address));
+    const router = tonClient.open(new DEX4.v1.Router(routerInfo.address));
     const keyPair = await mnemonicToPrivateKey7(walletData.mnemonic);
     const wallet = WalletContractV5R17.create({
       workchain: 0,
@@ -12791,7 +14752,7 @@ var jettonSwapExecutor = async (params, context) => {
       txParams = await router.getSwapTonToJettonTxParams({
         userWalletAddress: walletData.address,
         proxyTon,
-        askJettonAddress: toAddress,
+        askJettonAddress: toAddress2,
         offerAmount: BigInt(simulationResult.offerUnits),
         minAskAmount: BigInt(simulationResult.minAskUnits)
       });
@@ -12799,7 +14760,7 @@ var jettonSwapExecutor = async (params, context) => {
       txParams = await router.getSwapJettonToJettonTxParams({
         userWalletAddress: walletData.address,
         offerJettonAddress: fromAddress,
-        askJettonAddress: toAddress,
+        askJettonAddress: toAddress2,
         offerAmount: BigInt(simulationResult.offerUnits),
         minAskAmount: BigInt(simulationResult.minAskUnits)
       });
@@ -12822,7 +14783,7 @@ var jettonSwapExecutor = async (params, context) => {
       success: true,
       data: {
         from: fromAddress,
-        to: toAddress,
+        to: toAddress2,
         amountIn: amount.toString(),
         expectedOutput: expectedOutput.toFixed(6),
         minOutput: (Number(simulationResult.minAskUnits) / 10 ** 9).toFixed(6),
@@ -12847,8 +14808,8 @@ var jettonSwapExecutor = async (params, context) => {
 // src/agent/tools/jetton/send.ts
 import { Type as Type82 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey8 } from "@ton/crypto";
-import { WalletContractV5R1 as WalletContractV5R18, TonClient as TonClient10, toNano as toNano7, internal as internal7 } from "@ton/ton";
-import { Address as Address8, SendMode as SendMode7, beginCell as beginCell4 } from "@ton/core";
+import { WalletContractV5R1 as WalletContractV5R18, TonClient as TonClient10, toNano as toNano19, internal as internal7 } from "@ton/ton";
+import { Address as Address11, SendMode as SendMode7, beginCell as beginCell15 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint10 } from "@orbs-network/ton-access";
 var JETTON_TRANSFER_OP = 260734629;
 var jettonSendTool = {
@@ -12883,7 +14844,7 @@ var jettonSendExecutor = async (params, context) => {
       };
     }
     try {
-      Address8.parse(to);
+      Address11.parse(to);
     } catch {
       return {
         success: false,
@@ -12904,7 +14865,7 @@ var jettonSendExecutor = async (params, context) => {
     }
     const jettonsData = await jettonsResponse.json();
     const jettonBalance = jettonsData.balances?.find(
-      (b) => b.jetton.address.toLowerCase() === jetton_address.toLowerCase() || Address8.parse(b.jetton.address).toString() === Address8.parse(jetton_address).toString()
+      (b) => b.jetton.address.toLowerCase() === jetton_address.toLowerCase() || Address11.parse(b.jetton.address).toString() === Address11.parse(jetton_address).toString()
     );
     if (!jettonBalance) {
       return {
@@ -12924,11 +14885,11 @@ var jettonSendExecutor = async (params, context) => {
         error: `Insufficient ${symbol} balance. You have ${balanceHuman.toFixed(4)} but trying to send ${amount}`
       };
     }
-    let forwardPayload = beginCell4().endCell();
+    let forwardPayload = beginCell15().endCell();
     if (comment) {
-      forwardPayload = beginCell4().storeUint(0, 32).storeStringTail(comment).endCell();
+      forwardPayload = beginCell15().storeUint(0, 32).storeStringTail(comment).endCell();
     }
-    const messageBody = beginCell4().storeUint(JETTON_TRANSFER_OP, 32).storeUint(0, 64).storeCoins(amountInUnits).storeAddress(Address8.parse(to)).storeAddress(Address8.parse(walletData.address)).storeBit(false).storeCoins(comment ? toNano7("0.01") : BigInt(1)).storeBit(comment ? true : false).storeMaybeRef(comment ? forwardPayload : null).endCell();
+    const messageBody = beginCell15().storeUint(JETTON_TRANSFER_OP, 32).storeUint(0, 64).storeCoins(amountInUnits).storeAddress(Address11.parse(to)).storeAddress(Address11.parse(walletData.address)).storeBit(false).storeCoins(comment ? toNano19("0.01") : BigInt(1)).storeBit(comment ? true : false).storeMaybeRef(comment ? forwardPayload : null).endCell();
     const keyPair = await mnemonicToPrivateKey8(walletData.mnemonic);
     const wallet = WalletContractV5R18.create({
       workchain: 0,
@@ -12944,8 +14905,8 @@ var jettonSendExecutor = async (params, context) => {
       sendMode: SendMode7.PAY_GAS_SEPARATELY + SendMode7.IGNORE_ERRORS,
       messages: [
         internal7({
-          to: Address8.parse(senderJettonWallet),
-          value: toNano7("0.05"),
+          to: Address11.parse(senderJettonWallet),
+          value: toNano19("0.05"),
           // Gas for jetton transfer
           body: messageBody,
           bounce: true
@@ -13297,7 +15258,7 @@ var jettonSearchExecutor = async (params, context) => {
 
 // src/agent/tools/jetton/quote.ts
 import { Type as Type86 } from "@sinclair/typebox";
-import { toNano as toNano8 } from "@ton/ton";
+import { toNano as toNano20 } from "@ton/ton";
 var NATIVE_TON_ADDRESS2 = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 var jettonQuoteTool = {
   name: "jetton_quote",
@@ -13327,12 +15288,12 @@ var jettonQuoteExecutor = async (params, context) => {
     const { from_asset, to_asset, amount, slippage = 0.01 } = params;
     const isTonInput = from_asset.toLowerCase() === "ton";
     const fromAddress = isTonInput ? NATIVE_TON_ADDRESS2 : from_asset;
-    const toAddress = to_asset;
+    const toAddress2 = to_asset;
     const stonApiClient = new StonApiClient();
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
-      askAddress: toAddress,
-      offerUnits: toNano8(amount).toString(),
+      askAddress: toAddress2,
+      offerUnits: toNano20(amount).toString(),
       slippageTolerance: slippage.toString()
     });
     if (!simulationResult) {
@@ -13356,7 +15317,7 @@ var jettonQuoteExecutor = async (params, context) => {
     const quote = {
       from: fromAddress,
       fromSymbol,
-      to: toAddress,
+      to: toAddress2,
       toSymbol,
       amountIn: amount.toString(),
       expectedOutput: expectedOutput.toFixed(6),
@@ -13813,8 +15774,8 @@ var jettonPoolsExecutor = async (params, context) => {
 
 // src/agent/tools/dedust/quote.ts
 import { Type as Type91 } from "@sinclair/typebox";
-import { TonClient as TonClient11, toNano as toNano9, fromNano as fromNano4 } from "@ton/ton";
-import { Address as Address9 } from "@ton/core";
+import { TonClient as TonClient11, toNano as toNano21, fromNano as fromNano4 } from "@ton/ton";
+import { Address as Address12 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint11 } from "@orbs-network/ton-access";
 import { Factory, Asset, PoolType, ReadinessStatus } from "@dedust/sdk";
 
@@ -13871,7 +15832,7 @@ var dedustQuoteExecutor = async (params, context) => {
     let toAssetAddr = to_asset;
     if (!isTonInput) {
       try {
-        fromAssetAddr = Address9.parse(from_asset).toString();
+        fromAssetAddr = Address12.parse(from_asset).toString();
       } catch (error) {
         return {
           success: false,
@@ -13881,7 +15842,7 @@ var dedustQuoteExecutor = async (params, context) => {
     }
     if (!isTonOutput) {
       try {
-        toAssetAddr = Address9.parse(to_asset).toString();
+        toAssetAddr = Address12.parse(to_asset).toString();
       } catch (error) {
         return {
           success: false,
@@ -13892,10 +15853,10 @@ var dedustQuoteExecutor = async (params, context) => {
     const endpoint = await getHttpEndpoint11({ network: "mainnet" });
     const tonClient = new TonClient11({ endpoint });
     const factory = tonClient.open(
-      Factory.createFromAddress(Address9.parse(DEDUST_FACTORY_MAINNET))
+      Factory.createFromAddress(Address12.parse(DEDUST_FACTORY_MAINNET))
     );
-    const fromAsset = isTonInput ? Asset.native() : Asset.jetton(Address9.parse(fromAssetAddr));
-    const toAsset = isTonOutput ? Asset.native() : Asset.jetton(Address9.parse(toAssetAddr));
+    const fromAsset = isTonInput ? Asset.native() : Asset.jetton(Address12.parse(fromAssetAddr));
+    const toAsset = isTonOutput ? Asset.native() : Asset.jetton(Address12.parse(toAssetAddr));
     const poolTypeEnum = pool_type === "stable" ? PoolType.STABLE : PoolType.VOLATILE;
     const pool = tonClient.open(await factory.getPool(poolTypeEnum, [fromAsset, toAsset]));
     const readinessStatus = await pool.getReadinessStatus();
@@ -13906,7 +15867,7 @@ var dedustQuoteExecutor = async (params, context) => {
       };
     }
     const reserves = await pool.getReserves();
-    const amountIn = toNano9(amount);
+    const amountIn = toNano21(amount);
     const { amountOut, tradeFee } = await pool.getEstimatedSwapOut({
       assetIn: fromAsset,
       amountIn
@@ -13971,8 +15932,8 @@ var dedustQuoteExecutor = async (params, context) => {
 // src/agent/tools/dedust/swap.ts
 import { Type as Type92 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey9 } from "@ton/crypto";
-import { WalletContractV5R1 as WalletContractV5R19, TonClient as TonClient12, toNano as toNano10, fromNano as fromNano5 } from "@ton/ton";
-import { Address as Address10 } from "@ton/core";
+import { WalletContractV5R1 as WalletContractV5R19, TonClient as TonClient12, toNano as toNano22, fromNano as fromNano5 } from "@ton/ton";
+import { Address as Address13 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint12 } from "@orbs-network/ton-access";
 import { Factory as Factory2, Asset as Asset2, PoolType as PoolType2, ReadinessStatus as ReadinessStatus2, JettonRoot, VaultJetton } from "@dedust/sdk";
 var dedustSwapTool = {
@@ -14019,7 +15980,7 @@ var dedustSwapExecutor = async (params, context) => {
     let toAssetAddr = to_asset;
     if (!isTonInput) {
       try {
-        fromAssetAddr = Address10.parse(from_asset).toString();
+        fromAssetAddr = Address13.parse(from_asset).toString();
       } catch (error) {
         return {
           success: false,
@@ -14029,7 +15990,7 @@ var dedustSwapExecutor = async (params, context) => {
     }
     if (!isTonOutput) {
       try {
-        toAssetAddr = Address10.parse(to_asset).toString();
+        toAssetAddr = Address13.parse(to_asset).toString();
       } catch (error) {
         return {
           success: false,
@@ -14040,10 +16001,10 @@ var dedustSwapExecutor = async (params, context) => {
     const endpoint = await getHttpEndpoint12({ network: "mainnet" });
     const tonClient = new TonClient12({ endpoint });
     const factory = tonClient.open(
-      Factory2.createFromAddress(Address10.parse(DEDUST_FACTORY_MAINNET))
+      Factory2.createFromAddress(Address13.parse(DEDUST_FACTORY_MAINNET))
     );
-    const fromAssetObj = isTonInput ? Asset2.native() : Asset2.jetton(Address10.parse(fromAssetAddr));
-    const toAssetObj = isTonOutput ? Asset2.native() : Asset2.jetton(Address10.parse(toAssetAddr));
+    const fromAssetObj = isTonInput ? Asset2.native() : Asset2.jetton(Address13.parse(fromAssetAddr));
+    const toAssetObj = isTonOutput ? Asset2.native() : Asset2.jetton(Address13.parse(toAssetAddr));
     const poolTypeEnum = pool_type === "stable" ? PoolType2.STABLE : PoolType2.VOLATILE;
     const pool = tonClient.open(await factory.getPool(poolTypeEnum, [fromAssetObj, toAssetObj]));
     const readinessStatus = await pool.getReadinessStatus();
@@ -14053,7 +16014,7 @@ var dedustSwapExecutor = async (params, context) => {
         error: `Pool not ready. Status: ${readinessStatus}. Try the other pool type (${pool_type === "volatile" ? "stable" : "volatile"}) or check if the pool exists.`
       };
     }
-    const amountIn = toNano10(amount);
+    const amountIn = toNano22(amount);
     const { amountOut, tradeFee } = await pool.getEstimatedSwapOut({
       assetIn: fromAssetObj,
       amountIn
@@ -14079,10 +16040,10 @@ var dedustSwapExecutor = async (params, context) => {
         poolAddress: pool.address,
         amount: amountIn,
         limit: minAmountOut,
-        gasAmount: toNano10(DEDUST_GAS.SWAP_TON_TO_JETTON)
+        gasAmount: toNano22(DEDUST_GAS.SWAP_TON_TO_JETTON)
       });
     } else {
-      const jettonAddress = Address10.parse(fromAssetAddr);
+      const jettonAddress = Address13.parse(fromAssetAddr);
       const jettonVault = tonClient.open(await factory.getJettonVault(jettonAddress));
       const vaultStatus = await jettonVault.getReadinessStatus();
       if (vaultStatus !== ReadinessStatus2.READY) {
@@ -14093,17 +16054,17 @@ var dedustSwapExecutor = async (params, context) => {
       }
       const jettonRoot = tonClient.open(JettonRoot.createFromAddress(jettonAddress));
       const jettonWallet = tonClient.open(
-        await jettonRoot.getWallet(Address10.parse(walletData.address))
+        await jettonRoot.getWallet(Address13.parse(walletData.address))
       );
       const swapPayload = VaultJetton.createSwapPayload({
         poolAddress: pool.address,
         limit: minAmountOut
       });
-      await jettonWallet.sendTransfer(sender, toNano10(DEDUST_GAS.SWAP_JETTON_TO_ANY), {
+      await jettonWallet.sendTransfer(sender, toNano22(DEDUST_GAS.SWAP_JETTON_TO_ANY), {
         destination: jettonVault.address,
         amount: amountIn,
-        responseAddress: Address10.parse(walletData.address),
-        forwardAmount: toNano10(DEDUST_GAS.FORWARD_GAS),
+        responseAddress: Address13.parse(walletData.address),
+        forwardAmount: toNano22(DEDUST_GAS.FORWARD_GAS),
         forwardPayload: swapPayload
       });
     }
@@ -14267,8 +16228,8 @@ var dedustPoolsExecutor = async (params, context) => {
 
 // src/agent/tools/dex/smart-quote.ts
 import { Type as Type94 } from "@sinclair/typebox";
-import { TonClient as TonClient13, toNano as toNano11, fromNano as fromNano6 } from "@ton/ton";
-import { Address as Address11 } from "@ton/core";
+import { TonClient as TonClient13, toNano as toNano23, fromNano as fromNano6 } from "@ton/ton";
+import { Address as Address14 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint13 } from "@orbs-network/ton-access";
 import { Factory as Factory3, Asset as Asset3, PoolType as PoolType3, ReadinessStatus as ReadinessStatus3 } from "@dedust/sdk";
 var dexQuoteTool = {
@@ -14299,12 +16260,12 @@ async function getStonfiQuote(fromAsset, toAsset, amount, slippage) {
     const isTonInput = fromAsset.toLowerCase() === "ton";
     const isTonOutput = toAsset.toLowerCase() === "ton";
     const fromAddress = isTonInput ? NATIVE_TON_ADDRESS3 : fromAsset;
-    const toAddress = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
+    const toAddress2 = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
     const stonApiClient = new StonApiClient();
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
-      askAddress: toAddress,
-      offerUnits: toNano11(amount).toString(),
+      askAddress: toAddress2,
+      offerUnits: toNano23(amount).toString(),
       slippageTolerance: slippage.toString()
     });
     if (!simulationResult) {
@@ -14349,10 +16310,10 @@ async function getDedustQuote(fromAsset, toAsset, amount, slippage, tonClient) {
     const isTonInput = fromAsset.toLowerCase() === "ton";
     const isTonOutput = toAsset.toLowerCase() === "ton";
     const factory = tonClient.open(
-      Factory3.createFromAddress(Address11.parse(DEDUST_FACTORY_MAINNET))
+      Factory3.createFromAddress(Address14.parse(DEDUST_FACTORY_MAINNET))
     );
-    const fromAssetObj = isTonInput ? Asset3.native() : Asset3.jetton(Address11.parse(fromAsset));
-    const toAssetObj = isTonOutput ? Asset3.native() : Asset3.jetton(Address11.parse(toAsset));
+    const fromAssetObj = isTonInput ? Asset3.native() : Asset3.jetton(Address14.parse(fromAsset));
+    const toAssetObj = isTonOutput ? Asset3.native() : Asset3.jetton(Address14.parse(toAsset));
     let pool;
     let poolType = "volatile";
     try {
@@ -14383,7 +16344,7 @@ async function getDedustQuote(fromAsset, toAsset, amount, slippage, tonClient) {
         error: "Pool lookup failed"
       };
     }
-    const amountIn = toNano11(amount);
+    const amountIn = toNano23(amount);
     const { amountOut, tradeFee } = await pool.getEstimatedSwapOut({
       assetIn: fromAssetObj,
       amountIn
@@ -14526,10 +16487,9 @@ Use dex_swap to execute on the best DEX, or jetton_swap/dedust_swap for specific
 // src/agent/tools/dex/smart-swap.ts
 import { Type as Type95 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey10 } from "@ton/crypto";
-import { WalletContractV5R1 as WalletContractV5R110, TonClient as TonClient14, toNano as toNano12, fromNano as fromNano7 } from "@ton/ton";
-import { Address as Address12, SendMode as SendMode8, internal as internal8 } from "@ton/core";
+import { WalletContractV5R1 as WalletContractV5R110, TonClient as TonClient14, toNano as toNano24, fromNano as fromNano7 } from "@ton/ton";
+import { Address as Address15, SendMode as SendMode8, internal as internal8 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint14 } from "@orbs-network/ton-access";
-import { DEX as DEX2, pTON as pTON2 } from "@ston-fi/sdk";
 import { Factory as Factory4, Asset as Asset4, PoolType as PoolType4, ReadinessStatus as ReadinessStatus4, JettonRoot as JettonRoot2, VaultJetton as VaultJetton2 } from "@dedust/sdk";
 var dexSwapTool = {
   name: "dex_swap",
@@ -14564,12 +16524,12 @@ async function getStonfiQuote2(fromAsset, toAsset, amount, slippage) {
     const isTonInput = fromAsset.toLowerCase() === "ton";
     const isTonOutput = toAsset.toLowerCase() === "ton";
     const fromAddress = isTonInput ? NATIVE_TON_ADDRESS3 : fromAsset;
-    const toAddress = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
+    const toAddress2 = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
     const stonApiClient = new StonApiClient();
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
-      askAddress: toAddress,
-      offerUnits: toNano12(amount).toString(),
+      askAddress: toAddress2,
+      offerUnits: toNano24(amount).toString(),
       slippageTolerance: slippage.toString()
     });
     if (!simulationResult) {
@@ -14596,10 +16556,10 @@ async function getDedustQuote2(fromAsset, toAsset, amount, slippage, tonClient)
     const isTonInput = fromAsset.toLowerCase() === "ton";
     const isTonOutput = toAsset.toLowerCase() === "ton";
     const factory = tonClient.open(
-      Factory4.createFromAddress(Address12.parse(DEDUST_FACTORY_MAINNET))
+      Factory4.createFromAddress(Address15.parse(DEDUST_FACTORY_MAINNET))
     );
-    const fromAssetObj = isTonInput ? Asset4.native() : Asset4.jetton(Address12.parse(fromAsset));
-    const toAssetObj = isTonOutput ? Asset4.native() : Asset4.jetton(Address12.parse(toAsset));
+    const fromAssetObj = isTonInput ? Asset4.native() : Asset4.jetton(Address15.parse(fromAsset));
+    const toAssetObj = isTonOutput ? Asset4.native() : Asset4.jetton(Address15.parse(toAsset));
     let pool;
     let poolType = "volatile";
     try {
@@ -14616,7 +16576,7 @@ async function getDedustQuote2(fromAsset, toAsset, amount, slippage, tonClient)
     } catch {
       return { dex: "DeDust", expectedOutput: 0, available: false, error: "Pool lookup failed" };
     }
-    const amountIn = toNano12(amount);
+    const amountIn = toNano24(amount);
     const { amountOut, tradeFee } = await pool.getEstimatedSwapOut({
       assetIn: fromAssetObj,
       amountIn
@@ -14645,7 +16605,7 @@ async function getDedustQuote2(fromAsset, toAsset, amount, slippage, tonClient)
 async function executeStonfiSwap(fromAsset, toAsset, amount, slippage, simulationResult, walletData, tonClient) {
   const isTonInput = fromAsset.toLowerCase() === "ton";
   const isTonOutput = toAsset.toLowerCase() === "ton";
-  const toAddress = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
+  const toAddress2 = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
   const keyPair = await mnemonicToPrivateKey10(walletData.mnemonic);
   const wallet = WalletContractV5R110.create({
     workchain: 0,
@@ -14654,14 +16614,14 @@ async function executeStonfiSwap(fromAsset, toAsset, amount, slippage, simulatio
   const walletContract = tonClient.open(wallet);
   const seqno = await walletContract.getSeqno();
   const { router: routerInfo } = simulationResult;
-  const router = tonClient.open(new DEX2.v1.Router(routerInfo.address));
+  const router = tonClient.open(new DEX4.v1.Router(routerInfo.address));
   let txParams;
   if (isTonInput) {
-    const proxyTon = new pTON2.v1(routerInfo.ptonMasterAddress);
+    const proxyTon = new pTON.v1(routerInfo.ptonMasterAddress);
     txParams = await router.getSwapTonToJettonTxParams({
       userWalletAddress: walletData.address,
       proxyTon,
-      askJettonAddress: toAddress,
+      askJettonAddress: toAddress2,
       offerAmount: BigInt(simulationResult.offerUnits),
       minAskAmount: BigInt(simulationResult.minAskUnits)
     });
@@ -14669,7 +16629,7 @@ async function executeStonfiSwap(fromAsset, toAsset, amount, slippage, simulatio
     txParams = await router.getSwapJettonToJettonTxParams({
       userWalletAddress: walletData.address,
       offerJettonAddress: fromAsset,
-      askJettonAddress: toAddress,
+      askJettonAddress: toAddress2,
       offerAmount: BigInt(simulationResult.offerUnits),
       minAskAmount: BigInt(simulationResult.minAskUnits)
     });
@@ -14700,32 +16660,32 @@ async function executeDedustSwap(fromAsset, toAsset, amount, pool, minAmountOut,
   });
   const walletContract = tonClient.open(wallet);
   const sender = walletContract.sender(keyPair.secretKey);
-  const factory = tonClient.open(Factory4.createFromAddress(Address12.parse(DEDUST_FACTORY_MAINNET)));
-  const amountIn = toNano12(amount);
+  const factory = tonClient.open(Factory4.createFromAddress(Address15.parse(DEDUST_FACTORY_MAINNET)));
+  const amountIn = toNano24(amount);
   if (isTonInput) {
     const tonVault = tonClient.open(await factory.getNativeVault());
     await tonVault.sendSwap(sender, {
       poolAddress: pool.address,
       amount: amountIn,
       limit: minAmountOut,
-      gasAmount: toNano12(DEDUST_GAS.SWAP_TON_TO_JETTON)
+      gasAmount: toNano24(DEDUST_GAS.SWAP_TON_TO_JETTON)
     });
   } else {
-    const jettonAddress = Address12.parse(fromAsset);
+    const jettonAddress = Address15.parse(fromAsset);
     const jettonVault = tonClient.open(await factory.getJettonVault(jettonAddress));
     const jettonRoot = tonClient.open(JettonRoot2.createFromAddress(jettonAddress));
     const jettonWallet = tonClient.open(
-      await jettonRoot.getWallet(Address12.parse(walletData.address))
+      await jettonRoot.getWallet(Address15.parse(walletData.address))
     );
     const swapPayload = VaultJetton2.createSwapPayload({
       poolAddress: pool.address,
       limit: minAmountOut
     });
-    await jettonWallet.sendTransfer(sender, toNano12(DEDUST_GAS.SWAP_JETTON_TO_ANY), {
+    await jettonWallet.sendTransfer(sender, toNano24(DEDUST_GAS.SWAP_JETTON_TO_ANY), {
       destination: jettonVault.address,
       amount: amountIn,
-      responseAddress: Address12.parse(walletData.address),
-      forwardAmount: toNano12(DEDUST_GAS.FORWARD_GAS),
+      responseAddress: Address15.parse(walletData.address),
+      forwardAmount: toNano24(DEDUST_GAS.FORWARD_GAS),
       forwardPayload: swapPayload
     });
   }
@@ -16130,14 +18090,14 @@ Example: "Send 2 TON to EQxxx with memo: john_doe"`,
 };
 var casinoBalanceExecutor = async (params, context) => {
   try {
-    const address = getWalletAddress();
-    if (!address) {
+    const address4 = getWalletAddress();
+    if (!address4) {
       return {
         success: false,
         error: "Casino wallet not initialized. Contact admin."
       };
     }
-    const balanceInfo = await getWalletBalance(address);
+    const balanceInfo = await getWalletBalance(address4);
     if (!balanceInfo) {
       return {
         success: false,
@@ -16168,7 +18128,7 @@ var casinoBalanceExecutor = async (params, context) => {
     return {
       success: true,
       data: {
-        address,
+        address: address4,
         balance: balance.toFixed(2),
         balanceNano: balanceInfo.balanceNano,
         status,
@@ -16199,7 +18159,7 @@ import { Api as Api53 } from "telegram";
 
 // src/casino/payment-verifier.ts
 import { TonClient as TonClient15, fromNano as fromNano8 } from "@ton/ton";
-import { Address as Address13 } from "@ton/core";
+import { Address as Address16 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint15 } from "@orbs-network/ton-access";
 
 // src/casino/retry.ts
@@ -16276,7 +18236,7 @@ async function verifyPayment(db, params) {
     const { botWalletAddress, betAmount, requestTime, gameType, userId } = params;
     const endpoint = await getHttpEndpoint15({ network: "mainnet" });
     const client = new TonClient15({ endpoint });
-    const botAddress = Address13.parse(botWalletAddress);
+    const botAddress = Address16.parse(botWalletAddress);
     const transactions = await withBlockchainRetry(
       () => client.getTransactions(botAddress, { limit: 20 }),
       "getTransactions"
@@ -16433,13 +18393,13 @@ function shouldAwardDailyJackpot(db) {
 
 // src/casino/payout-sender.ts
 import { mnemonicToPrivateKey as mnemonicToPrivateKey11 } from "@ton/crypto";
-import { WalletContractV5R1 as WalletContractV5R111, TonClient as TonClient16, toNano as toNano13, internal as internal9 } from "@ton/ton";
-import { Address as Address14, SendMode as SendMode9 } from "@ton/core";
+import { WalletContractV5R1 as WalletContractV5R111, TonClient as TonClient16, toNano as toNano25, internal as internal9 } from "@ton/ton";
+import { Address as Address17, SendMode as SendMode9 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint16 } from "@orbs-network/ton-access";
 async function sendPayout(playerAddress, amount, message) {
   try {
     try {
-      Address14.parse(playerAddress);
+      Address17.parse(playerAddress);
     } catch (e) {
       return {
         success: false,
@@ -16469,8 +18429,8 @@ async function sendPayout(playerAddress, amount, message) {
         sendMode: SendMode9.PAY_GAS_SEPARATELY,
         messages: [
           internal9({
-            to: Address14.parse(playerAddress),
-            value: toNano13(amount),
+            to: Address17.parse(playerAddress),
+            value: toNano25(amount),
             body: message,
             bounce: false
           })
@@ -16865,8 +18825,8 @@ var casinoDiceExecutor = async (params, context) => {
 // src/agent/tools/casino/payout.ts
 import { Type as Type108 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey12 } from "@ton/crypto";
-import { WalletContractV5R1 as WalletContractV5R112, TonClient as TonClient17, toNano as toNano14, internal as internal10 } from "@ton/ton";
-import { Address as Address15, SendMode as SendMode10 } from "@ton/core";
+import { WalletContractV5R1 as WalletContractV5R112, TonClient as TonClient17, toNano as toNano26, internal as internal10 } from "@ton/ton";
+import { Address as Address18, SendMode as SendMode10 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint17 } from "@orbs-network/ton-access";
 var casinoPayoutTool = {
   name: "casino_payout",
@@ -16963,7 +18923,7 @@ var casinoPayoutExecutor = async (params, context) => {
     }
     const payout = bet_amount * multiplier;
     try {
-      Address15.parse(player_address);
+      Address18.parse(player_address);
     } catch (e) {
       return {
         success: false,
@@ -16993,8 +18953,8 @@ var casinoPayoutExecutor = async (params, context) => {
       sendMode: SendMode10.PAY_GAS_SEPARATELY + SendMode10.IGNORE_ERRORS,
       messages: [
         internal10({
-          to: Address15.parse(player_address),
-          value: toNano14(payout),
+          to: Address18.parse(player_address),
+          value: toNano26(payout),
           body: `${winType} You won ${payout} TON (${multiplier}x)`,
           bounce: false
         })
@@ -17795,17 +19755,17 @@ var GiftDetector = class {
 
 // src/ton/transfer.ts
 import { mnemonicToPrivateKey as mnemonicToPrivateKey13 } from "@ton/crypto";
-import { WalletContractV5R1 as WalletContractV5R113, TonClient as TonClient18, toNano as toNano15, internal as internal11 } from "@ton/ton";
-import { Address as Address16, SendMode as SendMode11 } from "@ton/core";
+import { WalletContractV5R1 as WalletContractV5R113, TonClient as TonClient18, toNano as toNano27, internal as internal11 } from "@ton/ton";
+import { Address as Address19, SendMode as SendMode11 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint18 } from "@orbs-network/ton-access";
 async function sendTon(params) {
   try {
-    const { toAddress, amount, comment = "", bounce = false } = params;
+    const { toAddress: toAddress2, amount, comment = "", bounce = false } = params;
     let recipientAddress;
     try {
-      recipientAddress = Address16.parse(toAddress);
+      recipientAddress = Address19.parse(toAddress2);
     } catch (e) {
-      console.error(`Invalid recipient address: ${toAddress}`, e);
+      console.error(`Invalid recipient address: ${toAddress2}`, e);
       return null;
     }
     const walletData = loadWallet();
@@ -17829,14 +19789,14 @@ async function sendTon(params) {
       messages: [
         internal11({
           to: recipientAddress,
-          value: toNano15(amount),
+          value: toNano27(amount),
           body: comment,
           bounce
         })
       ]
     });
     const pseudoHash = `${seqno}_${Date.now()}_${amount.toFixed(2)}`;
-    console.log(`\u{1F4B8} [TON] Sent ${amount} TON to ${toAddress.slice(0, 8)}... - seqno: ${seqno}`);
+    console.log(`\u{1F4B8} [TON] Sent ${amount} TON to ${toAddress2.slice(0, 8)}... - seqno: ${seqno}`);
     return pseudoHash;
   } catch (error) {
     console.error("Error sending TON:", error);