npm install @ston-fi/sdk

yarn add @ston-fi/sdk

pnpm install @ston-fi/sdk

npm install @ston-fi/sdk@latest

yarn add @ston-fi/sdk@latest

pnpm install @ston-fi/sdk@latest

import { TonClient } from "@ton/ton";
import { DEX } from "@ston-fi/sdk";

const client = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

const router = client.open(new DEX.v1.Router());

const pool = client.open(await router.getPool({
  token0: "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO", // STON
  token1: "EQBX6K9aXVl3nXINCyPPL86C4ONVmQ8vK360u6dykFKXpHCa", // GEMSTON
}));

const lpAccount = client.open(await pool.getLpAccount({
  ownerAddress: "", // ! replace with your address
}));

const txParams = await lpAccount.getRefundTxParams({
  queryId: 12345,
});

import { TonClient, toNano } from "@ton/ton";
import { DEX, pTON } from "@ston-fi/sdk";

const client = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

const router = client.open(new DEX.v1.Router());

// swap 1 TON to STON but not less than 1 nano STON
const txParams = await router.getSwapTonToJettonTxParams({
  userWalletAddress: "", // ! replace with your address
  proxyTon: new pTON.v1(),
  offerAmount: toNano("1"),
  askJettonAddress: "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO", // STON
  minAskAmount: "1",
  queryId: 12345,
});

import { TonClient, toNano } from "@ton/ton";
import { DEX, pTON } from "@ston-fi/sdk";

const client = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

const router = client.open(new DEX.v1.Router());

// swap 1 STON to GEMSTON but not less than 1 nano GEMSTON
const txParams = await router.getSwapJettonToJettonTxParams({
  userWalletAddress: "", // ! replace with your address
  offerJettonAddress: "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO", // STON
  offerAmount: toNano("1"),
  askJettonAddress: "EQBX6K9aXVl3nXINCyPPL86C4ONVmQ8vK360u6dykFKXpHCa", // GEMSTON
  minAskAmount: "1",
  queryId: 12345,
});

import { TonClient, toNano } from "@ton/ton";
import { DEX, pTON } from "@ston-fi/sdk";

const client = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

const router = client.open(new DEX.v1.Router());

// swap 1 GEMSTON to TON but not less than 1 nano TON
const txParams = await router.getSwapJettonToTonTxParams({
  userWalletAddress: "", // ! replace with your address
  offerJettonAddress: "EQBX6K9aXVl3nXINCyPPL86C4ONVmQ8vK360u6dykFKXpHCa", // GEMSTON
  offerAmount: toNano("1"),
  proxyTon: new pTON.v1(),
  minAskAmount: "1",
  queryId: 12345,
});

// pton_transfer + (pay_to + jetton_transfer) * 2 + (jetton_notification + swap)
fwd_amount = 0.01 + (0.02 + 0.045) * 2 + 0.045; // = 0.185
// jetton_transfer + fwd_amount
tx_amount = swap_amount + fwd_amount; // = swap_amount + 0.185

// (jetton_notification + swap) + (pay_to + jetton_transfer) * 2
fwd_amount = 0.045 + (0.02 + 0.045) * 2; // = 0.175
// jetton_transfer + fwd_amount
tx_amount = 0.045 + fwd_amount; // = 0.22

// (jetton_notification + swap) + (pay_to + pton_transfer) * 2
fwd_amount = 0.045 + (0.02 + 0.02) * 2; // = 0.125
// jetton_transfer + fwd_amount
tx_amount = 0.045 + fwd_amount; // = 0.17

import { TonClient, toNano } from "@ton/ton";
import { DEX } from "@ston-fi/sdk";

const USER_WALLET_ADDRESS = ""; // ! replace with your address
const JETTON_0_ADDRESS = "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO"; // STON
const JETTON_1_ADDRESS = "EQBX6K9aXVl3nXINCyPPL86C4ONVmQ8vK360u6dykFKXpHCa"; // GEMSTON

const client = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

const router = client.open(new DEX.v1.Router());

const txsParams = await Promise.all([
  // deposit 0.5 STON to the STON/GEMSTON pool and get at least 1 nano LP token
  router.getProvideLiquidityJettonTxParams({
    userWalletAddress: USER_WALLET_ADDRESS,
    sendTokenAddress: JETTON_0_ADDRESS,
    sendAmount: toNano("0.5"),
    otherTokenAddress: JETTON_1_ADDRESS,
    minLpOut: "1",
    queryId: 12345,
  }),
  // deposit 2 GEMSTON to the STON/GEMSTON pool and get at least 1 nano LP token
  router.getProvideLiquidityJettonTxParams({
    userWalletAddress: USER_WALLET_ADDRESS,
    sendTokenAddress: JETTON_1_ADDRESS,
    sendAmount: toNano("2.0"),
    otherTokenAddress: JETTON_0_ADDRESS,
    minLpOut: "1",
    queryId: 123456,
  }),
]);

import { TonClient, toNano } from "@ton/ton";
import { DEX, pTON } from "@ston-fi/sdk";

const USER_WALLET_ADDRESS = ""; // ! replace with your address
const JETTON_0_ADDRESS = "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO"; // STON

const client = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

const router = client.open(new DEX.v1.Router());

const txsParams = await Promise.all([
  // deposit 1 TON to the STON/TON pool and get at least 1 nano LP token
  router.getProvideLiquidityTonTxParams({
    userWalletAddress: USER_WALLET_ADDRESS,
    proxyTon: new pTON.v1(),
    sendAmount: toNano("1"),
    otherTokenAddress: JETTON_0_ADDRESS,
    minLpOut: "1",
    queryId: 12345,
  }),
  // deposit 0.5 STON to the STON/TON pool and get at least 1 nano LP token
  router.getProvideLiquidityJettonTxParams({
    userWalletAddress: USER_WALLET_ADDRESS,
    sendTokenAddress: JETTON_0_ADDRESS,
    sendAmount: toNano("0.5"),
    otherTokenAddress: new pTON.v1().address,
    minLpOut: "1",
    queryId: 123456,
  }),
]);

import { TonClient } from "@ton/ton";
import { DEX } from "@ston-fi/sdk";

const USER_WALLET_ADDRESS = ""; // ! replace with your address

const client = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

const router = client.open(new DEX.v1.Router());

const pool = client.open(await router.getPool({
  token0: "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO", // STON
  token1: "EQBX6K9aXVl3nXINCyPPL86C4ONVmQ8vK360u6dykFKXpHCa", // GEMSTON
}));

const lpTokenWallet = client.open(await pool.getJettonWallet({
  ownerAddress: USER_WALLET_ADDRESS,
}));

const lpTokenWalletData = await lpTokenWallet.getWalletData();

const txParams = await pool.getBurnTxParams({
  amount: lpTokenWalletData.balance,
  responseAddress: USER_WALLET_ADDRESS,
  queryId: 12345,
});

import { TonClient } from "@ton/ton";
import { DEX } from "@ston-fi/sdk";

const client = new TonClient({
  endpoint: "https://testnet.toncenter.com/api/v2/jsonRPC",
});

const router = client.open(
  DEX.v2_1.Router.create(
    "kQALh-JBBIKK7gr0o4AVf9JZnEsFndqO0qTCyT-D-yBsWk0v" // CPI Router v2.1.0
  )
);

const pool = client.open(
  await router.getPool({
    token0: "kQDLvsZol3juZyOAVG8tWsJntOxeEZWEaWCbbSjYakQpuYN5", // TestRED
    token1: "kQB_TOJSB7q3-Jm1O8s0jKFtqLElZDPjATs5uJGsujcjznq3", // TestBLUE
  })
);

const lpAccount = client.open(
  await pool.getLpAccount({
    ownerAddress: "", // ! replace with your address
  })
);

const txParams = await lpAccount.getRefundTxParams({
  queryId: 12345,
});

import { TonClient, toNano } from "@ton/ton";
import { DEX, pTON } from "@ston-fi/sdk";

const client = new TonClient({
  endpoint: "https://testnet.toncenter.com/api/v2/jsonRPC",
});

const router = client.open(
  DEX.v2_1.Router.create(
    "kQALh-JBBIKK7gr0o4AVf9JZnEsFndqO0qTCyT-D-yBsWk0v" // CPI Router v2.1.0
  )
);

const proxyTon = pTON.v2_1.create(
  "kQACS30DNoUQ7NfApPvzh7eBmSZ9L4ygJ-lkNWtba8TQT-Px" // pTON v2.1.0
);

// swap 1 TON to TestRED but not less than 1 nano TestRED
const txParams = await router.getSwapTonToJettonTxParams({
  userWalletAddress: "", // ! replace with your address
  proxyTon: proxyTon,
  offerAmount: toNano("1"),
  askJettonAddress: "kQDLvsZol3juZyOAVG8tWsJntOxeEZWEaWCbbSjYakQpuYN5", // TestRED
  minAskAmount: "1",
  queryId: 12345,
});

import { TonClient, toNano } from "@ton/ton";
import { DEX, pTON } from "@ston-fi/sdk";

const client = new TonClient({
  endpoint: "https://testnet.toncenter.com/api/v2/jsonRPC",
});

const router = client.open(
  DEX.v2_1.Router.create(
    "kQALh-JBBIKK7gr0o4AVf9JZnEsFndqO0qTCyT-D-yBsWk0v" // CPI Router v2.1.0
  )
);

// swap 1 TesREED to TestBlue but not less than 1 nano TestBlue
const txParams = await router.getSwapJettonToJettonTxParams({
  userWalletAddress: "", // ! replace with your address
  offerJettonAddress: "kQDLvsZol3juZyOAVG8tWsJntOxeEZWEaWCbbSjYakQpuYN5", // TesREED
  offerAmount: toNano("1"),
  askJettonAddress: "kQB_TOJSB7q3-Jm1O8s0jKFtqLElZDPjATs5uJGsujcjznq3", // TestBlue
  minAskAmount: "1",
  queryId: 12345,
});

import { TonClient, toNano } from "@ton/ton";
import { DEX, pTON } from "@ston-fi/sdk";

const client = new TonClient({
  endpoint: "https://testnet.toncenter.com/api/v2/jsonRPC",
});

const router = client.open(
  DEX.v2_1.Router.create(
    "kQALh-JBBIKK7gr0o4AVf9JZnEsFndqO0qTCyT-D-yBsWk0v" // CPI Router v2.1.0
  )
);

const proxyTon = pTON.v2_1.create(
  "kQACS30DNoUQ7NfApPvzh7eBmSZ9L4ygJ-lkNWtba8TQT-Px" // pTON v2.1.0
);

// swap 1 TestRED to TON but not less than 1 nano TON
const txParams = await router.getSwapJettonToTonTxParams({
  userWalletAddress: "", // ! replace with your address
  offerJettonAddress: "kQDLvsZol3juZyOAVG8tWsJntOxeEZWEaWCbbSjYakQpuYN5", // TestRED
  offerAmount: toNano("1"),
  minAskAmount: "1",
  proxyTon,
  queryId: 12345,
});

const client = new TonClient({
  endpoint: "https://testnet.toncenter.com/api/v2/jsonRPC",
});

const router = client.open(
  DEX.v2_1.Router.create(
    "kQALh-JBBIKK7gr0o4AVf9JZnEsFndqO0qTCyT-D-yBsWk0v" // CPI Router v2.1.0
  )
);

const vault = client.open(
  await router.getVault({
    tokenMinter: "kQDLvsZol3juZyOAVG8tWsJntOxeEZWEaWCbbSjYakQpuYN5", // TestRED
    user: "" // ! replace with your address
  })
);

const txParams = await vault.getWithdrawFeeTxParams({
  queryId: 12345,
});

import { TonClient, toNano } from "@ton/ton";
import { DEX } from "@ston-fi/sdk";

const USER_WALLET_ADDRESS = ""; // ! replace with your address
const JETTON_0_ADDRESS = "kQDLvsZol3juZyOAVG8tWsJntOxeEZWEaWCbbSjYakQpuYN5"; // TestRED
const JETTON_1_ADDRESS = "kQB_TOJSB7q3-Jm1O8s0jKFtqLElZDPjATs5uJGsujcjznq3"; // TestBLUE

const client = new TonClient({
  endpoint: "https://testnet.toncenter.com/api/v2/jsonRPC",
});

const router = client.open(
  DEX.v2_1.Router.create(
    "kQALh-JBBIKK7gr0o4AVf9JZnEsFndqO0qTCyT-D-yBsWk0v" // CPI Router v2.1.0
  )
);

const txParams = await Promise.all([
  // deposit 1 TestRED to the TestRED/TestBLUE pool and get at least 1 nano LP token
  router.getProvideLiquidityJettonTxParams({
    userWalletAddress: USER_WALLET_ADDRESS,
    sendTokenAddress: JETTON_0_ADDRESS,
    sendAmount: toNano("1"),
    otherTokenAddress: JETTON_1_ADDRESS,
    minLpOut: "1",
    queryId: 12345,
  }),
  // deposit 1 TestBLUE to the TestRED/TestBLUE pool and get at least 1 nano LP token
  router.getProvideLiquidityJettonTxParams({
    userWalletAddress: USER_WALLET_ADDRESS,
    sendTokenAddress: JETTON_1_ADDRESS,
    sendAmount: toNano("1"),
    otherTokenAddress: JETTON_0_ADDRESS,
    minLpOut: "1",
    queryId: 123456,
  }),
]);

const USER_WALLET_ADDRESS = ""; // ! replace with your address
const JETTON_0_ADDRESS = "kQDLvsZol3juZyOAVG8tWsJntOxeEZWEaWCbbSjYakQpuYN5"; // TestRED
const JETTON_1_ADDRESS = "kQB_TOJSB7q3-Jm1O8s0jKFtqLElZDPjATs5uJGsujcjznq3"; // TestBLUE

const client = new TonClient({
  endpoint: "https://testnet.toncenter.com/api/v2/jsonRPC",
});

const router = client.open(
  DEX.v2_1.Router.create(
    "kQALh-JBBIKK7gr0o4AVf9JZnEsFndqO0qTCyT-D-yBsWk0v" // CPI Router v2.1.0
  )
);

// deposit 1 TestRED to the TestRED/TestBLUE pool and get at least 1 nano LP token
const txParams = await router.getSingleSideProvideLiquidityJettonTxParams({
  userWalletAddress: USER_WALLET_ADDRESS,
  sendTokenAddress: JETTON_0_ADDRESS,
  sendAmount: toNano("1"),
  otherTokenAddress: JETTON_1_ADDRESS,
  minLpOut: "1",
  queryId: 123456,
});

import { TonClient, toNano } from "@ton/ton";
import { DEX, pTON } from "@ston-fi/sdk";

const USER_WALLET_ADDRESS = ""; // ! replace with your address
const JETTON_0_ADDRESS = "kQDLvsZol3juZyOAVG8tWsJntOxeEZWEaWCbbSjYakQpuYN5"; // TestRED

const client = new TonClient({
  endpoint: "https://testnet.toncenter.com/api/v2/jsonRPC",
});

const router = client.open(
  DEX.v2_1.Router.create(
    "kQALh-JBBIKK7gr0o4AVf9JZnEsFndqO0qTCyT-D-yBsWk0v" // CPI Router v2.1.0
  )
);

const proxyTon = pTON.v2_1.create(
  "kQACS30DNoUQ7NfApPvzh7eBmSZ9L4ygJ-lkNWtba8TQT-Px" // pTON v2.1.0
);

const txParams = await Promise.all([
  // deposit 1 TON to the TON/TestRED pool and get at least 1 nano LP token
  router.getProvideLiquidityTonTxParams({
    userWalletAddress: USER_WALLET_ADDRESS,
    proxyTon,
    sendAmount: toNano("1"),
    otherTokenAddress: JETTON_0_ADDRESS,
    minLpOut: "1",
    queryId: 12345,
  }),
  // deposit 1 TestRED to the TON/TestRED pool and get at least 1 nano LP token
  router.getProvideLiquidityJettonTxParams({
    userWalletAddress: USER_WALLET_ADDRESS,
    sendTokenAddress: JETTON_0_ADDRESS,
    sendAmount: toNano("1"),
    otherTokenAddress: proxyTon.address,
    minLpOut: "1",
    queryId: 123456,
  }),
]);

import { TonClient, toNano } from "@ton/ton";
import { DEX, pTON } from "@ston-fi/sdk";

const USER_WALLET_ADDRESS = ""; // ! replace with your address
const JETTON_0_ADDRESS = "kQDLvsZol3juZyOAVG8tWsJntOxeEZWEaWCbbSjYakQpuYN5"; // TestRED

const client = new TonClient({
  endpoint: "https://testnet.toncenter.com/api/v2/jsonRPC",
});

const router = client.open(
  DEX.v2_1.Router.create(
    "kQALh-JBBIKK7gr0o4AVf9JZnEsFndqO0qTCyT-D-yBsWk0v" // CPI Router v2.1.0
  )
);

const proxyTon = pTON.v2_1.create(
  "kQACS30DNoUQ7NfApPvzh7eBmSZ9L4ygJ-lkNWtba8TQT-Px" // pTON v2.1.0
);

// deposit 1 TON to the TON/TestRED pool and get at least 1 nano LP token
const txParams = await router.getSingleSideProvideLiquidityTonTxParams({
  userWalletAddress: USER_WALLET_ADDRESS,
  proxyTon,
  sendAmount: toNano("1"),
  otherTokenAddress: JETTON_0_ADDRESS,
  minLpOut: "1",
  queryId: 12345,
});

import { TonClient } from "@ton/ton";
import { DEX } from "@ston-fi/sdk";

const USER_WALLET_ADDRESS = ""; // ! replace with your address

const client = new TonClient({
  endpoint: "https://testnet.toncenter.com/api/v2/jsonRPC",
});

const router = client.open(
  DEX.v2_1.Router.create(
    "kQALh-JBBIKK7gr0o4AVf9JZnEsFndqO0qTCyT-D-yBsWk0v" // CPI Router v2.1.0
  )
);

const pool = client.open(
  await router.getPool({
    token0: "kQDLvsZol3juZyOAVG8tWsJntOxeEZWEaWCbbSjYakQpuYN5", // TestRED
    token1: "kQB_TOJSB7q3-Jm1O8s0jKFtqLElZDPjATs5uJGsujcjznq3", // TestBLUE
  })
);

const lpWallet = client.open(
  await pool.getJettonWallet({
    ownerAddress: USER_WALLET_ADDRESS,
  })
);

const lpWalletData = await lpWallet.getWalletData();

const txParams = await pool.getBurnTxParams({
  amount: lpWalletData.balance,
  userWalletAddress: USER_WALLET_ADDRESS,
  queryId: 12345,
});

async getPoolAddress(
    provider: ContractProvider,
    params: {
      token0: Address | string;
      token1: Address | string;
    },
): Promise<Address>

async getPoolAddressByJettonMinters(
    provider: ContractProvider,
    params: {
      token0: Address | string;
      token1: Address | string;
    },
): Promise<Address>

async getPool(
    provider: ContractProvider,
    params: {
      token0: Address | string;
      token1: Address | string;
    },
): Promise<PoolV1>

async getRouterData(provider: ContractProvider): Promise<{
    isLocked: boolean;
    adminAddress: Address;
    tempUpgrade: Cell;
    poolCode: Cell;
    jettonLpWalletCode: Cell;
    lpAccountCode: Cell;
}>

async createSwapBody(params: {
    userWalletAddress: Address | string;
    minAskAmount: bigint | number | string;
    askJettonWalletAddress: Address | string;
    referralAddress?: Address | string;
}): Promise<Cell>

async getSwapJettonToJettonTxParams(
    provider: ContractProvider,
    params: {
        userWalletAddress: Address | string;
        offerJettonAddress: Address | string;
        askJettonAddress: Address | string;
        offerAmount: bigint | number | string;
        minAskAmount: bigint | number | string;
        referralAddress?: Address | string;
        gasAmount?: bigint | number | string;
        forwardGasAmount?: bigint | number | string;
        queryId?: number | bigint;
    },
): Promise<SenderArguments>

async getSwapJettonToTonTxParams(
    provider: ContractProvider,
    params: {
        userWalletAddress: Address | string;
        offerJettonAddress: Address | string;
        proxyTon: PtonV1;
        offerAmount: bigint | number | string;
        minAskAmount: bigint | number | string;
        referralAddress?: Address | string;
        gasAmount?: bigint | number | string;
        forwardGasAmount?: bigint | number | string;
        queryId?: number | bigint;
    },
): Promise<SenderArguments>

async getSwapTonToJettonTxParams(
    provider: ContractProvider,
    params: {
        userWalletAddress: Address | string;
        proxyTon: PtonV1;
        askJettonAddress: Address | string;
        offerAmount: bigint | number | string;
        minAskAmount: bigint | number | string;
        referralAddress?: Address | string;
        forwardGasAmount?: bigint | number | string;
        queryId?: number | bigint;
    },
): Promise<SenderArguments>

async createProvideLiquidityBody(params: {
    routerWalletAddress: Address | string;
    minLpOut: bigint | number | string;
}): Promise<Cell>

async getProvideLiquidityJettonTxParams(
    provider: ContractProvider,
    params: {
        userWalletAddress: Address | string;
        sendTokenAddress: Address | string;
        otherTokenAddress: Address | string;
        sendAmount: bigint | number | string;
        minLpOut: bigint | number | string;
        gasAmount?: bigint | number | string;
        forwardGasAmount?: bigint | number | string;
        queryId?: number | bigint;
    },
): Promise<SenderArguments>

public async getProvideLiquidityTonTxParams(
    provider: ContractProvider,
    params: {
        userWalletAddress: Address | string;
        proxyTon: PtonV1;
        otherTokenAddress: Address | string;
        sendAmount: bigint | number | string;
        minLpOut: bigint | number | string;
        forwardGasAmount?: bigint | number | string;
        queryId?: number | bigint;
    },
): Promise<SenderArguments>

async getPoolData(provider: ContractProvider): Promise<{
    reserve0: bigint;
    reserve1: bigint;
    token0WalletAddress: Address;
    token1WalletAddress: Address;
    lpFee: bigint;
    protocolFee: bigint;
    refFee: bigint;
    protocolFeeAddress: Address;
    collectedToken0ProtocolFee: bigint;
    collectedToken1ProtocolFee: bigint;
}>

async getExpectedOutputs(
    provider: ContractProvider,
    params: {
        amount: bigint | number | string;
        jettonWallet: Address | string;
    },
): Promise<{
    jettonToReceive: bigint;
    protocolFeePaid: bigint;
    refFeePaid: bigint;
}>

async getExpectedTokens(
    provider: ContractProvider,
    params: {
        amount0: bigint | number | string;
        amount1: bigint | number | string;
    },
): Promise<bigint>

async getExpectedLiquidity(
    provider: ContractProvider,
    params: {
        jettonAmount: bigint | number | string;
    },
): Promise<{
    amount0: bigint;
    amount1: bigint;
}>

async getLpAccountAddress(
    provider: ContractProvider,
    params: {
        ownerAddress: Address | string,
    },
): Promise<Address>

async getLpAccount(
    provider: ContractProvider,
    params: {
        ownerAddress: Address | string
    },
): Promise<LpAccountV1>

async getJettonData(
    provider: ContractProvider,
): Promise<{
    totalSupply: bigint,
    isMintable: boolean,
    adminAddress: Address|null,
    jettonContentUri: string|null,
    jettonWalletCode: Cell
}>

getWalletAddress(
    provider: ContractProvider,
    ownerAddress: Address | string,
): Promise<Address>

async getJettonWallet(
    provider: ContractProvider,
    params: {
        ownerAddress: Address | string;
    },
): Promise<JettonWallet>

async createCollectFeesBody(params: {
    queryId?: QueryIdType
}): Promise<Cell>

async getCollectFeeTxParams(
    provider: ContractProvider,
    params?: {
        gasAmount?: bigint | number | string;
        queryId?: number | bigint;
    },
): Promise<SenderArguments>

async createBurnBody(params: {
    amount: bigint | number | string;
    responseAddress: Address | string;
    queryId?: number | bigint;
}): Promise<Cell>

async getBurnTxParams(
    provider: ContractProvider,
    params: {
        amount: bigint | number | string;
        responseAddress: Address | string;
        gasAmount?: bigint | number | string;
        queryId?: number | bigint;
    },
): Promise<SenderArguments>

async getLpAccountData(provider: ContractProvider): Promise<{
    userAddress: Address;
    poolAddress: Address;
    amount0: bigint;
    amount1: bigint;
}>

async createRefundBody(params?: {
    queryId?: QueryIdType
}): Promise<Cell>

async getRefundTxParams(
    provider: ContractProvider,
    params?: {
        gasAmount?: bigint | number | string;
        queryId?: number | bigint;
    },
): Promise<SenderArguments>

async createDirectAddLiquidityBody(params: {
    amount0: bigint | number | string;
    amount1: bigint | number | string;
    minimumLpToMint?: bigint | number | string;
    queryId?: number | bigint;
}): Promise<Cell>

async getDirectAddLiquidityTxParams(
    provider: ContractProvider,
    params: {
        amount0: bigint | number | string;
        amount1: bigint | number | string;
        minimumLpToMint?: bigint | number | string;
        gasAmount?: bigint | number | string;
        queryId?: number | bigint;
    },
): Promise<SenderArguments>

async createResetGasBody(params?: {
    queryId?: QueryIdType
}): Promise<Cell>

async getResetGasTxParams(
    provider: ContractProvider,
    params?: {
        gasAmount?: bigint | number | string;
        queryId?: number | bigint;
    },
): Promise<SenderArguments>

{
    to: Address;
    value: bigint;
    body?: Cell | null;
}

import { TonClient } from "@ton/ton";
import { FARM } from "@ston-fi/sdk";

const client = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

const farmNft = client.open(FARM.v3.NftItem.create(
  "EQA18JnBVNZZ8Wz-Kn6Mc5cy9pv798Pn8tfScjKw9NLPK3U2", // Farm v3 nft address
));

// Unstake all staked funds from Farm NFT back to the owner's wallet
const txParams = await farmNft.getUnstakeTxParams({
  queryId: 12345,
});

import { TonClient } from "@ton/ton";
import { FARM } from "@ston-fi/sdk";

const client = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

const farmNft = client.open(FARM.v3.NftItem.create(
  "EQA18JnBVNZZ8Wz-Kn6Mc5cy9pv798Pn8tfScjKw9NLPK3U2", // Farm v3 nft address
));

// Unstake all staked funds from Farm NFT back to the owner's wallet
const txParams = await farmNft.getClaimRewardsTxParams({
  queryId: 12345,
});

import { TonClient } from "@ton/ton";
import { FARM } from "@ston-fi/sdk";

const client = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

const farmNft = client.open(FARM.v3.NftItem.create(
  "EQA18JnBVNZZ8Wz-Kn6Mc5cy9pv798Pn8tfScjKw9NLPK3U2", // Farm v3 nft address
));

// Destroy farm NFT from the owner's wallet
const txParams = await farmNft.getDestroyTxParams({
  queryId: 12345,
});

import { TonClient, toNano } from "@ton/ton";
import { FARM } from "@ston-fi/sdk";

const client = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

const farm = client.open(FARM.v3.NftMinter.create(
  "EQATBSfNArrEFmchmy1XabKmxMNp9KezscqjPzfmstCU7VXO", // STON/TON Farm v3
));

// Stake 1 STON/TON LP token in v3 farm
const txParams = await farm.getStakeTxParams({
  userWalletAddress: "", // ! replace with your address
  jettonAddress: "EQDtZHOtVWaf9UIU6rmjLPNLTGxNLNogvK5xUZlMRgZwQ4Gt", // STON/TON pool LP token address
  jettonAmount: toNano("1"),
  queryId: 12345,
});

import TonWeb from "tonweb";
import { DEX, pTON } from "@ston-fi/sdk";

const router = new DEX.v1.Router({
  tonApiClient: new TonWeb.HttpProvider(),
});

const tonToJettonTxParams = await router.buildSwapJettonToTonTxParams({
  userWalletAddress: "", // ! replace with your address
  offerJettonAddress: "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO", // STON
  offerAmount: new TonWeb.utils.BN("1000000000"),
  proxyTonAddress: pTON.v1.address,
  minAskAmount: new TonWeb.utils.BN("1"),
  queryId: 12345,
});

import { TonClient } from "@ton/ton";

const client = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

import { DEX } from "@ston-fi/sdk";

type ContractsConstructorParameters = ConstructorParameters<
  typeof DEX.v1.Router
>;
// ^: [address: Address | string, (RouterV1Options | undefined)?]

- import TonWeb from 'tonweb';

const router = new DEX.v1.Router(
-  {
-    tonApiClient: new TonWeb.HttpProvider(),
-  }
);

const pool = new DEX.v1.Pool(
  "EQCl-ax-5QC06ub096s2bqTbhYZWigZ1-FkJm2IVIMSazp7U" // STON/GEMSTON pool
);

const pool = new DEX.v1.Pool(
+ 'EQCl-ax-5QC06ub096s2bqTbhYZWigZ1-FkJm2IVIMSazp7U',
  {
-    address: 'EQCl-ax-5QC06ub096s2bqTbhYZWigZ1-FkJm2IVIMSazp7U',
    gasConstants: {
        burn: DEX.v1.Pool.gasConstants.burn,
    }
  }
);

import { TonClient } from "@ton/ton";
import { DEX } from '@ston-fi/sdk';

const client = new TonClient({
  endpoint: 'https://toncenter.com/api/v2/jsonRPC',
});

- const router = new DEX.v1.Router();
+ const router = client.open(new DEX.v1.Router());

- const tonToJettonTxParams = await router.buildSwapJettonToTonTxParams({

+ const tonToJettonTxParams = await router.getSwapJettonToTonTxParams({

-  offerAmount: new TonWeb.utils.BN('1000000000'),
+  offerAmount: BigInt('1000000000'),
-  minAskAmount: new TonWeb.utils.BN('1'),
+  minAskAmount: BigInt('1'),

const tonToJettonTxParams = await router.getSwapJettonToTonTxParams({
-  proxyTonAddress: pTON.v1.address,
+  proxyTon: new pTON.v1(),
});

type TxParams = typeof tonToJettonTxParams;
// ^: { to: Address, gasAmount: BN, payload: Cell }

type TxParams = typeof tonToJettonTxParams;
// ^: { to: Address, value: BigInt, body?: Cell | null }

import { TonClient } from "@ton/ton";
import { DEX, pTON } from "@ston-fi/sdk";

const client = new TonClient({
  endpoint: "https://ton-api.ston.fi/jsonRPC",
});

const router = client.open(new DEX.v1.Router());

const tonToJettonTxParams = await router.getSwapJettonToTonTxParams({
    userWalletAddress: "", // ! replace with your address
    offerJettonAddress: "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO", // STON
    offerAmount: BigInt("1000000000"),
    proxyTon: new pTON.v1(),
    minAskAmount: BigInt("1"),
    queryId: 12345,
  });

import { TonClient, WalletContractV4, internal, toNano } from "@ton/ton";
import { mnemonicToPrivateKey } from "@ton/crypto";
import { DEX, pTON } from "@ston-fi/sdk";

const client = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

const mnemonics = Array.from(
  { length: 24 },
  (_, i) => `your mnemonic word ${i + 1}`
); // replace with your mnemonic
const keyPair = await mnemonicToPrivateKey(mnemonics);

const workchain = 0;
const wallet = WalletContractV4.create({
  workchain,
  publicKey: keyPair.publicKey,
});
const contract = client.open(wallet);

const dex = client.open(new DEX.v1.Router());

// swap 1 TON for a STON but not less than 0.1 STON
const txArgs = {
  offerAmount: toNano("1"),
  askJettonAddress: "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO",
  minAskAmount: toNano("0.1"),
  proxyTon: new pTON.v1(),
  userWalletAddress: wallet.address.toString(),
};

// you can instantly send the transaction using the router method with send suffix
await dex.sendSwapTonToJetton(contract.sender(keyPair.secretKey), txArgs);

// or you can get the transaction parameters
const txParams = await dex.getSwapTonToJettonTxParams(txArgs);

// and send it manually later
await contract.sendTransfer({
  seqno: await contract.getSeqno(),
  secretKey: keyPair.secretKey,
  messages: [internal(txParams)],
});

import React from "react";
import { TonClient, toNano } from "@ton/ton";
import { DEX, pTON } from "@ston-fi/sdk";
import { useTonConnectUI, useTonAddress } from "@tonconnect/ui-react";

const client = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

const dex = client.open(new DEX.v1.Router());

export const Example = () => {
  const wallet = useTonAddress();
  const [tonConnectUI] = useTonConnectUI();

  return (
    <button
      onClick={async () => {
        const txParams = await dex.getSwapTonToJettonTxParams({
          offerAmount: toNano("1"), // swap 1 TON
          askJettonAddress: "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO", // for a STON
          minAskAmount: toNano("0.1"), // but not less than 0.1 STON
          proxyTon: new pTON.v1(),
          userWalletAddress: wallet,
        });

        await tonConnectUI.sendTransaction({
          validUntil: Date.now() + 1000000,
          messages: [
            {
              address: txParams.to.toString(),
              amount: txParams.value.toString(),
              payload: txParams.body?.toBoc().toString("base64"),
            },
          ],
        });
      }}
    >
      Swap 1 TON to STON
    </button>
  );
};

import TonWeb from "tonweb";
import TonWebMnemonic from "tonweb-mnemonic";
import { TonClient, toNano } from "@ton/ton";
import { DEX, pTON } from "@ston-fi/sdk";

const tonWeb = new TonWeb();
const client = new TonWeb.HttpProvider();

const tonClient = new TonClient({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
});

const mnemonics = Array.from(
  { length: 24 },
  (_, i) => `your mnemonic word ${i + 1}`
); // replace with your mnemonic
const keyPair = await TonWebMnemonic.mnemonicToKeyPair(mnemonics);

const wallet = new tonWeb.wallet.all.v4R2(client, {
  publicKey: keyPair.publicKey,
});

const dex = tonClient.open(new DEX.v1.Router());

const txParams = await dex.getSwapTonToJettonTxParams({
  offerAmount: toNano("1"), // swap 1 TON
  askJettonAddress: "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO", // for a STON
  minAskAmount: toNano("0.1"), // but not less than 0.1 STON
  proxyTon: new pTON.v1(),
  userWalletAddress: (await wallet.getAddress()).toString(),
});

await wallet.methods
  .transfer({
    secretKey: keyPair.secretKey,
    toAddress: txParams.to.toString(),
    amount: new tonWeb.utils.BN(txParams.value),
    seqno: (await wallet.methods.seqno().call()) ?? 0,
    payload: TonWeb.boc.Cell.oneFromBoc(
      TonWeb.utils.base64ToBytes(txParams.body?.toBoc().toString("base64"))
    ),
    sendMode: 3,
  })
  .send();

npm install tonweb @ston-fi/sdk

yarn add tonweb @ston-fi/sdk

pnpm install tonweb @ston-fi/sdk

import TonWeb from "tonweb";
import { DEX } from "@ston-fi/sdk";

const USER_WALLET_ADDRESS = ""; // ! replace with your address
const JETTON_0_ADDRESS = "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO"; // STON
const JETTON_1_ADDRESS = "EQBX6K9aXVl3nXINCyPPL86C4ONVmQ8vK360u6dykFKXpHCa"; // GEMSTON

const router = new DEX.v1.Router({
  tonApiClient: new TonWeb.HttpProvider(),
});

const pool = await router.getPool({
  token0: JETTON_0_ADDRESS,
  token1: JETTON_1_ADDRESS,
});

if (!pool) {
  throw Error(`Pool for ${JETTON_0_ADDRESS}/${JETTON_1_ADDRESS} not found`);
}

const lpTokenWallet = await pool.getJettonWallet({
  ownerAddress: USER_WALLET_ADDRESS,
});
const lpTokenWalletData = await lpTokenWallet.getData();

const txParams = await pool.buildBurnTxParams({
  amount: lpTokenWalletData.balance,
  responseAddress: USER_WALLET_ADDRESS,
  queryId: 12345,
});

// To execute the transaction, you need to send a transaction to the blockchain.
// This code will be different based on the wallet you are using to send the tx from
// logging is used for demonstration purposes
console.log({
  to: txParams.to,
  amount: txParams.gasAmount,
  payload: txParams.payload,
});

import TonWeb from "tonweb";
import { DEX } from "@ston-fi/sdk";

const USER_WALLET_ADDRESS = ""; // ! replace with your address
const JETTON_0_ADDRESS = "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO"; // STON
const JETTON_1_ADDRESS = "EQBX6K9aXVl3nXINCyPPL86C4ONVmQ8vK360u6dykFKXpHCa"; // GEMSTON

const router = new DEX.v1.Router({
  tonApiClient: new TonWeb.HttpProvider(),
});

const pool = await router.getPool({
  token0: JETTON_0_ADDRESS,
  token1: JETTON_1_ADDRESS,
});

if (!pool) {
  throw Error(`Pool for ${JETTON_0_ADDRESS}/${JETTON_1_ADDRESS} not found`);
}

const lpAccount = await pool.getLpAccount({ ownerAddress: USER_WALLET_ADDRESS });

if (!lpAccount) {
  throw Error(
    `LpAccount for ${USER_WALLET_ADDRESS} at ${JETTON_0_ADDRESS}/${JETTON_1_ADDRESS} pool not found`
  );
}

const txParams = await lpAccount.buildRefundTxParams({
  queryId: 12345,
});

// To execute the transaction, you need to send a transaction to the blockchain.
// This code will be different based on the wallet you are using to send the tx from
// logging is used for demonstration purposes
console.log({
  to: txParams.to,
  amount: txParams.gasAmount,
  payload: txParams.payload,
});

import TonWeb from "tonweb";
import { FARM } from "@ston-fi/sdk";

const farm = new FARM.v3.NftMinter({
  tonApiClient: new TonWeb.HttpProvider(),
  address: "EQATBSfNArrEFmchmy1XabKmxMNp9KezscqjPzfmstCU7VXO", // STON/TON Farm v3
});

// Stake 1 STON/TON LP token in v3 farm
const txParams = farm.buildStakeTxParams({
  userWalletAddress: "", // ! replace with your address
  jettonAddress: "EQDtZHOtVWaf9UIU6rmjLPNLTGxNLNogvK5xUZlMRgZwQ4Gt", // STON/TON pool LP token address
  jettonAmount: "1000000000",
  queryId: 12345,
});

// To execute the transaction, you need to send a transaction to the blockchain.
// This code will be different based on the wallet you are using to send the tx from
// logging is used for demonstration purposes
console.log({
  to: txParams.to,
  amount: txParams.gasAmount,
  payload: txParams.payload,
});

import TonWeb from "tonweb";
import { DEX, pTON } from "@ston-fi/sdk";

const router = new DEX.v1.Router({
  tonApiClient: new TonWeb.HttpProvider(),
});

// swap 1 TON to STON but not less than 1 nano STON
const txParams = await router.buildSwapTonToJettonTxParams({
  userWalletAddress: "", // ! replace with your address
  proxyTonAddress: pTON.v1.address,
  offerAmount: new TonWeb.utils.BN("1000000000"),
  askJettonAddress: "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO", // STON
  minAskAmount: new TonWeb.utils.BN("1"),
  queryId: 12345,
});

// To execute the transaction, you need to send a transaction to the blockchain.
// This code will be different based on the wallet you are using to send the tx from
// logging is used for demonstration purposes
console.log({
  to: txParams.to,
  amount: txParams.gasAmount,
  payload: txParams.payload,
});

import TonWeb from "tonweb";
import { DEX, pTON } from "@ston-fi/sdk";

const router = new DEX.v1.Router({
  tonApiClient: new TonWeb.HttpProvider(),
});

// swap 1 STON to GEMSTON but not less than 1 nano GEMSTON
const txParams = await router.buildSwapJettonToJettonTxParams({
  userWalletAddress: "", // ! replace with your address
  offerJettonAddress: "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO", // STON
  offerAmount: new TonWeb.utils.BN("1000000000"),
  askJettonAddress: "EQBX6K9aXVl3nXINCyPPL86C4ONVmQ8vK360u6dykFKXpHCa", // GEMSTON
  minAskAmount: new TonWeb.utils.BN("1"),
  queryId: 12345,
});

// To execute the transaction, you need to send a transaction to the blockchain.
// This code will be different based on the wallet you are using to send the tx from
// logging is used for demonstration purposes
console.log({
  to: txParams.to,
  amount: txParams.gasAmount,
  payload: txParams.payload,
});

import TonWeb from "tonweb";
import { DEX, pTON } from "@ston-fi/sdk";

const router = new DEX.v1.Router({
  tonApiClient: new TonWeb.HttpProvider(),
});

// swap 1 GEMSTON to TON but not less than 1 nano TON
const txParams = await router.buildSwapJettonToTonTxParams({
  userWalletAddress: "", // ! replace with your address
  offerJettonAddress: "EQBX6K9aXVl3nXINCyPPL86C4ONVmQ8vK360u6dykFKXpHCa", // GEMSTON
  offerAmount: new TonWeb.utils.BN("1000000000"),
  proxyTonAddress: pTON.v1.address,
  minAskAmount: new TonWeb.utils.BN("1"),
  queryId: 12345,
});

// To execute the transaction, you need to send a transaction to the blockchain.
// This code will be different based on the wallet you are using to send the tx from
// logging is used for demonstration purposes
console.log({
  to: txParams.to,
  amount: txParams.gasAmount,
  payload: txParams.payload,
});

// pton_transfer + (pay_to + jetton_transfer) * 2 + (jetton_notification + swap)
fwd_amount = 0.01 + (0.02 + 0.06) * 2 + 0.045; // = 0.215
// jetton_transfer + fwd_amount
tx_amount = swap_amount + fwd_amount; // = swap_amount + 0.215

// (jetton_notification + swap) + (pay_to + jetton_transfer) * 2
fwd_amount = 0.045 + (0.02 + 0.06) * 2; // = 0.205
// jetton_transfer + fwd_amount
tx_amount = 0.06 + fwd_amount; // = 0.265

// (jetton_notification + swap) + (pay_to + pton_transfer) * 2
fwd_amount = 0.045 + (0.02 + 0.02) * 2; // = 0.125
// jetton_transfer + fwd_amount
tx_amount = 0.06 + fwd_amount; // = 0.185

import TonWeb from "tonweb";
import { DEX } from "@ston-fi/sdk";

const USER_WALLET_ADDRESS = ""; // ! replace with your address
const JETTON_0_ADDRESS = "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO"; // STON
const JETTON_1_ADDRESS = "EQBX6K9aXVl3nXINCyPPL86C4ONVmQ8vK360u6dykFKXpHCa"; // GEMSTON

const router = new DEX.v1.Router({
  tonApiClient: new TonWeb.HttpProvider(),
});

const txsParams = await Promise.all([
  // deposit 5 STON to the STON/GEMSTON pool and get at least 1 nano LP token
  router.buildProvideLiquidityJettonTxParams({
    userWalletAddress: USER_WALLET_ADDRESS,
    sendTokenAddress: JETTON_0_ADDRESS,
    sendAmount: new TonWeb.utils.BN("500000000"),
    otherTokenAddress: JETTON_1_ADDRESS,
    minLpOut: new TonWeb.utils.BN("1"),
    queryId: 12345,
  }),
  // deposit 2 GEMSTON to the STON/GEMSTON pool and get at least 1 nano LP token
  router.buildProvideLiquidityJettonTxParams({
    userWalletAddress: USER_WALLET_ADDRESS,
    sendTokenAddress: JETTON_1_ADDRESS,
    sendAmount: new TonWeb.utils.BN("200000000"),
    otherTokenAddress: JETTON_0_ADDRESS,
    minLpOut: new TonWeb.utils.BN("1"),
    queryId: 123456,
  }),
]);

// To execute the transaction, you need to send a transaction to the blockchain.
// This code will be different based on the wallet you are using to send the tx from
// logging is used for demonstration purposes
txsParams.map((txParams) => console.log({
  to: txParams.to,
  amount: txParams.gasAmount,
  payload: txParams.payload,
}));

import TonWeb from "tonweb";
import { DEX, pTON } from "@ston-fi/sdk";

const USER_WALLET_ADDRESS = ""; // ! replace with your address
const JETTON_0_ADDRESS = "EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO"; // STON
const pTON_ADDRESS = pTON.v1.address;

const router = new DEX.v1.Router({
  tonApiClient: new TonWeb.HttpProvider(),
});

const txsParams = await Promise.all([
  // deposit 1 TON to the STON/TON pool and get at least 1 nano LP token
  router.buildProvideLiquidityTonTxParams({
    userWalletAddress: USER_WALLET_ADDRESS,
    proxyTonAddress: pTON_ADDRESS,
    sendAmount: new TonWeb.utils.BN("100000000"),
    otherTokenAddress: JETTON_0_ADDRESS,
    minLpOut: new TonWeb.utils.BN("1"),
    queryId: 12345,
  }),
  // deposit 5 STON to the STON/TON pool and get at least 1 nano LP token
  router.buildProvideLiquidityJettonTxParams({
    userWalletAddress: USER_WALLET_ADDRESS,
    sendTokenAddress: JETTON_0_ADDRESS,
    sendAmount: new TonWeb.utils.BN("500000000"),
    otherTokenAddress: pTON_ADDRESS,
    minLpOut: new TonWeb.utils.BN("1"),
    queryId: 123456,
  }),
]);

// To execute the transaction, you need to send a transaction to the blockchain.
// This code will be different based on the wallet you are using to send the tx from
// logging is used for demonstration purposes
txsParams.map((txParams) => console.log({
  to: txParams.to,
  amount: txParams.gasAmount,
  payload: txParams.payload,
}));

{
    to: Address;
    payload: Cell;
    gasAmount: BN;
}

import TonWeb from "tonweb";
import { FARM } from "@ston-fi/sdk";

const farm = new FARM.v3.NftItem({
  tonApiClient: new TonWeb.HttpProvider(),
  address: "EQA18JnBVNZZ8Wz-Kn6Mc5cy9pv798Pn8tfScjKw9NLPK3U2", // Farm v3 nft address
});

// Claim occurred farming rewards from the NFT to the owner's wallet
const txParams = farm.buildClaimRewardsTxParams({
  queryId: 12345,
});

// To execute the transaction, you need to send a transaction to the blockchain.
// This code will be different based on the wallet you are using to send the tx from
// logging is used for demonstration purposes
console.log({
  to: txParams.to,
  amount: txParams.gasAmount,
  payload: txParams.payload,
});

import TonWeb from "tonweb";
import { FARM } from "@ston-fi/sdk";

const farm = new FARM.v3.NftItem({
  tonApiClient: new TonWeb.HttpProvider(),
  address: "EQA18JnBVNZZ8Wz-Kn6Mc5cy9pv798Pn8tfScjKw9NLPK3U2", // Farm v3 nft address
});

// Destroy farm NFT from the owner's wallet
const txParams = farm.buildDestroyTxParams({
  queryId: 12345,
});

// To execute the transaction, you need to send a transaction to the blockchain.
// This code will be different based on the wallet you are using to send the tx from
// logging is used for demonstration purposes
console.log({
  to: txParams.to,
  amount: txParams.gasAmount,
  payload: txParams.payload,
});

import TonWeb from "tonweb";
import { TonClient, WalletContractV4, internal, toNano, Cell } from "@ton/ton";
import { mnemonicToPrivateKey } from "@ton/crypto";
import { DEX, pTON } from "@ston-fi/sdk";

const MNEMONIC = Array.from({ length: 24 }, (_, i) => `your mnemonic word ${i + 1}`); // replace with your mnemonic
const TON_API_URL = "https://toncenter.com/api/v2/jsonRPC";

const client = new TonClient({
    endpoint: TON_API_URL,
});

const keyPair = await mnemonicToPrivateKey(MNEMONIC);

const wallet = WalletContractV4.create({
    workchain: 0,
    publicKey: keyPair.publicKey,
});

const contract = client.open(wallet);

const dex = new DEX.v1.Router({
    tonApiClient: new TonWeb.HttpProvider(TON_API_URL),
})

const swapTxParams = await dex.buildSwapTonToJettonTxParams({
    offerAmount: toNano('1'), // swap 1 TON
    askJettonAddress: 'EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO', // for a STON
    minAskAmount: toNano('0.1'), // but not less than 0.1 STON
    proxyTonAddress: pTON.v1.address.toString(),
    userWalletAddress: wallet.address.toString(),
});

await contract.sendTransfer({
    seqno: await contract.getSeqno(),
    secretKey: keyPair.secretKey,
    messages: [internal({
        to: swapTxParams.to.toString(),
        value: BigInt(swapTxParams.gasAmount.toString()),
        body: Cell.fromBase64(TonWeb.utils.bytesToBase64(await swapTxParams.payload.toBoc())),
    })]
});

import TonWeb from "tonweb";
import { FARM } from "@ston-fi/sdk";

const farm = new FARM.v3.NftItem({
  tonApiClient: new TonWeb.HttpProvider(),
  address: "EQA18JnBVNZZ8Wz-Kn6Mc5cy9pv798Pn8tfScjKw9NLPK3U2", // Farm v3 nft address
});

// Unstake all staked funds from Farm NFT back to the owner's wallet
const txParams = farm.buildUnstakeTxParams({
  queryId: 12345,
});

// To execute the transaction, you need to send a transaction to the blockchain.
// This code will be different based on the wallet you are using to send the tx from
// logging is used for demonstration purposes
console.log({
  to: txParams.to,
  amount: txParams.gasAmount,
  payload: txParams.payload,
});

import TonWeb from "tonweb";
import TonWebMnemonic from "tonweb-mnemonic";
import { DEX, pTON } from "@ston-fi/sdk";

const MNEMONIC = Array.from({ length: 24 }, (_, i) => `your mnemonic word ${i + 1}`); // replace with your mnemonic

const tonWeb = new TonWeb();

const client = new TonWeb.HttpProvider();

const keyPair = await TonWebMnemonic.mnemonicToKeyPair(MNEMONIC);

const wallet = new tonWeb.wallet.all.v4R2(client, {
    publicKey: keyPair.publicKey,
});

const dex = new DEX.v1.Router({
    tonApiClient: client,
})

const swapTxParams = await dex.buildSwapTonToJettonTxParams({
    offerAmount: TonWeb.utils.toNano('1'), // swap 1 TON
    askJettonAddress: 'EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO', // for a STON
    minAskAmount: TonWeb.utils.toNano('0.1'), // but not less than 0.1 STON
    proxyTonAddress: pTON.v1.address.toString(),
    userWalletAddress: (await wallet.getAddress()).toString(),
});

await wallet.methods.transfer({
    secretKey: keyPair.secretKey,
    toAddress: swapTxParams.to,
    amount: swapTxParams.gasAmount,
    seqno: await wallet.methods.seqno().call() ?? 0,
    payload: swapTxParams.payload,
    sendMode: 3,
}).send();

import React from 'react';
import TonWeb from 'tonweb';
import { DEX, pTON } from '@ston-fi/sdk';
import { useTonConnectUI, useTonAddress } from '@tonconnect/ui-react';

const dex = new DEX.v1.Router({
  tonApiClient: new TonWeb.HttpProvider(),
});

export const Example = () => {
  const wallet = useTonAddress();
  const [tonConnectUI] = useTonConnectUI();

  return (
    <button
      onClick={async () => {
        const swapTxParams = await dex.buildSwapTonToJettonTxParams({
          offerAmount: TonWeb.utils.toNano('1'), // swap 1 TON
          askJettonAddress: 'EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO', // for a STON
          minAskAmount: TonWeb.utils.toNano('0.1'), // but not less than 0.1 STON
          proxyTonAddress: pTON.v1.address.toString(),
          userWalletAddress: wallet,
        });

        await tonConnectUI.sendTransaction({
          validUntil: Date.now() + 1000000,
          messages: [
            {
              address: swapTxParams.to.toString(),
              amount: swapTxParams.gasAmount.toString(),
              payload: TonWeb.utils.bytesToBase64(
                await swapTxParams.payload.toBoc(),
              ),
            },
          ],
        });
      }}
    >
      Swap 1 TON to STON
    </button>
  );
};

import TonWeb from 'tonweb';
import { Router, ROUTER_REVISION, ROUTER_REVISION_ADDRESS } from '@ston-fi/sdk';

const WALLET_ADDRESS = ''; // ! replace with your address
const JETTON0 = 'EQA2kCVNwVsil2EM2mB0SkXytxCqQjS4mttjDpnXmwG9T6bO'; // STON
const PROXY_TON = 'EQCM3B12QK1e4yZSf8GtBRT0aLMNyEsBc_DhVfRRtOEffLez'; // ProxyTON

const provider = new TonWeb.HttpProvider();

const router = new Router(provider, {
  revision: ROUTER_REVISION.V1,
  address: ROUTER_REVISION_ADDRESS.V1,
});

const tonToJettonTxParams = await router.buildSwapJettonTxParams({
  userWalletAddress: WALLET_ADDRESS,
  offerJettonAddress: JETTON0,
  offerAmount: new TonWeb.utils.BN('1000000000'),
  askJettonAddress: PROXY_TON,
  minAskAmount: new TonWeb.utils.BN('1'),
  queryId: 12345,
});

- import { Router, ROUTER_REVISION, ROUTER_REVISION_ADDRESS } from '@ston-fi/sdk';

+ import { DEX, ROUTER_REVISION, ROUTER_REVISION_ADDRESS } from '@ston-fi/sdk';

.
└── dex
    └── Router
        └── Router
            ├── RouterRevisionV1
            └── RouterRevisionV2

.
└── dex
    └── Router
        ├── RouterV1
        └── RouterV2

import { DEX, DEX_VERSION } from '@ston-fi/sdk';

DEX.v1.Router.version === DEX_VERSION.v1

- import { DEX, ROUTER_REVISION, ROUTER_REVISION_ADDRESS } from '@ston-fi/sdk';

+ import { DEX, ROUTER_REVISION_ADDRESS } from '@ston-fi/sdk';

-  const router = new Router(provider, {
-   revision: ROUTER_REVISION.V1,
+  const router = new Dex.v1.Router(provider, {
    address: ROUTER_REVISION_ADDRESS.V1,
  });

import { DEX, pTON } from '@ston-fi/sdk';

DEX.v1.Router.address; // EQB3ncyBUTjZUA5EnFKR5_EnOMI9V1tTEAAPaiU71gc4TiUt
pTON.v1.address; // EQCM3B12QK1e4yZSf8GtBRT0aLMNyEsBc_DhVfRRtOEffLez

- import { DEX, ROUTER_REVISION_ADDRESS } from '@ston-fi/sdk';
+ import { DEX } from '@ston-fi/sdk';

  const router = new Dex.v1.Router(provider, {
-  address: ROUTER_REVISION_ADDRESS.V1,
  });

-   const provider = new TonWeb.HttpProvider();

- const router = new Dex.v1.Router(provider, {
+ const router = new DEX.v1.Router({
+    tonApiClient: new TonWeb.HttpProvider(),
  });

-   const tonToJettonTxParams = await router.buildSwapJettonTxParams({

+   const tonToJettonTxParams = await router.buildSwapJettonToTonTxParams({