teleton 0.1.11 → 0.1.13

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

@@ -3548,10 +3548,10 @@ async function generateWallet() {
     workchain: 0,
     publicKey: keyPair.publicKey
   });
-  const address4 = wallet.address.toString({ bounceable: true, testOnly: false });
+  const address = wallet.address.toString({ bounceable: true, testOnly: false });
   return {
     version: "w5r1",
-    address: address4,
+    address,
     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 address4 = wallet.address.toString({ bounceable: true, testOnly: false });
+  const address = wallet.address.toString({ bounceable: true, testOnly: false });
   return {
     version: "w5r1",
-    address: address4,
+    address,
     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(address4) {
+async function getWalletBalance(address) {
   try {
     const endpoint = await getHttpEndpoint({ network: "mainnet" });
     const client = new TonClient({ endpoint });
-    const { Address: Address20 } = await import("@ton/core");
-    const addressObj = Address20.parse(address4);
+    const { Address: Address17 } = await import("@ton/core");
+    const addressObj = Address17.parse(address);
     const balance = await client.getBalance(addressObj);
     const balanceFormatted = fromNano(balance);
     return {
@@ -3953,12 +3953,12 @@ Usage:
    * /wallet - Check TON wallet balance
    */
   async handleWalletCommand() {
-    const address4 = getWalletAddress();
-    if (!address4) return "\u274C No wallet configured.";
-    const result = await getWalletBalance(address4);
+    const address = getWalletAddress();
+    if (!address) return "\u274C No wallet configured.";
+    const result = await getWalletBalance(address);
     if (!result) return "\u274C Failed to fetch balance.";
     return `\u{1F48E} **${result.balance} TON**
-\u{1F4CD} \`${address4}\``;
+\u{1F4CD} \`${address}\``;
   }
   /**
    * /help - Show available commands
@@ -4183,8 +4183,8 @@ var MarketScraperService = class {
    * Currently not implemented
    * Would require modifications to support single-collection mode
    */
-  async scrapeSingleCollection(address4) {
-    console.log(`\u{1F504} Single collection scrape not yet implemented for ${address4}`);
+  async scrapeSingleCollection(address) {
+    console.log(`\u{1F504} Single collection scrape not yet implemented for ${address}`);
     return {
       success: false,
       error: "Single collection scrape not yet implemented"
@@ -10571,8 +10571,8 @@ var tonGetAddressTool = {
 };
 var tonGetAddressExecutor = async (params, context) => {
   try {
-    const address4 = getWalletAddress();
-    if (!address4) {
+    const address = getWalletAddress();
+    if (!address) {
       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: address4,
-        message: `Your TON wallet address: ${address4}`
+        address,
+        message: `Your TON wallet address: ${address}`
       }
     };
   } catch (error) {
@@ -10604,14 +10604,14 @@ var tonGetBalanceTool = {
 };
 var tonGetBalanceExecutor = async (params, context) => {
   try {
-    const address4 = getWalletAddress();
-    if (!address4) {
+    const address = getWalletAddress();
+    if (!address) {
       return {
         success: false,
         error: "Wallet not initialized. Contact admin to generate wallet."
       };
     }
-    const balance = await getWalletBalance(address4);
+    const balance = await getWalletBalance(address);
     if (!balance) {
       return {
         success: false,
@@ -10621,7 +10621,7 @@ var tonGetBalanceExecutor = async (params, context) => {
     return {
       success: true,
       data: {
-        address: address4,
+        address,
         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: address4, limit = 10 } = params;
+    const { address, limit = 10 } = params;
     let addressObj;
     try {
-      addressObj = Address2.parse(address4);
+      addressObj = Address2.parse(address);
     } catch (e) {
       return {
         success: false,
-        error: `Invalid address: ${address4}`
+        error: `Invalid address: ${address}`
       };
     }
     const endpoint = await getHttpEndpoint3({ network: "mainnet" });
@@ -10962,7 +10962,7 @@ var tonGetTransactionsExecutor = async (params, context) => {
     return {
       success: true,
       data: {
-        address: address4,
+        address,
         transactions: formatted
       }
     };
@@ -12016,2662 +12016,11 @@ 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 toNano18, internal as internal6 } from "@ton/ton";
+import { WalletContractV5R1 as WalletContractV5R17, TonClient as TonClient9, toNano as toNano6, internal as internal6 } from "@ton/ton";
 import { SendMode as SendMode6 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint9 } from "@orbs-network/ton-access";
-
-// 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";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-      key = keys[i];
-      if (!__hasOwnProp.call(to, key) && key !== except) {
-        __defProp(to, key, {
-          get: ((k) => from[k]).bind(null, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-      }
-    }
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-  value: mod,
-  enumerable: true
-}) : target, mod));
-var normalizeDate = (date) => {
-  return date.toISOString().split(".")[0];
-};
-var require_map_obj = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-  const isObject2 = (value) => typeof value === "object" && value !== null;
-  const mapObjectSkip2 = /* @__PURE__ */ Symbol("skip");
-  const isObjectCustom2 = (value) => isObject2(value) && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
-  const mapObject2 = (object, mapper, options, isSeen = /* @__PURE__ */ new WeakMap()) => {
-    options = {
-      deep: false,
-      target: {},
-      ...options
-    };
-    if (isSeen.has(object)) return isSeen.get(object);
-    isSeen.set(object, options.target);
-    const { target } = options;
-    delete options.target;
-    const mapArray = (array) => array.map((element) => isObjectCustom2(element) ? mapObject2(element, mapper, options, isSeen) : element);
-    if (Array.isArray(object)) return mapArray(object);
-    for (const [key, value] of Object.entries(object)) {
-      const mapResult = mapper(key, value, object);
-      if (mapResult === mapObjectSkip2) continue;
-      let [newKey, newValue, { shouldRecurse = true } = {}] = mapResult;
-      if (newKey === "__proto__") continue;
-      if (options.deep && shouldRecurse && isObjectCustom2(newValue)) newValue = Array.isArray(newValue) ? mapArray(newValue) : mapObject2(newValue, mapper, options, isSeen);
-      target[newKey] = newValue;
-    }
-    return target;
-  };
-  module.exports = (object, mapper, options) => {
-    if (!isObject2(object)) throw new TypeError(`Expected an object, got \`${object}\` (${typeof object})`);
-    return mapObject2(object, mapper, options);
-  };
-  module.exports.mapObjectSkip = mapObjectSkip2;
-}));
-var import_map_obj = /* @__PURE__ */ __toESM(require_map_obj(), 1);
-var QuickLRU = class extends Map {
-  constructor(options = {}) {
-    super();
-    if (!(options.maxSize && options.maxSize > 0)) throw new TypeError("`maxSize` must be a number greater than 0");
-    if (typeof options.maxAge === "number" && options.maxAge === 0) throw new TypeError("`maxAge` must be a number greater than 0");
-    this.maxSize = options.maxSize;
-    this.maxAge = options.maxAge || Number.POSITIVE_INFINITY;
-    this.onEviction = options.onEviction;
-    this.cache = /* @__PURE__ */ new Map();
-    this.oldCache = /* @__PURE__ */ new Map();
-    this._size = 0;
-  }
-  _emitEvictions(cache$2) {
-    if (typeof this.onEviction !== "function") return;
-    for (const [key, item] of cache$2) this.onEviction(key, item.value);
-  }
-  _deleteIfExpired(key, item) {
-    if (typeof item.expiry === "number" && item.expiry <= Date.now()) {
-      if (typeof this.onEviction === "function") this.onEviction(key, item.value);
-      return this.delete(key);
-    }
-    return false;
-  }
-  _getOrDeleteIfExpired(key, item) {
-    if (this._deleteIfExpired(key, item) === false) return item.value;
-  }
-  _getItemValue(key, item) {
-    return item.expiry ? this._getOrDeleteIfExpired(key, item) : item.value;
-  }
-  _peek(key, cache$2) {
-    const item = cache$2.get(key);
-    return this._getItemValue(key, item);
-  }
-  _set(key, value) {
-    this.cache.set(key, value);
-    this._size++;
-    if (this._size >= this.maxSize) {
-      this._size = 0;
-      this._emitEvictions(this.oldCache);
-      this.oldCache = this.cache;
-      this.cache = /* @__PURE__ */ new Map();
-    }
-  }
-  _moveToRecent(key, item) {
-    this.oldCache.delete(key);
-    this._set(key, item);
-  }
-  *_entriesAscending() {
-    for (const item of this.oldCache) {
-      const [key, value] = item;
-      if (!this.cache.has(key)) {
-        if (this._deleteIfExpired(key, value) === false) yield item;
-      }
-    }
-    for (const item of this.cache) {
-      const [key, value] = item;
-      if (this._deleteIfExpired(key, value) === false) yield item;
-    }
-  }
-  get(key) {
-    if (this.cache.has(key)) {
-      const item = this.cache.get(key);
-      return this._getItemValue(key, item);
-    }
-    if (this.oldCache.has(key)) {
-      const item = this.oldCache.get(key);
-      if (this._deleteIfExpired(key, item) === false) {
-        this._moveToRecent(key, item);
-        return item.value;
-      }
-    }
-  }
-  set(key, value, { maxAge = this.maxAge } = {}) {
-    const expiry = typeof maxAge === "number" && maxAge !== Number.POSITIVE_INFINITY ? Date.now() + maxAge : void 0;
-    if (this.cache.has(key)) this.cache.set(key, {
-      value,
-      expiry
-    });
-    else this._set(key, {
-      value,
-      expiry
-    });
-    return this;
-  }
-  has(key) {
-    if (this.cache.has(key)) return !this._deleteIfExpired(key, this.cache.get(key));
-    if (this.oldCache.has(key)) return !this._deleteIfExpired(key, this.oldCache.get(key));
-    return false;
-  }
-  peek(key) {
-    if (this.cache.has(key)) return this._peek(key, this.cache);
-    if (this.oldCache.has(key)) return this._peek(key, this.oldCache);
-  }
-  delete(key) {
-    const deleted = this.cache.delete(key);
-    if (deleted) this._size--;
-    return this.oldCache.delete(key) || deleted;
-  }
-  clear() {
-    this.cache.clear();
-    this.oldCache.clear();
-    this._size = 0;
-  }
-  resize(newSize) {
-    if (!(newSize && newSize > 0)) throw new TypeError("`maxSize` must be a number greater than 0");
-    const items = [...this._entriesAscending()];
-    const removeCount = items.length - newSize;
-    if (removeCount < 0) {
-      this.cache = new Map(items);
-      this.oldCache = /* @__PURE__ */ new Map();
-      this._size = items.length;
-    } else {
-      if (removeCount > 0) this._emitEvictions(items.slice(0, removeCount));
-      this.oldCache = new Map(items.slice(removeCount));
-      this.cache = /* @__PURE__ */ new Map();
-      this._size = 0;
-    }
-    this.maxSize = newSize;
-  }
-  *keys() {
-    for (const [key] of this) yield key;
-  }
-  *values() {
-    for (const [, value] of this) yield value;
-  }
-  *[Symbol.iterator]() {
-    for (const item of this.cache) {
-      const [key, value] = item;
-      if (this._deleteIfExpired(key, value) === false) yield [key, value.value];
-    }
-    for (const item of this.oldCache) {
-      const [key, value] = item;
-      if (!this.cache.has(key)) {
-        if (this._deleteIfExpired(key, value) === false) yield [key, value.value];
-      }
-    }
-  }
-  *entriesDescending() {
-    let items = [...this.cache];
-    for (let i = items.length - 1; i >= 0; --i) {
-      const [key, value] = items[i];
-      if (this._deleteIfExpired(key, value) === false) yield [key, value.value];
-    }
-    items = [...this.oldCache];
-    for (let i = items.length - 1; i >= 0; --i) {
-      const [key, value] = items[i];
-      if (!this.cache.has(key)) {
-        if (this._deleteIfExpired(key, value) === false) yield [key, value.value];
-      }
-    }
-  }
-  *entriesAscending() {
-    for (const [key, value] of this._entriesAscending()) yield [key, value.value];
-  }
-  get size() {
-    if (!this._size) return this.oldCache.size;
-    let oldCacheSize = 0;
-    for (const key of this.oldCache.keys()) if (!this.cache.has(key)) oldCacheSize++;
-    return Math.min(this._size + oldCacheSize, this.maxSize);
-  }
-  entries() {
-    return this.entriesAscending();
-  }
-  forEach(callbackFunction, thisArgument = this) {
-    for (const [key, value] of this.entriesAscending()) callbackFunction.call(thisArgument, value, key, this);
-  }
-  get [Symbol.toStringTag]() {
-    return JSON.stringify([...this.entriesAscending()]);
-  }
-};
-var handlePreserveConsecutiveUppercase = (decamelized, separator) => {
-  decamelized = decamelized.replace(/((?<![\p{Uppercase_Letter}\d])[\p{Uppercase_Letter}\d](?![\p{Uppercase_Letter}\d]))/gu, ($0) => $0.toLowerCase());
-  return decamelized.replace(new RegExp("(?<!\\p{Uppercase_Letter})(\\p{Uppercase_Letter}+)(\\p{Uppercase_Letter}\\p{Lowercase_Letter}+)", "gu"), (_, $1, $2) => $1 + separator + $2.toLowerCase());
-};
-function decamelize(text, { separator = "_", preserveConsecutiveUppercase: preserveConsecutiveUppercase$1 = false } = {}) {
-  if (!(typeof text === "string" && typeof separator === "string")) throw new TypeError("The `text` and `separator` arguments should be of type `string`");
-  if (text.length < 2) return preserveConsecutiveUppercase$1 ? text : text.toLowerCase();
-  const replacement = `$1${separator}$2`;
-  const decamelized = text.replace(new RegExp("([\\p{Lowercase_Letter}\\d])(\\p{Uppercase_Letter})", "gu"), replacement);
-  if (preserveConsecutiveUppercase$1) return handlePreserveConsecutiveUppercase(decamelized, separator);
-  return decamelized.replace(new RegExp("(\\p{Uppercase_Letter})(\\p{Uppercase_Letter}\\p{Lowercase_Letter}+)", "gu"), replacement).toLowerCase();
-}
-var has$1 = (array, key) => array.some((element) => {
-  if (typeof element === "string") return element === key;
-  element.lastIndex = 0;
-  return element.test(key);
-});
-var cache$1 = new QuickLRU({ maxSize: 1e5 });
-var isObject$2 = (value) => typeof value === "object" && value !== null && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
-var transform$1 = (input, options = {}) => {
-  if (!isObject$2(input)) return input;
-  const { separator = "_", exclude, deep = false } = options;
-  const makeMapper = (parentPath) => (key, value) => {
-    if (deep && isObject$2(value)) {
-      const path = parentPath === void 0 ? key : `${parentPath}.${key}`;
-      value = (0, import_map_obj.default)(value, makeMapper(path));
-    }
-    if (!(exclude && has$1(exclude, key))) {
-      const cacheKey = `${separator}${key}`;
-      if (cache$1.has(cacheKey)) key = cache$1.get(cacheKey);
-      else {
-        const returnValue = decamelize(key, { separator });
-        if (key.length < 100) cache$1.set(cacheKey, returnValue);
-        key = returnValue;
-      }
-    }
-    return [key, value];
-  };
-  return (0, import_map_obj.default)(input, makeMapper(void 0));
-};
-function decamelizeKeys$1(input, options) {
-  if (Array.isArray(input)) return Object.keys(input).map((key) => transform$1(input[key], options));
-  return transform$1(input, options);
-}
-function decamelizeKeys(val) {
-  return decamelizeKeys$1(val, { deep: true });
-}
-function toUrlSafe(str) {
-  let safeStr = str;
-  while (safeStr.indexOf("/") >= 0) safeStr = safeStr.replace("/", "_");
-  while (safeStr.indexOf("+") >= 0) safeStr = safeStr.replace("+", "-");
-  while (safeStr.indexOf("=") >= 0) safeStr = safeStr.replace("=", "");
-  return safeStr;
-}
-function normalizeRequest(path, options) {
-  const pathWithParams = path.replace(/{([a-zA-Z0-9_]+)}/g, (_, key) => {
-    const value = options?.query?.[key];
-    if (!value) throw new Error(`Missing value for path parameter "${key}"`);
-    delete options?.query?.[key];
-    return toUrlSafe(value);
-  });
-  if (options?.query) {
-    for (const key in options.query) {
-      const value = options.query[key];
-      if (typeof value === "string") options.query[key] = toUrlSafe(value);
-    }
-    options.query = decamelizeKeys(options.query);
-  }
-  if (options?.body && typeof options.body === "object") options.body = decamelizeKeys(options.body);
-  return [pathWithParams, options];
-}
-var isObject$1 = (value) => typeof value === "object" && value !== null;
-var isObjectCustom = (value) => isObject$1(value) && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
-var mapObjectSkip = /* @__PURE__ */ Symbol("mapObjectSkip");
-var _mapObject = (object, mapper, options, isSeen = /* @__PURE__ */ new WeakMap()) => {
-  options = {
-    deep: false,
-    target: {},
-    ...options
-  };
-  if (isSeen.has(object)) return isSeen.get(object);
-  isSeen.set(object, options.target);
-  const { target } = options;
-  delete options.target;
-  const mapArray = (array) => array.map((element) => isObjectCustom(element) ? _mapObject(element, mapper, options, isSeen) : element);
-  if (Array.isArray(object)) return mapArray(object);
-  for (const [key, value] of Object.entries(object)) {
-    const mapResult = mapper(key, value, object);
-    if (mapResult === mapObjectSkip) continue;
-    let [newKey, newValue, { shouldRecurse = true } = {}] = mapResult;
-    if (newKey === "__proto__") continue;
-    if (options.deep && shouldRecurse && isObjectCustom(newValue)) newValue = Array.isArray(newValue) ? mapArray(newValue) : _mapObject(newValue, mapper, options, isSeen);
-    target[newKey] = newValue;
-  }
-  return target;
-};
-function mapObject(object, mapper, options) {
-  if (!isObject$1(object)) throw new TypeError(`Expected an object, got \`${object}\` (${typeof object})`);
-  return _mapObject(object, mapper, options);
-}
-var UPPERCASE = /[\p{Lu}]/u;
-var LOWERCASE = /[\p{Ll}]/u;
-var LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu;
-var IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
-var SEPARATORS = /[_.\- ]+/;
-var LEADING_SEPARATORS = /* @__PURE__ */ new RegExp("^" + SEPARATORS.source);
-var SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, "gu");
-var NUMBERS_AND_IDENTIFIER = new RegExp("\\d+" + IDENTIFIER.source, "gu");
-var preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutiveUppercase$1) => {
-  let isLastCharLower = false;
-  let isLastCharUpper = false;
-  let isLastLastCharUpper = false;
-  let isLastLastCharPreserved = false;
-  for (let index = 0; index < string.length; index++) {
-    const character = string[index];
-    isLastLastCharPreserved = index > 2 ? string[index - 3] === "-" : true;
-    if (isLastCharLower && UPPERCASE.test(character)) {
-      string = string.slice(0, index) + "-" + string.slice(index);
-      isLastCharLower = false;
-      isLastLastCharUpper = isLastCharUpper;
-      isLastCharUpper = true;
-      index++;
-    } else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character) && (!isLastLastCharPreserved || preserveConsecutiveUppercase$1)) {
-      string = string.slice(0, index - 1) + "-" + string.slice(index - 1);
-      isLastLastCharUpper = isLastCharUpper;
-      isLastCharUpper = false;
-      isLastCharLower = true;
-    } else {
-      isLastCharLower = toLowerCase(character) === character && toUpperCase(character) !== character;
-      isLastLastCharUpper = isLastCharUpper;
-      isLastCharUpper = toUpperCase(character) === character && toLowerCase(character) !== character;
-    }
-  }
-  return string;
-};
-var preserveConsecutiveUppercase = (input, toLowerCase) => {
-  LEADING_CAPITAL.lastIndex = 0;
-  return input.replaceAll(LEADING_CAPITAL, (match) => toLowerCase(match));
-};
-var postProcess = (input, toUpperCase) => {
-  SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
-  NUMBERS_AND_IDENTIFIER.lastIndex = 0;
-  return input.replaceAll(NUMBERS_AND_IDENTIFIER, (match, pattern, offset) => ["_", "-"].includes(input.charAt(offset + match.length)) ? match : toUpperCase(match)).replaceAll(SEPARATORS_AND_IDENTIFIER, (_, identifier) => toUpperCase(identifier));
-};
-function camelCase(input, options) {
-  if (!(typeof input === "string" || Array.isArray(input))) throw new TypeError("Expected the input to be `string | string[]`");
-  options = {
-    pascalCase: false,
-    preserveConsecutiveUppercase: false,
-    ...options
-  };
-  if (Array.isArray(input)) input = input.map((x) => x.trim()).filter((x) => x.length).join("-");
-  else input = input.trim();
-  if (input.length === 0) return "";
-  const toLowerCase = options.locale === false ? (string) => string.toLowerCase() : (string) => string.toLocaleLowerCase(options.locale);
-  const toUpperCase = options.locale === false ? (string) => string.toUpperCase() : (string) => string.toLocaleUpperCase(options.locale);
-  if (input.length === 1) {
-    if (SEPARATORS.test(input)) return "";
-    return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
-  }
-  if (input !== toLowerCase(input)) input = preserveCamelCase(input, toLowerCase, toUpperCase, options.preserveConsecutiveUppercase);
-  input = input.replace(LEADING_SEPARATORS, "");
-  input = options.preserveConsecutiveUppercase ? preserveConsecutiveUppercase(input, toLowerCase) : toLowerCase(input);
-  if (options.pascalCase) input = toUpperCase(input.charAt(0)) + input.slice(1);
-  return postProcess(input, toUpperCase);
-}
-var has = (array, key) => array.some((element) => {
-  if (typeof element === "string") return element === key;
-  element.lastIndex = 0;
-  return element.test(key);
-});
-var cache = new QuickLRU({ maxSize: 1e5 });
-var isObject = (value) => typeof value === "object" && value !== null && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
-var transform = (input, options = {}) => {
-  if (!isObject(input)) return input;
-  const { exclude, pascalCase = false, stopPaths, deep = false, preserveConsecutiveUppercase: preserveConsecutiveUppercase$1 = false } = options;
-  const stopPathsSet = new Set(stopPaths);
-  const makeMapper = (parentPath) => (key, value) => {
-    if (deep && isObject(value)) {
-      const path = parentPath === void 0 ? key : `${parentPath}.${key}`;
-      if (!stopPathsSet.has(path)) value = mapObject(value, makeMapper(path));
-    }
-    if (!(exclude && has(exclude, key))) {
-      const cacheKey = pascalCase ? `${key}_` : key;
-      if (cache.has(cacheKey)) key = cache.get(cacheKey);
-      else {
-        const returnValue = camelCase(key, {
-          pascalCase,
-          locale: false,
-          preserveConsecutiveUppercase: preserveConsecutiveUppercase$1
-        });
-        if (key.length < 100) cache.set(cacheKey, returnValue);
-        key = returnValue;
-      }
-    }
-    return [key, value];
-  };
-  return mapObject(input, makeMapper(void 0));
-};
-function camelcaseKeys$1(input, options) {
-  if (Array.isArray(input)) return Object.keys(input).map((key) => transform(input[key], options));
-  return transform(input, options);
-}
-function camelcaseKeys(val) {
-  return camelcaseKeys$1(val, { deep: true });
-}
-function denullifyValues(obj) {
-  const newObj = {};
-  for (const k in obj) {
-    const v = obj[k];
-    newObj[k] = v === null ? void 0 : v && typeof v === "object" && v.__proto__.constructor === Object ? denullifyValues(v) : v;
-  }
-  return newObj;
-}
-function normalizeResponse(response) {
-  return denullifyValues(camelcaseKeys(response));
-}
-var StonApiClient = class {
-  constructor(options) {
-    this.apiFetch = ofetch.create({ baseURL: options?.baseURL ?? options?.baseUrl ?? "https://api.ston.fi" });
-  }
-  async getAsset(assetAddress) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/assets/{assetAddress}", {
-      method: "GET",
-      query: { assetAddress }
-    }))).asset;
-  }
-  async getAssets() {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/assets", { method: "GET" }))).assetList;
-  }
-  async queryAssets(body) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/assets/query", {
-      method: "POST",
-      body
-    }))).assetList;
-  }
-  /**
-  * @deprecated use `queryAssets` method with `searchTerms` parameter instead
-  */
-  async searchAssets(query) {
-    return this.queryAssets({
-      ...query,
-      searchTerms: [query.searchString]
-    });
-  }
-  async getFarm(farmAddress) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/farms/{farmAddress}", {
-      method: "GET",
-      query: { farmAddress }
-    }))).farm;
-  }
-  async getFarms(query) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/farms", {
-      method: "GET",
-      query
-    }))).farmList;
-  }
-  async getFarmsByPool(poolAddress) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/farms_by_pool/{poolAddress}", {
-      method: "GET",
-      query: { poolAddress }
-    }))).farmList;
-  }
-  async getSwapPairs(query) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/markets", {
-      method: "GET",
-      query
-    }))).pairs;
-  }
-  async getSwapStatus(query) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/swap/status", {
-      method: "GET",
-      query
-    })));
-  }
-  async getPool(data) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/pools/{poolAddress}", {
-      method: "GET",
-      query: typeof data === "string" ? { poolAddress: data } : data
-    }))).pool;
-  }
-  async getPools(query) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/pools", {
-      method: "GET",
-      query
-    }))).poolList;
-  }
-  async getPoolsByAssetPair(query) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/pools/by_market/{asset0Address}/{asset1Address}", {
-      method: "GET",
-      query
-    }))).poolList;
-  }
-  async queryPools({ searchTerms: searchTerm, unconditionalAssets: unconditionalAsset, ...query }) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/pools/query", {
-      method: "POST",
-      query: {
-        ...query,
-        searchTerm,
-        unconditionalAsset
-      }
-    }))).poolList;
-  }
-  async queryTransactions(query) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/transactions/query", {
-      method: "GET",
-      query: {
-        ...query,
-        minTxTimestamp: query.minTxTimestamp ? normalizeDate(query.minTxTimestamp) : void 0
-      }
-    })));
-  }
-  async simulateSwap({ offerUnits: units, ...query }) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/swap/simulate", {
-      method: "POST",
-      query: {
-        ...query,
-        units
-      }
-    })));
-  }
-  async simulateReverseSwap({ askUnits: units, ...query }) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/reverse_swap/simulate", {
-      method: "POST",
-      query: {
-        ...query,
-        units
-      }
-    })));
-  }
-  async simulateLiquidityProvision(query) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/liquidity_provision/simulate", {
-      method: "POST",
-      query
-    })));
-  }
-  async getJettonWalletAddress(query) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/jetton/{jettonAddress}/address", {
-      method: "GET",
-      query
-    }))).address;
-  }
-  async getWalletAsset(query) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/assets/{assetAddress}", {
-      method: "GET",
-      query
-    }))).asset;
-  }
-  async getWalletAssets(walletAddress) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/assets", {
-      method: "GET",
-      query: { walletAddress }
-    }))).assetList;
-  }
-  async getWalletFarm(query) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/farms/{farmAddress}", {
-      method: "GET",
-      query
-    }))).farm;
-  }
-  async getWalletFarms(data) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/farms", {
-      method: "GET",
-      query: typeof data === "string" ? { walletAddress: data } : data
-    }))).farmList;
-  }
-  async getWalletPool(query) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/pools/{poolAddress}", {
-      method: "GET",
-      query
-    }))).pool;
-  }
-  async getWalletPools(data) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/pools", {
-      method: "GET",
-      query: typeof data === "string" ? { walletAddress: data } : data
-    }))).poolList;
-  }
-  async getWalletStakes(query) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/stakes", {
-      method: "GET",
-      query
-    })));
-  }
-  async getWalletVaultsFee(query) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/fee_vaults", {
-      method: "GET",
-      query
-    }))).vaultList;
-  }
-  async getWalletOperations({ since, until, ...query }) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/operations", {
-      method: "GET",
-      query: {
-        ...query,
-        since: normalizeDate(since),
-        until: normalizeDate(until)
-      }
-    }))).operations;
-  }
-  async getOperations({ since, until }) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/stats/operations", {
-      method: "GET",
-      query: {
-        since: normalizeDate(since),
-        until: normalizeDate(until)
-      }
-    }))).operations;
-  }
-  async getAssetsFeeStats({ since, until, referrerAddress }) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/stats/fees", {
-      method: "GET",
-      query: {
-        since: normalizeDate(since),
-        until: normalizeDate(until),
-        referrerAddress
-      }
-    })));
-  }
-  async getWithdrawalsFeeStats({ since, until, referrerAddress }) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/stats/fee_withdrawals", {
-      method: "GET",
-      query: {
-        since: normalizeDate(since),
-        until: normalizeDate(until),
-        referrerAddress
-      }
-    }))).withdrawals;
-  }
-  async getAccrualsFeeStats({ since, until, referrerAddress }) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/stats/fee_accruals", {
-      method: "GET",
-      query: {
-        since: normalizeDate(since),
-        until: normalizeDate(until),
-        referrerAddress
-      }
-    }))).operations;
-  }
-  async getStakingStats() {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/stats/staking", { method: "GET" })));
-  }
-  async getRouters(query) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/routers", {
-      method: "GET",
-      query
-    }))).routerList;
-  }
-  async getRouter(routerAddress) {
-    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/routers/{routerAddress}", {
-      method: "GET",
-      query: { routerAddress }
-    }))).router;
-  }
-};
-
-// src/agent/tools/jetton/swap.ts
+import { DEX, pTON } from "@ston-fi/sdk";
+import { StonApiClient } from "@ston-fi/api";
 var NATIVE_TON_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 var jettonSwapTool = {
   name: "jetton_swap",
@@ -14708,27 +12057,27 @@ var jettonSwapExecutor = async (params, context) => {
     }
     const isTonInput = from_asset.toLowerCase() === "ton";
     const fromAddress = isTonInput ? NATIVE_TON_ADDRESS : from_asset;
-    const toAddress2 = to_asset;
+    const toAddress = to_asset;
     if (!isTonInput && !fromAddress.match(/^[EUe][Qq][A-Za-z0-9_-]{46}$/)) {
       return {
         success: false,
         error: `Invalid from_asset address: ${from_asset}`
       };
     }
-    if (!toAddress2.match(/^[EUe][Qq][A-Za-z0-9_-]{46}$/)) {
+    if (!toAddress.match(/^[EUe][Qq][A-Za-z0-9_-]{46}$/)) {
       return {
         success: false,
-        error: `Invalid to_asset address: ${toAddress2}`
+        error: `Invalid to_asset address: ${toAddress}`
       };
     }
     const endpoint = await getHttpEndpoint9({ network: "mainnet" });
     const tonClient = new TonClient9({ endpoint });
     const stonApiClient = new StonApiClient();
-    console.log(`Simulating swap: ${amount} ${fromAddress} \u2192 ${toAddress2}`);
+    console.log(`Simulating swap: ${amount} ${fromAddress} \u2192 ${toAddress}`);
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
-      askAddress: toAddress2,
-      offerUnits: toNano18(amount).toString(),
+      askAddress: toAddress,
+      offerUnits: toNano6(amount).toString(),
       slippageTolerance: slippage.toString()
     });
     if (!simulationResult || !simulationResult.router) {
@@ -14738,7 +12087,7 @@ var jettonSwapExecutor = async (params, context) => {
       };
     }
     const { router: routerInfo } = simulationResult;
-    const router = tonClient.open(new DEX4.v1.Router(routerInfo.address));
+    const router = tonClient.open(new DEX.v1.Router(routerInfo.address));
     const keyPair = await mnemonicToPrivateKey7(walletData.mnemonic);
     const wallet = WalletContractV5R17.create({
       workchain: 0,
@@ -14752,7 +12101,7 @@ var jettonSwapExecutor = async (params, context) => {
       txParams = await router.getSwapTonToJettonTxParams({
         userWalletAddress: walletData.address,
         proxyTon,
-        askJettonAddress: toAddress2,
+        askJettonAddress: toAddress,
         offerAmount: BigInt(simulationResult.offerUnits),
         minAskAmount: BigInt(simulationResult.minAskUnits)
       });
@@ -14760,7 +12109,7 @@ var jettonSwapExecutor = async (params, context) => {
       txParams = await router.getSwapJettonToJettonTxParams({
         userWalletAddress: walletData.address,
         offerJettonAddress: fromAddress,
-        askJettonAddress: toAddress2,
+        askJettonAddress: toAddress,
         offerAmount: BigInt(simulationResult.offerUnits),
         minAskAmount: BigInt(simulationResult.minAskUnits)
       });
@@ -14783,7 +12132,7 @@ var jettonSwapExecutor = async (params, context) => {
       success: true,
       data: {
         from: fromAddress,
-        to: toAddress2,
+        to: toAddress,
         amountIn: amount.toString(),
         expectedOutput: expectedOutput.toFixed(6),
         minOutput: (Number(simulationResult.minAskUnits) / 10 ** 9).toFixed(6),
@@ -14808,8 +12157,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 toNano19, internal as internal7 } from "@ton/ton";
-import { Address as Address11, SendMode as SendMode7, beginCell as beginCell15 } from "@ton/core";
+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 { getHttpEndpoint as getHttpEndpoint10 } from "@orbs-network/ton-access";
 var JETTON_TRANSFER_OP = 260734629;
 var jettonSendTool = {
@@ -14844,7 +12193,7 @@ var jettonSendExecutor = async (params, context) => {
       };
     }
     try {
-      Address11.parse(to);
+      Address8.parse(to);
     } catch {
       return {
         success: false,
@@ -14865,7 +12214,7 @@ var jettonSendExecutor = async (params, context) => {
     }
     const jettonsData = await jettonsResponse.json();
     const jettonBalance = jettonsData.balances?.find(
-      (b) => b.jetton.address.toLowerCase() === jetton_address.toLowerCase() || Address11.parse(b.jetton.address).toString() === Address11.parse(jetton_address).toString()
+      (b) => b.jetton.address.toLowerCase() === jetton_address.toLowerCase() || Address8.parse(b.jetton.address).toString() === Address8.parse(jetton_address).toString()
     );
     if (!jettonBalance) {
       return {
@@ -14885,11 +12234,11 @@ var jettonSendExecutor = async (params, context) => {
         error: `Insufficient ${symbol} balance. You have ${balanceHuman.toFixed(4)} but trying to send ${amount}`
       };
     }
-    let forwardPayload = beginCell15().endCell();
+    let forwardPayload = beginCell4().endCell();
     if (comment) {
-      forwardPayload = beginCell15().storeUint(0, 32).storeStringTail(comment).endCell();
+      forwardPayload = beginCell4().storeUint(0, 32).storeStringTail(comment).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 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 keyPair = await mnemonicToPrivateKey8(walletData.mnemonic);
     const wallet = WalletContractV5R18.create({
       workchain: 0,
@@ -14905,8 +12254,8 @@ var jettonSendExecutor = async (params, context) => {
       sendMode: SendMode7.PAY_GAS_SEPARATELY + SendMode7.IGNORE_ERRORS,
       messages: [
         internal7({
-          to: Address11.parse(senderJettonWallet),
-          value: toNano19("0.05"),
+          to: Address8.parse(senderJettonWallet),
+          value: toNano7("0.05"),
           // Gas for jetton transfer
           body: messageBody,
           bounce: true
@@ -15258,7 +12607,8 @@ var jettonSearchExecutor = async (params, context) => {
 
 // src/agent/tools/jetton/quote.ts
 import { Type as Type86 } from "@sinclair/typebox";
-import { toNano as toNano20 } from "@ton/ton";
+import { toNano as toNano8 } from "@ton/ton";
+import { StonApiClient as StonApiClient2 } from "@ston-fi/api";
 var NATIVE_TON_ADDRESS2 = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 var jettonQuoteTool = {
   name: "jetton_quote",
@@ -15288,12 +12638,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 toAddress2 = to_asset;
-    const stonApiClient = new StonApiClient();
+    const toAddress = to_asset;
+    const stonApiClient = new StonApiClient2();
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
-      askAddress: toAddress2,
-      offerUnits: toNano20(amount).toString(),
+      askAddress: toAddress,
+      offerUnits: toNano8(amount).toString(),
       slippageTolerance: slippage.toString()
     });
     if (!simulationResult) {
@@ -15317,7 +12667,7 @@ var jettonQuoteExecutor = async (params, context) => {
     const quote = {
       from: fromAddress,
       fromSymbol,
-      to: toAddress2,
+      to: toAddress,
       toSymbol,
       amountIn: amount.toString(),
       expectedOutput: expectedOutput.toFixed(6),
@@ -15774,8 +13124,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 toNano21, fromNano as fromNano4 } from "@ton/ton";
-import { Address as Address12 } from "@ton/core";
+import { TonClient as TonClient11, toNano as toNano9, fromNano as fromNano4 } from "@ton/ton";
+import { Address as Address9 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint11 } from "@orbs-network/ton-access";
 import { Factory, Asset, PoolType, ReadinessStatus } from "@dedust/sdk";
 
@@ -15832,7 +13182,7 @@ var dedustQuoteExecutor = async (params, context) => {
     let toAssetAddr = to_asset;
     if (!isTonInput) {
       try {
-        fromAssetAddr = Address12.parse(from_asset).toString();
+        fromAssetAddr = Address9.parse(from_asset).toString();
       } catch (error) {
         return {
           success: false,
@@ -15842,7 +13192,7 @@ var dedustQuoteExecutor = async (params, context) => {
     }
     if (!isTonOutput) {
       try {
-        toAssetAddr = Address12.parse(to_asset).toString();
+        toAssetAddr = Address9.parse(to_asset).toString();
       } catch (error) {
         return {
           success: false,
@@ -15853,10 +13203,10 @@ var dedustQuoteExecutor = async (params, context) => {
     const endpoint = await getHttpEndpoint11({ network: "mainnet" });
     const tonClient = new TonClient11({ endpoint });
     const factory = tonClient.open(
-      Factory.createFromAddress(Address12.parse(DEDUST_FACTORY_MAINNET))
+      Factory.createFromAddress(Address9.parse(DEDUST_FACTORY_MAINNET))
     );
-    const fromAsset = isTonInput ? Asset.native() : Asset.jetton(Address12.parse(fromAssetAddr));
-    const toAsset = isTonOutput ? Asset.native() : Asset.jetton(Address12.parse(toAssetAddr));
+    const fromAsset = isTonInput ? Asset.native() : Asset.jetton(Address9.parse(fromAssetAddr));
+    const toAsset = isTonOutput ? Asset.native() : Asset.jetton(Address9.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();
@@ -15867,7 +13217,7 @@ var dedustQuoteExecutor = async (params, context) => {
       };
     }
     const reserves = await pool.getReserves();
-    const amountIn = toNano21(amount);
+    const amountIn = toNano9(amount);
     const { amountOut, tradeFee } = await pool.getEstimatedSwapOut({
       assetIn: fromAsset,
       amountIn
@@ -15932,8 +13282,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 toNano22, fromNano as fromNano5 } from "@ton/ton";
-import { Address as Address13 } from "@ton/core";
+import { WalletContractV5R1 as WalletContractV5R19, TonClient as TonClient12, toNano as toNano10, fromNano as fromNano5 } from "@ton/ton";
+import { Address as Address10 } 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 = {
@@ -15980,7 +13330,7 @@ var dedustSwapExecutor = async (params, context) => {
     let toAssetAddr = to_asset;
     if (!isTonInput) {
       try {
-        fromAssetAddr = Address13.parse(from_asset).toString();
+        fromAssetAddr = Address10.parse(from_asset).toString();
       } catch (error) {
         return {
           success: false,
@@ -15990,7 +13340,7 @@ var dedustSwapExecutor = async (params, context) => {
     }
     if (!isTonOutput) {
       try {
-        toAssetAddr = Address13.parse(to_asset).toString();
+        toAssetAddr = Address10.parse(to_asset).toString();
       } catch (error) {
         return {
           success: false,
@@ -16001,10 +13351,10 @@ var dedustSwapExecutor = async (params, context) => {
     const endpoint = await getHttpEndpoint12({ network: "mainnet" });
     const tonClient = new TonClient12({ endpoint });
     const factory = tonClient.open(
-      Factory2.createFromAddress(Address13.parse(DEDUST_FACTORY_MAINNET))
+      Factory2.createFromAddress(Address10.parse(DEDUST_FACTORY_MAINNET))
     );
-    const fromAssetObj = isTonInput ? Asset2.native() : Asset2.jetton(Address13.parse(fromAssetAddr));
-    const toAssetObj = isTonOutput ? Asset2.native() : Asset2.jetton(Address13.parse(toAssetAddr));
+    const fromAssetObj = isTonInput ? Asset2.native() : Asset2.jetton(Address10.parse(fromAssetAddr));
+    const toAssetObj = isTonOutput ? Asset2.native() : Asset2.jetton(Address10.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();
@@ -16014,7 +13364,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 = toNano22(amount);
+    const amountIn = toNano10(amount);
     const { amountOut, tradeFee } = await pool.getEstimatedSwapOut({
       assetIn: fromAssetObj,
       amountIn
@@ -16040,10 +13390,10 @@ var dedustSwapExecutor = async (params, context) => {
         poolAddress: pool.address,
         amount: amountIn,
         limit: minAmountOut,
-        gasAmount: toNano22(DEDUST_GAS.SWAP_TON_TO_JETTON)
+        gasAmount: toNano10(DEDUST_GAS.SWAP_TON_TO_JETTON)
       });
     } else {
-      const jettonAddress = Address13.parse(fromAssetAddr);
+      const jettonAddress = Address10.parse(fromAssetAddr);
       const jettonVault = tonClient.open(await factory.getJettonVault(jettonAddress));
       const vaultStatus = await jettonVault.getReadinessStatus();
       if (vaultStatus !== ReadinessStatus2.READY) {
@@ -16054,17 +13404,17 @@ var dedustSwapExecutor = async (params, context) => {
       }
       const jettonRoot = tonClient.open(JettonRoot.createFromAddress(jettonAddress));
       const jettonWallet = tonClient.open(
-        await jettonRoot.getWallet(Address13.parse(walletData.address))
+        await jettonRoot.getWallet(Address10.parse(walletData.address))
       );
       const swapPayload = VaultJetton.createSwapPayload({
         poolAddress: pool.address,
         limit: minAmountOut
       });
-      await jettonWallet.sendTransfer(sender, toNano22(DEDUST_GAS.SWAP_JETTON_TO_ANY), {
+      await jettonWallet.sendTransfer(sender, toNano10(DEDUST_GAS.SWAP_JETTON_TO_ANY), {
         destination: jettonVault.address,
         amount: amountIn,
-        responseAddress: Address13.parse(walletData.address),
-        forwardAmount: toNano22(DEDUST_GAS.FORWARD_GAS),
+        responseAddress: Address10.parse(walletData.address),
+        forwardAmount: toNano10(DEDUST_GAS.FORWARD_GAS),
         forwardPayload: swapPayload
       });
     }
@@ -16228,9 +13578,10 @@ 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 toNano23, fromNano as fromNano6 } from "@ton/ton";
-import { Address as Address14 } from "@ton/core";
+import { TonClient as TonClient13, toNano as toNano11, fromNano as fromNano6 } from "@ton/ton";
+import { Address as Address11 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint13 } from "@orbs-network/ton-access";
+import { StonApiClient as StonApiClient3 } from "@ston-fi/api";
 import { Factory as Factory3, Asset as Asset3, PoolType as PoolType3, ReadinessStatus as ReadinessStatus3 } from "@dedust/sdk";
 var dexQuoteTool = {
   name: "dex_quote",
@@ -16260,12 +13611,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 toAddress2 = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
-    const stonApiClient = new StonApiClient();
+    const toAddress = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
+    const stonApiClient = new StonApiClient3();
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
-      askAddress: toAddress2,
-      offerUnits: toNano23(amount).toString(),
+      askAddress: toAddress,
+      offerUnits: toNano11(amount).toString(),
       slippageTolerance: slippage.toString()
     });
     if (!simulationResult) {
@@ -16310,10 +13661,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(Address14.parse(DEDUST_FACTORY_MAINNET))
+      Factory3.createFromAddress(Address11.parse(DEDUST_FACTORY_MAINNET))
     );
-    const fromAssetObj = isTonInput ? Asset3.native() : Asset3.jetton(Address14.parse(fromAsset));
-    const toAssetObj = isTonOutput ? Asset3.native() : Asset3.jetton(Address14.parse(toAsset));
+    const fromAssetObj = isTonInput ? Asset3.native() : Asset3.jetton(Address11.parse(fromAsset));
+    const toAssetObj = isTonOutput ? Asset3.native() : Asset3.jetton(Address11.parse(toAsset));
     let pool;
     let poolType = "volatile";
     try {
@@ -16344,7 +13695,7 @@ async function getDedustQuote(fromAsset, toAsset, amount, slippage, tonClient) {
         error: "Pool lookup failed"
       };
     }
-    const amountIn = toNano23(amount);
+    const amountIn = toNano11(amount);
     const { amountOut, tradeFee } = await pool.getEstimatedSwapOut({
       assetIn: fromAssetObj,
       amountIn
@@ -16487,9 +13838,11 @@ 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 toNano24, fromNano as fromNano7 } from "@ton/ton";
-import { Address as Address15, SendMode as SendMode8, internal as internal8 } from "@ton/core";
+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 { getHttpEndpoint as getHttpEndpoint14 } from "@orbs-network/ton-access";
+import { StonApiClient as StonApiClient4 } from "@ston-fi/api";
+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",
@@ -16524,12 +13877,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 toAddress2 = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
-    const stonApiClient = new StonApiClient();
+    const toAddress = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
+    const stonApiClient = new StonApiClient4();
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
-      askAddress: toAddress2,
-      offerUnits: toNano24(amount).toString(),
+      askAddress: toAddress,
+      offerUnits: toNano12(amount).toString(),
       slippageTolerance: slippage.toString()
     });
     if (!simulationResult) {
@@ -16556,10 +13909,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(Address15.parse(DEDUST_FACTORY_MAINNET))
+      Factory4.createFromAddress(Address12.parse(DEDUST_FACTORY_MAINNET))
     );
-    const fromAssetObj = isTonInput ? Asset4.native() : Asset4.jetton(Address15.parse(fromAsset));
-    const toAssetObj = isTonOutput ? Asset4.native() : Asset4.jetton(Address15.parse(toAsset));
+    const fromAssetObj = isTonInput ? Asset4.native() : Asset4.jetton(Address12.parse(fromAsset));
+    const toAssetObj = isTonOutput ? Asset4.native() : Asset4.jetton(Address12.parse(toAsset));
     let pool;
     let poolType = "volatile";
     try {
@@ -16576,7 +13929,7 @@ async function getDedustQuote2(fromAsset, toAsset, amount, slippage, tonClient)
     } catch {
       return { dex: "DeDust", expectedOutput: 0, available: false, error: "Pool lookup failed" };
     }
-    const amountIn = toNano24(amount);
+    const amountIn = toNano12(amount);
     const { amountOut, tradeFee } = await pool.getEstimatedSwapOut({
       assetIn: fromAssetObj,
       amountIn
@@ -16605,7 +13958,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 toAddress2 = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
+  const toAddress = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
   const keyPair = await mnemonicToPrivateKey10(walletData.mnemonic);
   const wallet = WalletContractV5R110.create({
     workchain: 0,
@@ -16614,14 +13967,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 DEX4.v1.Router(routerInfo.address));
+  const router = tonClient.open(new DEX2.v1.Router(routerInfo.address));
   let txParams;
   if (isTonInput) {
-    const proxyTon = new pTON.v1(routerInfo.ptonMasterAddress);
+    const proxyTon = new pTON2.v1(routerInfo.ptonMasterAddress);
     txParams = await router.getSwapTonToJettonTxParams({
       userWalletAddress: walletData.address,
       proxyTon,
-      askJettonAddress: toAddress2,
+      askJettonAddress: toAddress,
       offerAmount: BigInt(simulationResult.offerUnits),
       minAskAmount: BigInt(simulationResult.minAskUnits)
     });
@@ -16629,7 +13982,7 @@ async function executeStonfiSwap(fromAsset, toAsset, amount, slippage, simulatio
     txParams = await router.getSwapJettonToJettonTxParams({
       userWalletAddress: walletData.address,
       offerJettonAddress: fromAsset,
-      askJettonAddress: toAddress2,
+      askJettonAddress: toAddress,
       offerAmount: BigInt(simulationResult.offerUnits),
       minAskAmount: BigInt(simulationResult.minAskUnits)
     });
@@ -16660,32 +14013,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(Address15.parse(DEDUST_FACTORY_MAINNET)));
-  const amountIn = toNano24(amount);
+  const factory = tonClient.open(Factory4.createFromAddress(Address12.parse(DEDUST_FACTORY_MAINNET)));
+  const amountIn = toNano12(amount);
   if (isTonInput) {
     const tonVault = tonClient.open(await factory.getNativeVault());
     await tonVault.sendSwap(sender, {
       poolAddress: pool.address,
       amount: amountIn,
       limit: minAmountOut,
-      gasAmount: toNano24(DEDUST_GAS.SWAP_TON_TO_JETTON)
+      gasAmount: toNano12(DEDUST_GAS.SWAP_TON_TO_JETTON)
     });
   } else {
-    const jettonAddress = Address15.parse(fromAsset);
+    const jettonAddress = Address12.parse(fromAsset);
     const jettonVault = tonClient.open(await factory.getJettonVault(jettonAddress));
     const jettonRoot = tonClient.open(JettonRoot2.createFromAddress(jettonAddress));
     const jettonWallet = tonClient.open(
-      await jettonRoot.getWallet(Address15.parse(walletData.address))
+      await jettonRoot.getWallet(Address12.parse(walletData.address))
     );
     const swapPayload = VaultJetton2.createSwapPayload({
       poolAddress: pool.address,
       limit: minAmountOut
     });
-    await jettonWallet.sendTransfer(sender, toNano24(DEDUST_GAS.SWAP_JETTON_TO_ANY), {
+    await jettonWallet.sendTransfer(sender, toNano12(DEDUST_GAS.SWAP_JETTON_TO_ANY), {
       destination: jettonVault.address,
       amount: amountIn,
-      responseAddress: Address15.parse(walletData.address),
-      forwardAmount: toNano24(DEDUST_GAS.FORWARD_GAS),
+      responseAddress: Address12.parse(walletData.address),
+      forwardAmount: toNano12(DEDUST_GAS.FORWARD_GAS),
       forwardPayload: swapPayload
     });
   }
@@ -18090,14 +15443,14 @@ Example: "Send 2 TON to EQxxx with memo: john_doe"`,
 };
 var casinoBalanceExecutor = async (params, context) => {
   try {
-    const address4 = getWalletAddress();
-    if (!address4) {
+    const address = getWalletAddress();
+    if (!address) {
       return {
         success: false,
         error: "Casino wallet not initialized. Contact admin."
       };
     }
-    const balanceInfo = await getWalletBalance(address4);
+    const balanceInfo = await getWalletBalance(address);
     if (!balanceInfo) {
       return {
         success: false,
@@ -18128,7 +15481,7 @@ var casinoBalanceExecutor = async (params, context) => {
     return {
       success: true,
       data: {
-        address: address4,
+        address,
         balance: balance.toFixed(2),
         balanceNano: balanceInfo.balanceNano,
         status,
@@ -18159,7 +15512,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 Address16 } from "@ton/core";
+import { Address as Address13 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint15 } from "@orbs-network/ton-access";
 
 // src/casino/retry.ts
@@ -18236,7 +15589,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 = Address16.parse(botWalletAddress);
+    const botAddress = Address13.parse(botWalletAddress);
     const transactions = await withBlockchainRetry(
       () => client.getTransactions(botAddress, { limit: 20 }),
       "getTransactions"
@@ -18393,13 +15746,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 toNano25, internal as internal9 } from "@ton/ton";
-import { Address as Address17, SendMode as SendMode9 } from "@ton/core";
+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 { getHttpEndpoint as getHttpEndpoint16 } from "@orbs-network/ton-access";
 async function sendPayout(playerAddress, amount, message) {
   try {
     try {
-      Address17.parse(playerAddress);
+      Address14.parse(playerAddress);
     } catch (e) {
       return {
         success: false,
@@ -18429,8 +15782,8 @@ async function sendPayout(playerAddress, amount, message) {
         sendMode: SendMode9.PAY_GAS_SEPARATELY,
         messages: [
           internal9({
-            to: Address17.parse(playerAddress),
-            value: toNano25(amount),
+            to: Address14.parse(playerAddress),
+            value: toNano13(amount),
             body: message,
             bounce: false
           })
@@ -18825,8 +16178,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 toNano26, internal as internal10 } from "@ton/ton";
-import { Address as Address18, SendMode as SendMode10 } from "@ton/core";
+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 { getHttpEndpoint as getHttpEndpoint17 } from "@orbs-network/ton-access";
 var casinoPayoutTool = {
   name: "casino_payout",
@@ -18923,7 +16276,7 @@ var casinoPayoutExecutor = async (params, context) => {
     }
     const payout = bet_amount * multiplier;
     try {
-      Address18.parse(player_address);
+      Address15.parse(player_address);
     } catch (e) {
       return {
         success: false,
@@ -18953,8 +16306,8 @@ var casinoPayoutExecutor = async (params, context) => {
       sendMode: SendMode10.PAY_GAS_SEPARATELY + SendMode10.IGNORE_ERRORS,
       messages: [
         internal10({
-          to: Address18.parse(player_address),
-          value: toNano26(payout),
+          to: Address15.parse(player_address),
+          value: toNano14(payout),
           body: `${winType} You won ${payout} TON (${multiplier}x)`,
           bounce: false
         })
@@ -19755,17 +17108,17 @@ var GiftDetector = class {
 
 // src/ton/transfer.ts
 import { mnemonicToPrivateKey as mnemonicToPrivateKey13 } from "@ton/crypto";
-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 { 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 { getHttpEndpoint as getHttpEndpoint18 } from "@orbs-network/ton-access";
 async function sendTon(params) {
   try {
-    const { toAddress: toAddress2, amount, comment = "", bounce = false } = params;
+    const { toAddress, amount, comment = "", bounce = false } = params;
     let recipientAddress;
     try {
-      recipientAddress = Address19.parse(toAddress2);
+      recipientAddress = Address16.parse(toAddress);
     } catch (e) {
-      console.error(`Invalid recipient address: ${toAddress2}`, e);
+      console.error(`Invalid recipient address: ${toAddress}`, e);
       return null;
     }
     const walletData = loadWallet();
@@ -19789,14 +17142,14 @@ async function sendTon(params) {
       messages: [
         internal11({
           to: recipientAddress,
-          value: toNano27(amount),
+          value: toNano15(amount),
           body: comment,
           bounce
         })
       ]
     });
     const pseudoHash = `${seqno}_${Date.now()}_${amount.toFixed(2)}`;
-    console.log(`\u{1F4B8} [TON] Sent ${amount} TON to ${toAddress2.slice(0, 8)}... - seqno: ${seqno}`);
+    console.log(`\u{1F4B8} [TON] Sent ${amount} TON to ${toAddress.slice(0, 8)}... - seqno: ${seqno}`);
     return pseudoHash;
   } catch (error) {
     console.error("Error sending TON:", error);