teleton 0.1.8 → 0.1.11

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

@@ -3548,10 +3548,10 @@ async function generateWallet() {
     workchain: 0,
     publicKey: keyPair.publicKey
   });
-  const address = wallet.address.toString({ bounceable: true, testOnly: false });
+  const address4 = wallet.address.toString({ bounceable: true, testOnly: false });
   return {
     version: "w5r1",
-    address,
+    address: address4,
     publicKey: keyPair.publicKey.toString("hex"),
     mnemonic,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -3590,10 +3590,10 @@ async function importWallet(mnemonic) {
     workchain: 0,
     publicKey: keyPair.publicKey
   });
-  const address = wallet.address.toString({ bounceable: true, testOnly: false });
+  const address4 = wallet.address.toString({ bounceable: true, testOnly: false });
   return {
     version: "w5r1",
-    address,
+    address: address4,
     publicKey: keyPair.publicKey.toString("hex"),
     mnemonic,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -3603,12 +3603,12 @@ function getWalletAddress() {
   const wallet = loadWallet();
   return wallet?.address || null;
 }
-async function getWalletBalance(address) {
+async function getWalletBalance(address4) {
   try {
     const endpoint = await getHttpEndpoint({ network: "mainnet" });
     const client = new TonClient({ endpoint });
-    const { Address: Address17 } = await import("@ton/core");
-    const addressObj = Address17.parse(address);
+    const { Address: Address20 } = await import("@ton/core");
+    const addressObj = Address20.parse(address4);
     const balance = await client.getBalance(addressObj);
     const balanceFormatted = fromNano(balance);
     return {
@@ -3953,12 +3953,12 @@ Usage:
    * /wallet - Check TON wallet balance
    */
   async handleWalletCommand() {
-    const address = getWalletAddress();
-    if (!address) return "\u274C No wallet configured.";
-    const result = await getWalletBalance(address);
+    const address4 = getWalletAddress();
+    if (!address4) return "\u274C No wallet configured.";
+    const result = await getWalletBalance(address4);
     if (!result) return "\u274C Failed to fetch balance.";
     return `\u{1F48E} **${result.balance} TON**
-\u{1F4CD} \`${address}\``;
+\u{1F4CD} \`${address4}\``;
   }
   /**
    * /help - Show available commands
@@ -4183,8 +4183,8 @@ var MarketScraperService = class {
    * Currently not implemented
    * Would require modifications to support single-collection mode
    */
-  async scrapeSingleCollection(address) {
-    console.log(`\u{1F504} Single collection scrape not yet implemented for ${address}`);
+  async scrapeSingleCollection(address4) {
+    console.log(`\u{1F504} Single collection scrape not yet implemented for ${address4}`);
     return {
       success: false,
       error: "Single collection scrape not yet implemented"
@@ -10571,8 +10571,8 @@ var tonGetAddressTool = {
 };
 var tonGetAddressExecutor = async (params, context) => {
   try {
-    const address = getWalletAddress();
-    if (!address) {
+    const address4 = getWalletAddress();
+    if (!address4) {
       return {
         success: false,
         error: "Wallet not initialized. Contact admin to generate wallet."
@@ -10581,8 +10581,8 @@ var tonGetAddressExecutor = async (params, context) => {
     return {
       success: true,
       data: {
-        address,
-        message: `Your TON wallet address: ${address}`
+        address: address4,
+        message: `Your TON wallet address: ${address4}`
       }
     };
   } catch (error) {
@@ -10604,14 +10604,14 @@ var tonGetBalanceTool = {
 };
 var tonGetBalanceExecutor = async (params, context) => {
   try {
-    const address = getWalletAddress();
-    if (!address) {
+    const address4 = getWalletAddress();
+    if (!address4) {
       return {
         success: false,
         error: "Wallet not initialized. Contact admin to generate wallet."
       };
     }
-    const balance = await getWalletBalance(address);
+    const balance = await getWalletBalance(address4);
     if (!balance) {
       return {
         success: false,
@@ -10621,7 +10621,7 @@ var tonGetBalanceExecutor = async (params, context) => {
     return {
       success: true,
       data: {
-        address,
+        address: address4,
         balance: balance.balance,
         balanceNano: balance.balanceNano,
         message: `Your wallet balance: ${balance.balance} TON`,
@@ -10825,14 +10825,14 @@ function parseMessageBody(body) {
 }
 var tonGetTransactionsExecutor = async (params, context) => {
   try {
-    const { address, limit = 10 } = params;
+    const { address: address4, limit = 10 } = params;
     let addressObj;
     try {
-      addressObj = Address2.parse(address);
+      addressObj = Address2.parse(address4);
     } catch (e) {
       return {
         success: false,
-        error: `Invalid address: ${address}`
+        error: `Invalid address: ${address4}`
       };
     }
     const endpoint = await getHttpEndpoint3({ network: "mainnet" });
@@ -10962,7 +10962,7 @@ var tonGetTransactionsExecutor = async (params, context) => {
     return {
       success: true,
       data: {
-        address,
+        address: address4,
         transactions: formatted
       }
     };
@@ -12016,11 +12016,2662 @@ var jettonBalancesExecutor = async (params, context) => {
 // src/agent/tools/jetton/swap.ts
 import { Type as Type81 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey7 } from "@ton/crypto";
-import { WalletContractV5R1 as WalletContractV5R17, TonClient as TonClient9, toNano as toNano6, internal as internal6 } from "@ton/ton";
+import { WalletContractV5R1 as WalletContractV5R17, TonClient as TonClient9, toNano as toNano18, internal as internal6 } from "@ton/ton";
 import { SendMode as SendMode6 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint9 } from "@orbs-network/ton-access";
-import { DEX, pTON } from "@ston-fi/sdk";
-import { StonApiClient } from "@ston-fi/api";
+
+// 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
 var NATIVE_TON_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 var jettonSwapTool = {
   name: "jetton_swap",
@@ -12057,27 +14708,27 @@ var jettonSwapExecutor = async (params, context) => {
     }
     const isTonInput = from_asset.toLowerCase() === "ton";
     const fromAddress = isTonInput ? NATIVE_TON_ADDRESS : from_asset;
-    const toAddress = to_asset;
+    const toAddress2 = to_asset;
     if (!isTonInput && !fromAddress.match(/^[EUe][Qq][A-Za-z0-9_-]{46}$/)) {
       return {
         success: false,
         error: `Invalid from_asset address: ${from_asset}`
       };
     }
-    if (!toAddress.match(/^[EUe][Qq][A-Za-z0-9_-]{46}$/)) {
+    if (!toAddress2.match(/^[EUe][Qq][A-Za-z0-9_-]{46}$/)) {
       return {
         success: false,
-        error: `Invalid to_asset address: ${toAddress}`
+        error: `Invalid to_asset address: ${toAddress2}`
       };
     }
     const endpoint = await getHttpEndpoint9({ network: "mainnet" });
     const tonClient = new TonClient9({ endpoint });
     const stonApiClient = new StonApiClient();
-    console.log(`Simulating swap: ${amount} ${fromAddress} \u2192 ${toAddress}`);
+    console.log(`Simulating swap: ${amount} ${fromAddress} \u2192 ${toAddress2}`);
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
-      askAddress: toAddress,
-      offerUnits: toNano6(amount).toString(),
+      askAddress: toAddress2,
+      offerUnits: toNano18(amount).toString(),
       slippageTolerance: slippage.toString()
     });
     if (!simulationResult || !simulationResult.router) {
@@ -12087,7 +14738,7 @@ var jettonSwapExecutor = async (params, context) => {
       };
     }
     const { router: routerInfo } = simulationResult;
-    const router = tonClient.open(new DEX.v1.Router(routerInfo.address));
+    const router = tonClient.open(new DEX4.v1.Router(routerInfo.address));
     const keyPair = await mnemonicToPrivateKey7(walletData.mnemonic);
     const wallet = WalletContractV5R17.create({
       workchain: 0,
@@ -12101,7 +14752,7 @@ var jettonSwapExecutor = async (params, context) => {
       txParams = await router.getSwapTonToJettonTxParams({
         userWalletAddress: walletData.address,
         proxyTon,
-        askJettonAddress: toAddress,
+        askJettonAddress: toAddress2,
         offerAmount: BigInt(simulationResult.offerUnits),
         minAskAmount: BigInt(simulationResult.minAskUnits)
       });
@@ -12109,7 +14760,7 @@ var jettonSwapExecutor = async (params, context) => {
       txParams = await router.getSwapJettonToJettonTxParams({
         userWalletAddress: walletData.address,
         offerJettonAddress: fromAddress,
-        askJettonAddress: toAddress,
+        askJettonAddress: toAddress2,
         offerAmount: BigInt(simulationResult.offerUnits),
         minAskAmount: BigInt(simulationResult.minAskUnits)
       });
@@ -12132,7 +14783,7 @@ var jettonSwapExecutor = async (params, context) => {
       success: true,
       data: {
         from: fromAddress,
-        to: toAddress,
+        to: toAddress2,
         amountIn: amount.toString(),
         expectedOutput: expectedOutput.toFixed(6),
         minOutput: (Number(simulationResult.minAskUnits) / 10 ** 9).toFixed(6),
@@ -12157,8 +14808,8 @@ var jettonSwapExecutor = async (params, context) => {
 // src/agent/tools/jetton/send.ts
 import { Type as Type82 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey8 } from "@ton/crypto";
-import { WalletContractV5R1 as WalletContractV5R18, TonClient as TonClient10, toNano as toNano7, internal as internal7 } from "@ton/ton";
-import { Address as Address8, SendMode as SendMode7, beginCell as beginCell4 } from "@ton/core";
+import { WalletContractV5R1 as WalletContractV5R18, TonClient as TonClient10, toNano as toNano19, internal as internal7 } from "@ton/ton";
+import { Address as Address11, SendMode as SendMode7, beginCell as beginCell15 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint10 } from "@orbs-network/ton-access";
 var JETTON_TRANSFER_OP = 260734629;
 var jettonSendTool = {
@@ -12193,7 +14844,7 @@ var jettonSendExecutor = async (params, context) => {
       };
     }
     try {
-      Address8.parse(to);
+      Address11.parse(to);
     } catch {
       return {
         success: false,
@@ -12214,7 +14865,7 @@ var jettonSendExecutor = async (params, context) => {
     }
     const jettonsData = await jettonsResponse.json();
     const jettonBalance = jettonsData.balances?.find(
-      (b) => b.jetton.address.toLowerCase() === jetton_address.toLowerCase() || Address8.parse(b.jetton.address).toString() === Address8.parse(jetton_address).toString()
+      (b) => b.jetton.address.toLowerCase() === jetton_address.toLowerCase() || Address11.parse(b.jetton.address).toString() === Address11.parse(jetton_address).toString()
     );
     if (!jettonBalance) {
       return {
@@ -12234,11 +14885,11 @@ var jettonSendExecutor = async (params, context) => {
         error: `Insufficient ${symbol} balance. You have ${balanceHuman.toFixed(4)} but trying to send ${amount}`
       };
     }
-    let forwardPayload = beginCell4().endCell();
+    let forwardPayload = beginCell15().endCell();
     if (comment) {
-      forwardPayload = beginCell4().storeUint(0, 32).storeStringTail(comment).endCell();
+      forwardPayload = beginCell15().storeUint(0, 32).storeStringTail(comment).endCell();
     }
-    const messageBody = beginCell4().storeUint(JETTON_TRANSFER_OP, 32).storeUint(0, 64).storeCoins(amountInUnits).storeAddress(Address8.parse(to)).storeAddress(Address8.parse(walletData.address)).storeBit(false).storeCoins(comment ? toNano7("0.01") : BigInt(1)).storeBit(comment ? true : false).storeMaybeRef(comment ? forwardPayload : null).endCell();
+    const messageBody = beginCell15().storeUint(JETTON_TRANSFER_OP, 32).storeUint(0, 64).storeCoins(amountInUnits).storeAddress(Address11.parse(to)).storeAddress(Address11.parse(walletData.address)).storeBit(false).storeCoins(comment ? toNano19("0.01") : BigInt(1)).storeBit(comment ? true : false).storeMaybeRef(comment ? forwardPayload : null).endCell();
     const keyPair = await mnemonicToPrivateKey8(walletData.mnemonic);
     const wallet = WalletContractV5R18.create({
       workchain: 0,
@@ -12254,8 +14905,8 @@ var jettonSendExecutor = async (params, context) => {
       sendMode: SendMode7.PAY_GAS_SEPARATELY + SendMode7.IGNORE_ERRORS,
       messages: [
         internal7({
-          to: Address8.parse(senderJettonWallet),
-          value: toNano7("0.05"),
+          to: Address11.parse(senderJettonWallet),
+          value: toNano19("0.05"),
           // Gas for jetton transfer
           body: messageBody,
           bounce: true
@@ -12607,8 +15258,7 @@ var jettonSearchExecutor = async (params, context) => {
 
 // src/agent/tools/jetton/quote.ts
 import { Type as Type86 } from "@sinclair/typebox";
-import { toNano as toNano8 } from "@ton/ton";
-import { StonApiClient as StonApiClient2 } from "@ston-fi/api";
+import { toNano as toNano20 } from "@ton/ton";
 var NATIVE_TON_ADDRESS2 = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 var jettonQuoteTool = {
   name: "jetton_quote",
@@ -12638,12 +15288,12 @@ var jettonQuoteExecutor = async (params, context) => {
     const { from_asset, to_asset, amount, slippage = 0.01 } = params;
     const isTonInput = from_asset.toLowerCase() === "ton";
     const fromAddress = isTonInput ? NATIVE_TON_ADDRESS2 : from_asset;
-    const toAddress = to_asset;
-    const stonApiClient = new StonApiClient2();
+    const toAddress2 = to_asset;
+    const stonApiClient = new StonApiClient();
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
-      askAddress: toAddress,
-      offerUnits: toNano8(amount).toString(),
+      askAddress: toAddress2,
+      offerUnits: toNano20(amount).toString(),
       slippageTolerance: slippage.toString()
     });
     if (!simulationResult) {
@@ -12667,7 +15317,7 @@ var jettonQuoteExecutor = async (params, context) => {
     const quote = {
       from: fromAddress,
       fromSymbol,
-      to: toAddress,
+      to: toAddress2,
       toSymbol,
       amountIn: amount.toString(),
       expectedOutput: expectedOutput.toFixed(6),
@@ -13124,8 +15774,8 @@ var jettonPoolsExecutor = async (params, context) => {
 
 // src/agent/tools/dedust/quote.ts
 import { Type as Type91 } from "@sinclair/typebox";
-import { TonClient as TonClient11, toNano as toNano9, fromNano as fromNano4 } from "@ton/ton";
-import { Address as Address9 } from "@ton/core";
+import { TonClient as TonClient11, toNano as toNano21, fromNano as fromNano4 } from "@ton/ton";
+import { Address as Address12 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint11 } from "@orbs-network/ton-access";
 import { Factory, Asset, PoolType, ReadinessStatus } from "@dedust/sdk";
 
@@ -13182,7 +15832,7 @@ var dedustQuoteExecutor = async (params, context) => {
     let toAssetAddr = to_asset;
     if (!isTonInput) {
       try {
-        fromAssetAddr = Address9.parse(from_asset).toString();
+        fromAssetAddr = Address12.parse(from_asset).toString();
       } catch (error) {
         return {
           success: false,
@@ -13192,7 +15842,7 @@ var dedustQuoteExecutor = async (params, context) => {
     }
     if (!isTonOutput) {
       try {
-        toAssetAddr = Address9.parse(to_asset).toString();
+        toAssetAddr = Address12.parse(to_asset).toString();
       } catch (error) {
         return {
           success: false,
@@ -13203,10 +15853,10 @@ var dedustQuoteExecutor = async (params, context) => {
     const endpoint = await getHttpEndpoint11({ network: "mainnet" });
     const tonClient = new TonClient11({ endpoint });
     const factory = tonClient.open(
-      Factory.createFromAddress(Address9.parse(DEDUST_FACTORY_MAINNET))
+      Factory.createFromAddress(Address12.parse(DEDUST_FACTORY_MAINNET))
     );
-    const fromAsset = isTonInput ? Asset.native() : Asset.jetton(Address9.parse(fromAssetAddr));
-    const toAsset = isTonOutput ? Asset.native() : Asset.jetton(Address9.parse(toAssetAddr));
+    const fromAsset = isTonInput ? Asset.native() : Asset.jetton(Address12.parse(fromAssetAddr));
+    const toAsset = isTonOutput ? Asset.native() : Asset.jetton(Address12.parse(toAssetAddr));
     const poolTypeEnum = pool_type === "stable" ? PoolType.STABLE : PoolType.VOLATILE;
     const pool = tonClient.open(await factory.getPool(poolTypeEnum, [fromAsset, toAsset]));
     const readinessStatus = await pool.getReadinessStatus();
@@ -13217,7 +15867,7 @@ var dedustQuoteExecutor = async (params, context) => {
       };
     }
     const reserves = await pool.getReserves();
-    const amountIn = toNano9(amount);
+    const amountIn = toNano21(amount);
     const { amountOut, tradeFee } = await pool.getEstimatedSwapOut({
       assetIn: fromAsset,
       amountIn
@@ -13282,8 +15932,8 @@ var dedustQuoteExecutor = async (params, context) => {
 // src/agent/tools/dedust/swap.ts
 import { Type as Type92 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey9 } from "@ton/crypto";
-import { WalletContractV5R1 as WalletContractV5R19, TonClient as TonClient12, toNano as toNano10, fromNano as fromNano5 } from "@ton/ton";
-import { Address as Address10 } from "@ton/core";
+import { WalletContractV5R1 as WalletContractV5R19, TonClient as TonClient12, toNano as toNano22, fromNano as fromNano5 } from "@ton/ton";
+import { Address as Address13 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint12 } from "@orbs-network/ton-access";
 import { Factory as Factory2, Asset as Asset2, PoolType as PoolType2, ReadinessStatus as ReadinessStatus2, JettonRoot, VaultJetton } from "@dedust/sdk";
 var dedustSwapTool = {
@@ -13330,7 +15980,7 @@ var dedustSwapExecutor = async (params, context) => {
     let toAssetAddr = to_asset;
     if (!isTonInput) {
       try {
-        fromAssetAddr = Address10.parse(from_asset).toString();
+        fromAssetAddr = Address13.parse(from_asset).toString();
       } catch (error) {
         return {
           success: false,
@@ -13340,7 +15990,7 @@ var dedustSwapExecutor = async (params, context) => {
     }
     if (!isTonOutput) {
       try {
-        toAssetAddr = Address10.parse(to_asset).toString();
+        toAssetAddr = Address13.parse(to_asset).toString();
       } catch (error) {
         return {
           success: false,
@@ -13351,10 +16001,10 @@ var dedustSwapExecutor = async (params, context) => {
     const endpoint = await getHttpEndpoint12({ network: "mainnet" });
     const tonClient = new TonClient12({ endpoint });
     const factory = tonClient.open(
-      Factory2.createFromAddress(Address10.parse(DEDUST_FACTORY_MAINNET))
+      Factory2.createFromAddress(Address13.parse(DEDUST_FACTORY_MAINNET))
     );
-    const fromAssetObj = isTonInput ? Asset2.native() : Asset2.jetton(Address10.parse(fromAssetAddr));
-    const toAssetObj = isTonOutput ? Asset2.native() : Asset2.jetton(Address10.parse(toAssetAddr));
+    const fromAssetObj = isTonInput ? Asset2.native() : Asset2.jetton(Address13.parse(fromAssetAddr));
+    const toAssetObj = isTonOutput ? Asset2.native() : Asset2.jetton(Address13.parse(toAssetAddr));
     const poolTypeEnum = pool_type === "stable" ? PoolType2.STABLE : PoolType2.VOLATILE;
     const pool = tonClient.open(await factory.getPool(poolTypeEnum, [fromAssetObj, toAssetObj]));
     const readinessStatus = await pool.getReadinessStatus();
@@ -13364,7 +16014,7 @@ var dedustSwapExecutor = async (params, context) => {
         error: `Pool not ready. Status: ${readinessStatus}. Try the other pool type (${pool_type === "volatile" ? "stable" : "volatile"}) or check if the pool exists.`
       };
     }
-    const amountIn = toNano10(amount);
+    const amountIn = toNano22(amount);
     const { amountOut, tradeFee } = await pool.getEstimatedSwapOut({
       assetIn: fromAssetObj,
       amountIn
@@ -13390,10 +16040,10 @@ var dedustSwapExecutor = async (params, context) => {
         poolAddress: pool.address,
         amount: amountIn,
         limit: minAmountOut,
-        gasAmount: toNano10(DEDUST_GAS.SWAP_TON_TO_JETTON)
+        gasAmount: toNano22(DEDUST_GAS.SWAP_TON_TO_JETTON)
       });
     } else {
-      const jettonAddress = Address10.parse(fromAssetAddr);
+      const jettonAddress = Address13.parse(fromAssetAddr);
       const jettonVault = tonClient.open(await factory.getJettonVault(jettonAddress));
       const vaultStatus = await jettonVault.getReadinessStatus();
       if (vaultStatus !== ReadinessStatus2.READY) {
@@ -13404,17 +16054,17 @@ var dedustSwapExecutor = async (params, context) => {
       }
       const jettonRoot = tonClient.open(JettonRoot.createFromAddress(jettonAddress));
       const jettonWallet = tonClient.open(
-        await jettonRoot.getWallet(Address10.parse(walletData.address))
+        await jettonRoot.getWallet(Address13.parse(walletData.address))
       );
       const swapPayload = VaultJetton.createSwapPayload({
         poolAddress: pool.address,
         limit: minAmountOut
       });
-      await jettonWallet.sendTransfer(sender, toNano10(DEDUST_GAS.SWAP_JETTON_TO_ANY), {
+      await jettonWallet.sendTransfer(sender, toNano22(DEDUST_GAS.SWAP_JETTON_TO_ANY), {
         destination: jettonVault.address,
         amount: amountIn,
-        responseAddress: Address10.parse(walletData.address),
-        forwardAmount: toNano10(DEDUST_GAS.FORWARD_GAS),
+        responseAddress: Address13.parse(walletData.address),
+        forwardAmount: toNano22(DEDUST_GAS.FORWARD_GAS),
         forwardPayload: swapPayload
       });
     }
@@ -13578,10 +16228,9 @@ var dedustPoolsExecutor = async (params, context) => {
 
 // src/agent/tools/dex/smart-quote.ts
 import { Type as Type94 } from "@sinclair/typebox";
-import { TonClient as TonClient13, toNano as toNano11, fromNano as fromNano6 } from "@ton/ton";
-import { Address as Address11 } from "@ton/core";
+import { TonClient as TonClient13, toNano as toNano23, fromNano as fromNano6 } from "@ton/ton";
+import { Address as Address14 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint13 } from "@orbs-network/ton-access";
-import { 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",
@@ -13611,12 +16260,12 @@ async function getStonfiQuote(fromAsset, toAsset, amount, slippage) {
     const isTonInput = fromAsset.toLowerCase() === "ton";
     const isTonOutput = toAsset.toLowerCase() === "ton";
     const fromAddress = isTonInput ? NATIVE_TON_ADDRESS3 : fromAsset;
-    const toAddress = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
-    const stonApiClient = new StonApiClient3();
+    const toAddress2 = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
+    const stonApiClient = new StonApiClient();
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
-      askAddress: toAddress,
-      offerUnits: toNano11(amount).toString(),
+      askAddress: toAddress2,
+      offerUnits: toNano23(amount).toString(),
       slippageTolerance: slippage.toString()
     });
     if (!simulationResult) {
@@ -13661,10 +16310,10 @@ async function getDedustQuote(fromAsset, toAsset, amount, slippage, tonClient) {
     const isTonInput = fromAsset.toLowerCase() === "ton";
     const isTonOutput = toAsset.toLowerCase() === "ton";
     const factory = tonClient.open(
-      Factory3.createFromAddress(Address11.parse(DEDUST_FACTORY_MAINNET))
+      Factory3.createFromAddress(Address14.parse(DEDUST_FACTORY_MAINNET))
     );
-    const fromAssetObj = isTonInput ? Asset3.native() : Asset3.jetton(Address11.parse(fromAsset));
-    const toAssetObj = isTonOutput ? Asset3.native() : Asset3.jetton(Address11.parse(toAsset));
+    const fromAssetObj = isTonInput ? Asset3.native() : Asset3.jetton(Address14.parse(fromAsset));
+    const toAssetObj = isTonOutput ? Asset3.native() : Asset3.jetton(Address14.parse(toAsset));
     let pool;
     let poolType = "volatile";
     try {
@@ -13695,7 +16344,7 @@ async function getDedustQuote(fromAsset, toAsset, amount, slippage, tonClient) {
         error: "Pool lookup failed"
       };
     }
-    const amountIn = toNano11(amount);
+    const amountIn = toNano23(amount);
     const { amountOut, tradeFee } = await pool.getEstimatedSwapOut({
       assetIn: fromAssetObj,
       amountIn
@@ -13838,11 +16487,9 @@ Use dex_swap to execute on the best DEX, or jetton_swap/dedust_swap for specific
 // src/agent/tools/dex/smart-swap.ts
 import { Type as Type95 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey10 } from "@ton/crypto";
-import { WalletContractV5R1 as WalletContractV5R110, TonClient as TonClient14, toNano as toNano12, fromNano as fromNano7 } from "@ton/ton";
-import { Address as Address12, SendMode as SendMode8, internal as internal8 } from "@ton/core";
+import { WalletContractV5R1 as WalletContractV5R110, TonClient as TonClient14, toNano as toNano24, fromNano as fromNano7 } from "@ton/ton";
+import { Address as Address15, SendMode as SendMode8, internal as internal8 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint14 } from "@orbs-network/ton-access";
-import { 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",
@@ -13877,12 +16524,12 @@ async function getStonfiQuote2(fromAsset, toAsset, amount, slippage) {
     const isTonInput = fromAsset.toLowerCase() === "ton";
     const isTonOutput = toAsset.toLowerCase() === "ton";
     const fromAddress = isTonInput ? NATIVE_TON_ADDRESS3 : fromAsset;
-    const toAddress = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
-    const stonApiClient = new StonApiClient4();
+    const toAddress2 = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
+    const stonApiClient = new StonApiClient();
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
-      askAddress: toAddress,
-      offerUnits: toNano12(amount).toString(),
+      askAddress: toAddress2,
+      offerUnits: toNano24(amount).toString(),
       slippageTolerance: slippage.toString()
     });
     if (!simulationResult) {
@@ -13909,10 +16556,10 @@ async function getDedustQuote2(fromAsset, toAsset, amount, slippage, tonClient)
     const isTonInput = fromAsset.toLowerCase() === "ton";
     const isTonOutput = toAsset.toLowerCase() === "ton";
     const factory = tonClient.open(
-      Factory4.createFromAddress(Address12.parse(DEDUST_FACTORY_MAINNET))
+      Factory4.createFromAddress(Address15.parse(DEDUST_FACTORY_MAINNET))
     );
-    const fromAssetObj = isTonInput ? Asset4.native() : Asset4.jetton(Address12.parse(fromAsset));
-    const toAssetObj = isTonOutput ? Asset4.native() : Asset4.jetton(Address12.parse(toAsset));
+    const fromAssetObj = isTonInput ? Asset4.native() : Asset4.jetton(Address15.parse(fromAsset));
+    const toAssetObj = isTonOutput ? Asset4.native() : Asset4.jetton(Address15.parse(toAsset));
     let pool;
     let poolType = "volatile";
     try {
@@ -13929,7 +16576,7 @@ async function getDedustQuote2(fromAsset, toAsset, amount, slippage, tonClient)
     } catch {
       return { dex: "DeDust", expectedOutput: 0, available: false, error: "Pool lookup failed" };
     }
-    const amountIn = toNano12(amount);
+    const amountIn = toNano24(amount);
     const { amountOut, tradeFee } = await pool.getEstimatedSwapOut({
       assetIn: fromAssetObj,
       amountIn
@@ -13958,7 +16605,7 @@ async function getDedustQuote2(fromAsset, toAsset, amount, slippage, tonClient)
 async function executeStonfiSwap(fromAsset, toAsset, amount, slippage, simulationResult, walletData, tonClient) {
   const isTonInput = fromAsset.toLowerCase() === "ton";
   const isTonOutput = toAsset.toLowerCase() === "ton";
-  const toAddress = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
+  const toAddress2 = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
   const keyPair = await mnemonicToPrivateKey10(walletData.mnemonic);
   const wallet = WalletContractV5R110.create({
     workchain: 0,
@@ -13967,14 +16614,14 @@ async function executeStonfiSwap(fromAsset, toAsset, amount, slippage, simulatio
   const walletContract = tonClient.open(wallet);
   const seqno = await walletContract.getSeqno();
   const { router: routerInfo } = simulationResult;
-  const router = tonClient.open(new DEX2.v1.Router(routerInfo.address));
+  const router = tonClient.open(new DEX4.v1.Router(routerInfo.address));
   let txParams;
   if (isTonInput) {
-    const proxyTon = new pTON2.v1(routerInfo.ptonMasterAddress);
+    const proxyTon = new pTON.v1(routerInfo.ptonMasterAddress);
     txParams = await router.getSwapTonToJettonTxParams({
       userWalletAddress: walletData.address,
       proxyTon,
-      askJettonAddress: toAddress,
+      askJettonAddress: toAddress2,
       offerAmount: BigInt(simulationResult.offerUnits),
       minAskAmount: BigInt(simulationResult.minAskUnits)
     });
@@ -13982,7 +16629,7 @@ async function executeStonfiSwap(fromAsset, toAsset, amount, slippage, simulatio
     txParams = await router.getSwapJettonToJettonTxParams({
       userWalletAddress: walletData.address,
       offerJettonAddress: fromAsset,
-      askJettonAddress: toAddress,
+      askJettonAddress: toAddress2,
       offerAmount: BigInt(simulationResult.offerUnits),
       minAskAmount: BigInt(simulationResult.minAskUnits)
     });
@@ -14013,32 +16660,32 @@ async function executeDedustSwap(fromAsset, toAsset, amount, pool, minAmountOut,
   });
   const walletContract = tonClient.open(wallet);
   const sender = walletContract.sender(keyPair.secretKey);
-  const factory = tonClient.open(Factory4.createFromAddress(Address12.parse(DEDUST_FACTORY_MAINNET)));
-  const amountIn = toNano12(amount);
+  const factory = tonClient.open(Factory4.createFromAddress(Address15.parse(DEDUST_FACTORY_MAINNET)));
+  const amountIn = toNano24(amount);
   if (isTonInput) {
     const tonVault = tonClient.open(await factory.getNativeVault());
     await tonVault.sendSwap(sender, {
       poolAddress: pool.address,
       amount: amountIn,
       limit: minAmountOut,
-      gasAmount: toNano12(DEDUST_GAS.SWAP_TON_TO_JETTON)
+      gasAmount: toNano24(DEDUST_GAS.SWAP_TON_TO_JETTON)
     });
   } else {
-    const jettonAddress = Address12.parse(fromAsset);
+    const jettonAddress = Address15.parse(fromAsset);
     const jettonVault = tonClient.open(await factory.getJettonVault(jettonAddress));
     const jettonRoot = tonClient.open(JettonRoot2.createFromAddress(jettonAddress));
     const jettonWallet = tonClient.open(
-      await jettonRoot.getWallet(Address12.parse(walletData.address))
+      await jettonRoot.getWallet(Address15.parse(walletData.address))
     );
     const swapPayload = VaultJetton2.createSwapPayload({
       poolAddress: pool.address,
       limit: minAmountOut
     });
-    await jettonWallet.sendTransfer(sender, toNano12(DEDUST_GAS.SWAP_JETTON_TO_ANY), {
+    await jettonWallet.sendTransfer(sender, toNano24(DEDUST_GAS.SWAP_JETTON_TO_ANY), {
       destination: jettonVault.address,
       amount: amountIn,
-      responseAddress: Address12.parse(walletData.address),
-      forwardAmount: toNano12(DEDUST_GAS.FORWARD_GAS),
+      responseAddress: Address15.parse(walletData.address),
+      forwardAmount: toNano24(DEDUST_GAS.FORWARD_GAS),
       forwardPayload: swapPayload
     });
   }
@@ -15443,14 +18090,14 @@ Example: "Send 2 TON to EQxxx with memo: john_doe"`,
 };
 var casinoBalanceExecutor = async (params, context) => {
   try {
-    const address = getWalletAddress();
-    if (!address) {
+    const address4 = getWalletAddress();
+    if (!address4) {
       return {
         success: false,
         error: "Casino wallet not initialized. Contact admin."
       };
     }
-    const balanceInfo = await getWalletBalance(address);
+    const balanceInfo = await getWalletBalance(address4);
     if (!balanceInfo) {
       return {
         success: false,
@@ -15481,7 +18128,7 @@ var casinoBalanceExecutor = async (params, context) => {
     return {
       success: true,
       data: {
-        address,
+        address: address4,
         balance: balance.toFixed(2),
         balanceNano: balanceInfo.balanceNano,
         status,
@@ -15512,7 +18159,7 @@ import { Api as Api53 } from "telegram";
 
 // src/casino/payment-verifier.ts
 import { TonClient as TonClient15, fromNano as fromNano8 } from "@ton/ton";
-import { Address as Address13 } from "@ton/core";
+import { Address as Address16 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint15 } from "@orbs-network/ton-access";
 
 // src/casino/retry.ts
@@ -15589,7 +18236,7 @@ async function verifyPayment(db, params) {
     const { botWalletAddress, betAmount, requestTime, gameType, userId } = params;
     const endpoint = await getHttpEndpoint15({ network: "mainnet" });
     const client = new TonClient15({ endpoint });
-    const botAddress = Address13.parse(botWalletAddress);
+    const botAddress = Address16.parse(botWalletAddress);
     const transactions = await withBlockchainRetry(
       () => client.getTransactions(botAddress, { limit: 20 }),
       "getTransactions"
@@ -15746,13 +18393,13 @@ function shouldAwardDailyJackpot(db) {
 
 // src/casino/payout-sender.ts
 import { mnemonicToPrivateKey as mnemonicToPrivateKey11 } from "@ton/crypto";
-import { WalletContractV5R1 as WalletContractV5R111, TonClient as TonClient16, toNano as toNano13, internal as internal9 } from "@ton/ton";
-import { Address as Address14, SendMode as SendMode9 } from "@ton/core";
+import { WalletContractV5R1 as WalletContractV5R111, TonClient as TonClient16, toNano as toNano25, internal as internal9 } from "@ton/ton";
+import { Address as Address17, SendMode as SendMode9 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint16 } from "@orbs-network/ton-access";
 async function sendPayout(playerAddress, amount, message) {
   try {
     try {
-      Address14.parse(playerAddress);
+      Address17.parse(playerAddress);
     } catch (e) {
       return {
         success: false,
@@ -15782,8 +18429,8 @@ async function sendPayout(playerAddress, amount, message) {
         sendMode: SendMode9.PAY_GAS_SEPARATELY,
         messages: [
           internal9({
-            to: Address14.parse(playerAddress),
-            value: toNano13(amount),
+            to: Address17.parse(playerAddress),
+            value: toNano25(amount),
             body: message,
             bounce: false
           })
@@ -16178,8 +18825,8 @@ var casinoDiceExecutor = async (params, context) => {
 // src/agent/tools/casino/payout.ts
 import { Type as Type108 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey12 } from "@ton/crypto";
-import { WalletContractV5R1 as WalletContractV5R112, TonClient as TonClient17, toNano as toNano14, internal as internal10 } from "@ton/ton";
-import { Address as Address15, SendMode as SendMode10 } from "@ton/core";
+import { WalletContractV5R1 as WalletContractV5R112, TonClient as TonClient17, toNano as toNano26, internal as internal10 } from "@ton/ton";
+import { Address as Address18, SendMode as SendMode10 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint17 } from "@orbs-network/ton-access";
 var casinoPayoutTool = {
   name: "casino_payout",
@@ -16276,7 +18923,7 @@ var casinoPayoutExecutor = async (params, context) => {
     }
     const payout = bet_amount * multiplier;
     try {
-      Address15.parse(player_address);
+      Address18.parse(player_address);
     } catch (e) {
       return {
         success: false,
@@ -16306,8 +18953,8 @@ var casinoPayoutExecutor = async (params, context) => {
       sendMode: SendMode10.PAY_GAS_SEPARATELY + SendMode10.IGNORE_ERRORS,
       messages: [
         internal10({
-          to: Address15.parse(player_address),
-          value: toNano14(payout),
+          to: Address18.parse(player_address),
+          value: toNano26(payout),
           body: `${winType} You won ${payout} TON (${multiplier}x)`,
           bounce: false
         })
@@ -17108,17 +19755,17 @@ var GiftDetector = class {
 
 // src/ton/transfer.ts
 import { mnemonicToPrivateKey as mnemonicToPrivateKey13 } from "@ton/crypto";
-import { WalletContractV5R1 as WalletContractV5R113, TonClient as TonClient18, toNano as toNano15, internal as internal11 } from "@ton/ton";
-import { Address as Address16, SendMode as SendMode11 } from "@ton/core";
+import { WalletContractV5R1 as WalletContractV5R113, TonClient as TonClient18, toNano as toNano27, internal as internal11 } from "@ton/ton";
+import { Address as Address19, SendMode as SendMode11 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint18 } from "@orbs-network/ton-access";
 async function sendTon(params) {
   try {
-    const { toAddress, amount, comment = "", bounce = false } = params;
+    const { toAddress: toAddress2, amount, comment = "", bounce = false } = params;
     let recipientAddress;
     try {
-      recipientAddress = Address16.parse(toAddress);
+      recipientAddress = Address19.parse(toAddress2);
     } catch (e) {
-      console.error(`Invalid recipient address: ${toAddress}`, e);
+      console.error(`Invalid recipient address: ${toAddress2}`, e);
       return null;
     }
     const walletData = loadWallet();
@@ -17142,14 +19789,14 @@ async function sendTon(params) {
       messages: [
         internal11({
           to: recipientAddress,
-          value: toNano15(amount),
+          value: toNano27(amount),
           body: comment,
           bounce
         })
       ]
     });
     const pseudoHash = `${seqno}_${Date.now()}_${amount.toFixed(2)}`;
-    console.log(`\u{1F4B8} [TON] Sent ${amount} TON to ${toAddress.slice(0, 8)}... - seqno: ${seqno}`);
+    console.log(`\u{1F4B8} [TON] Sent ${amount} TON to ${toAddress2.slice(0, 8)}... - seqno: ${seqno}`);
     return pseudoHash;
   } catch (error) {
     console.error("Error sending TON:", error);