STON.fi SDK

https://github.com/ston-fi/sdk
Admin
TypeScript SDKs for interacting with STON.fi DEX protocols including token swaps, liquidity...
Tokens:92,676
Snippets:549
Trust Score:7.5
License:MIT
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Example — factory from API router info

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/helpers.md

Demonstrates using dexFactory and routerFactory with a RouterInfo object from @ston-fi/api. Shows how to get a contract set and a ready router instance.

```typescript
import { dexFactory, routerFactory } from "@ston-fi/sdk";
import type { RouterInfo } from "@ston-fi/api";

// Shape: { address, majorVersion, minorVersion, routerType }
const routerInfo: RouterInfo = {
  address: "EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs",
  majorVersion: 2,
  minorVersion: 2,
  routerType: "constant_product",
};

// Contract set — note Router/Pool are already the CPI-typed classes
const dexContracts = dexFactory(routerInfo);
const router = client.open(dexContracts.Router.create(routerInfo.address));
const pool = await router.getPool({ token0, token1 });

// Or a ready instance directly:
const router2 = client.open(routerFactory(routerInfo));
```

--------------------------------

### Install @ston-fi/stake-sdk with pnpm

Source: https://github.com/ston-fi/sdk/blob/main/packages/stake-sdk/README.md

Install the Stake SDK package using pnpm. Requires prior installation of @ton/ton.

```bash
pnpm install @ston-fi/stake-sdk
```

--------------------------------

### Install with pnpm

Source: https://github.com/ston-fi/sdk/blob/main/packages/sdk/README.md

Install the STON.fi SDK using the pnpm package manager. Requires the @ton/ton package to be installed first.

```bash
pnpm install @ston-fi/sdk
```

--------------------------------

### Install @ston-fi/stake-sdk with npm

Source: https://github.com/ston-fi/sdk/blob/main/packages/stake-sdk/README.md

Install the Stake SDK package using npm. Requires prior installation of @ton/ton.

```bash
npm install @ston-fi/stake-sdk
```

--------------------------------

### Install @ston-fi/stake-sdk with yarn

Source: https://github.com/ston-fi/sdk/blob/main/packages/stake-sdk/README.md

Install the Stake SDK package using yarn. Requires prior installation of @ton/ton.

```bash
yarn add @ston-fi/stake-sdk
```

--------------------------------

### Install with Yarn

Source: https://github.com/ston-fi/sdk/blob/main/packages/sdk/README.md

Install the STON.fi SDK using the Yarn package manager. Requires the @ton/ton package to be installed first.

```bash
yarn add @ston-fi/sdk
```

--------------------------------

### Install with npm

Source: https://github.com/ston-fi/sdk/blob/main/packages/sdk/README.md

Install the STON.fi SDK using the npm package manager. Requires the @ton/ton package to be installed first.

```bash
npm install @ston-fi/sdk
```

--------------------------------

### Run dev command with turbo

Source: https://github.com/ston-fi/sdk/blob/main/examples/next-js-app/README.md

Starts the development server using Turbo.

```sh
turbo dev
```

--------------------------------

### Direct add liquidity example

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/lp-account-v1.md

Example showing direct liquidity addition with a minimum LP protection. It sends a direct add liquidity transaction with specified amounts and a minimum LP to mint, catching and logging any errors.

```ts
const lpAccount = client.open(DEX.v1.LpAccount.create(lpAccountAddress));

try {
  await lpAccount.sendDirectAddLiquidity(wallet.sender(secretKey), {
    amount0: toUnits("50", 9),
    amount1: toUnits("500", 6),
    minimumLpToMint: toUnits("45", 9),
  });
} catch (error) {
  console.error("Direct add failed", error);
}
```

--------------------------------

### Install dependencies with pnpm

Source: https://github.com/ston-fi/sdk/blob/main/examples/next-js-app/README.md

Installs project dependencies using pnpm.

```sh
pnpm install
```

--------------------------------

### Client initialization example

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/client.md

Initializes a Client with a TON HTTP API endpoint and API key, then opens a DEX router contract and fetches pool data.

```typescript
import { Client } from "@ston-fi/sdk";

const client = new Client({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
  apiKey: "your-api-key",
});

const router = client.open(
  // DEX.v2_2.Router.CPI.create(...) or any other contract class
  DEX.v2_2.Router.CPI.create("EQD4..."),
);

const poolData = await router.getPoolData(router.provider);
```

--------------------------------

### Get jetton wallet data via Pool.getJettonWallet

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/core-contracts.md

Shows how to obtain a jetton wallet instance via Pool.getJettonWallet and read its data. Requires a client and a pool address. The example uses DEX.v1.Pool, but Pool v2 is also available.

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

const pool = client.open(DEX.v1.Pool.create(poolAddress));
const userJettonWallet = await pool.getJettonWallet({ ownerAddress: userAddress });
const { balance, jettonMasterAddress } = await userJettonWallet.getWalletData();
```

--------------------------------

### Assembling a raw Jetton transfer example

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/utils.md

Demonstrates how to build a Jetton transfer message using createJettonTransferMessage, which is internal and used by contracts. The example shows constructing a forward payload with beginCell and passing it to the function.

```typescript
import { beginCell } from "@ton/ton";
// createJettonTransferMessage is internal; this shows how swap bodies compose it:
// routers call it with a forward payload built by createSwapBody.

const forwardPayload = beginCell().storeUint(0x25938561, 32).endCell();

const body = createJettonTransferMessage({
  queryId: 0,
  amount: 1000000000n,
  destination: routerAddress,
  responseDestination: userAddress,
  forwardTonAmount: 175000000n,
  forwardPayload,
});
```

--------------------------------

### Refund pending liquidity example

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/lp-account-v1.md

Example showing how to refund pending liquidity from an LP account. It obtains the LP account address via the pool, checks pending amounts, and sends a refund if any are non-zero.

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

const pool = client.open(DEX.v1.Pool.create(poolAddress));
const lpAccountAddress = await pool.getLpAccountAddress({
  ownerAddress: wallet.address,
});
const lpAccount = client.open(DEX.v1.LpAccount.create(lpAccountAddress));

// Inspect pending amounts, then refund if needed
const data = await lpAccount.getLpAccountData();
if (data.amount0 > 0n || data.amount1 > 0n) {
  await lpAccount.sendRefund(wallet.sender(secretKey), {});
}
```

--------------------------------

### FARM.v3.NftMinter.getStakeTxParams

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/farm-v3.md

Example demonstrating how to stake Jettons into a Farm v3 pool with a custom owner address using the FARM.v3.NftMinter.getStakeTxParams method.

```APIDOC
## [FARM.v3.NftMinter.getStakeTxParams]

### Description
Retrieves the transaction parameters for staking Jettons into a Farm v3 pool, minting an NFT to a specified owner address.

### Method
N/A (SDK method)

### Endpoint
N/A (SDK method)

### Parameters
#### Parameters
- **userWalletAddress** (Address) - Required - The address of the user's wallet that will send the stake transaction.
- **jettonAddress** (Address) - Required - The address of the Jetton to be staked.
- **jettonAmount** (bigint) - Required - The amount of Jettons to stake, specified in base units (e.g., using `toUnits`).
- **ownerAddress** (Address) - Required - The address that will receive the minted NFT representing the stake.

### Request Example
```ts
const txParams = await minter.getStakeTxParams({
  userWalletAddress: wallet.address,
  jettonAddress: JETTON_ADDRESS,
  jettonAmount: toUnits("100", 9),
  ownerAddress: beneficiaryAddress,
});
```

### Response
#### Success Response
- **txParams** (object) - The transaction parameters object, which can be sent using a wallet sender.

#### Response Example
```ts
await wallet.sender(secretKey).send(txParams);
```
```

--------------------------------

### getExpectedOutputs

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/pool-v1.md

Gets expected output amounts for a swap.

```APIDOC
## getExpectedOutputs

### Description
Calls `get_expected_outputs` with the amount and the **router's jetton wallet** for the token to sell.

### Method
getExpectedOutputs

### Signature
```ts
public async getExpectedOutputs(
  provider: ContractProvider,
  params: {
    amount: AmountType;
    jettonWallet: AddressType;
  },
)
```

### Parameters
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `provider` | `ContractProvider` | yes | Provider |
| `amount` | `AmountType` | yes | Amount of tokens to sell |
| `jettonWallet` | `AddressType` | yes | Router's jetton wallet for the token to sell |

### Returns
| Field | Type | Description |
|-------|------|-------------|
| `jettonToReceive` | `bigint` | Expected output amount |
| `protocolFeePaid` | `bigint` | Protocol fee |
| `refFeePaid` | `bigint` | Referral fee |
```

--------------------------------

### Custom-decimal token math example

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/utils.md

Shows how to use fromUnits and toUnits with custom decimals (e.g., USDT with 6 decimals) and with the default 9 decimals.

```typescript
import { fromUnits, toUnits } from "@ston-fi/sdk";

// USDT has 6 decimals
const amount = toUnits("1.5", 6); // 1500000n
const back = fromUnits(amount, 6); // "1.5"

// Default 9 decimals
const tonUnits = toUnits("1"); // 1000000000n
console.log(fromUnits(tonUnits)); // "1"
```

--------------------------------

### FARM.v3.NftItem.getFarmingData

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/farm-v3.md

Example demonstrating how to retrieve farming data for a Farm v3 NFT item using the FARM.v3.NftItem.getFarmingData method.

```APIDOC
## [FARM.v3.NftItem.getFarmingData]

### Description
Retrieves the current farming data for a specific Farm v3 NFT item, including status, staked tokens, and owner address.

### Method
N/A (SDK method)

### Endpoint
N/A (SDK method)

### Parameters
No parameters.

### Request Example
```ts
const data = await item.getFarmingData();
```

### Response
#### Success Response
- **status** (string) - The current farming status.
- **stakedTokens** (bigint) - The amount of tokens currently staked.
- **ownerAddress** (Address) - The address of the NFT owner.

#### Response Example
```ts
console.log(data.status, data.stakedTokens, data.ownerAddress);
```
```

--------------------------------

### Direct add liquidity with min LP protection using DEX.v2_1.LpAccount

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/lp-account-v2.md

Use this example to add liquidity directly with minimum LP protection. It sends a direct add liquidity transaction and catches errors, logging 'Direct add failed' on failure.

```ts
const lpAccount = client.open(DEX.v2_1.LpAccount.create(lpAccountAddress));

try {
  await lpAccount.sendDirectAddLiquidity(wallet.sender(secretKey), {
    userWalletAddress: wallet.address,
    amount0: toUnits("25", 9),
    amount1: toUnits("250", 6),
    minimumLpToMint: toUnits("20", 9),
    excessesAddress: wallet.address,
  });
} catch (error) {
  console.error("Direct add failed", error);
}
```

--------------------------------

### FARM.v3.NftItem.sendClaimRewards

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/farm-v3.md

Example demonstrating how to claim rewards from a specific pool using the FARM.v3.NftItem.sendClaimRewards method.

```APIDOC
## [FARM.v3.NftItem.sendClaimRewards]

### Description
Sends a transaction to claim rewards from a specific pool associated with the Farm v3 NFT item.

### Method
N/A (SDK method)

### Endpoint
N/A (SDK method)

### Parameters
#### Parameters
- **sender** (Sender) - Required - The sender object used to send the transaction.
- **poolIndex** (number) - Required - The index of the pool from which to claim rewards.

### Request Example
```ts
await item.sendClaimRewards(wallet.sender(secretKey), { poolIndex: 0 });
```

### Response
#### Success Response
No explicit response body; the transaction is sent.
```

--------------------------------

### Refund with payloads using DEX.v2_2.LpAccount

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/lp-account-v2.md

Use this example to refund LP tokens with optional payloads. It creates a pool and LP account, then sends a refund with a left payload and no right payload.

```ts
import { DEX } from "@ston-fi/sdk";
import { beginCell } from "@ton/ton";

const pool = client.open(DEX.v2_2.Pool.CPI.create(poolAddress));
const lpAccountAddress = await pool.getLpAccountAddress({ ownerAddress: wallet.address });
const lpAccount = client.open(DEX.v2_2.LpAccount.create(lpAccountAddress));

const payload = beginCell().storeUint(0x1234, 32).endCell();

await lpAccount.sendRefund(wallet.sender(secretKey), {
  leftMaybePayload: payload,
  rightMaybePayload: undefined,
});
```

--------------------------------

### getSwapTonToJettonTxParams

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/pton.md

Example of swapping TON to a jetton using the pTON contract with the v2.1 router.

```APIDOC
## [TON→jetton swap via pTON (v2 router)]

### Description
This example demonstrates how to perform a TON to jetton swap using the pTON contract with the v2.1 router. It creates a router instance and a pTON instance, then calls the `getSwapTonToJettonTxParams` method to obtain transaction parameters.

### Method
`getSwapTonToJettonTxParams`

### Parameters
- **userWalletAddress** (Address) - Required - The address of the user's wallet.
- **proxyTon** (PtonV2_1) - Required - The pTON contract instance.
- **askJettonAddress** (Address) - Required - The address of the jetton to receive.
- **offerAmount** (bigint) - Required - The amount of TON to swap.
- **minAskAmount** (bigint) - Required - The minimum amount of jetton to receive.

### Request Example
```ts
import { DEX } from "@ston-fi/sdk";

const router = client.open(DEX.v2_1.Router.CPI.create(routerAddress));
const proxyTon = DEX.v2_1.pTON.create(ptonMasterAddress); // PtonV2_1

const txParams = await router.getSwapTonToJettonTxParams({
  userWalletAddress: wallet.address,
  proxyTon,
  askJettonAddress: STON_JETTON_ADDRESS,
  offerAmount: toNano("1"),
  minAskAmount: toUnits("0.4", 9),
});
```
```

--------------------------------

### getExpectedLiquidity

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/pool-v1.md

Gets expected liquidity when burning LP tokens.

```APIDOC
## getExpectedLiquidity

### Description
Calls `get_expected_liquidity`; returns expected freed liquidity when burning LP tokens.

### Method
getExpectedLiquidity

### Signature
```ts
public async getExpectedLiquidity(
  provider: ContractProvider,
  params: {
    jettonAmount: AmountType;
  },
)
```

### Parameters
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `provider` | `ContractProvider` | yes | Provider |
| `jettonAmount` | `AmountType` | yes | Amount of LP tokens to burn |

### Returns
`{ amount0: bigint; amount1: bigint }` - Expected freed liquidity.
```

--------------------------------

### Example — Claim Vault Fees

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/vault.md

Shows how to retrieve a vault from a router, check accrued fees, and send a withdraw fee transaction if the deposited amount is greater than zero.

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

const router = client.open(DEX.v2_1.Router.CPI.create(routerAddress));

const vault = await router.getVault({
  user: wallet.address,
  tokenMinter: STON_JETTON_ADDRESS,
});

const data = await vault.getVaultData();
console.log("Accrued fees:", data.depositedAmount);

if (data.depositedAmount > 0n) {
  await vault.sendWithdrawFee(wallet.sender(secretKey), {});
}
```

--------------------------------

### FarmNftItemV1 class definition, constructor, and method signatures

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/farm-v1-v2.md

Shows the FarmNftItemV1 contract class with gas constants configured for claimRewards (0.3 TON), unstake (0.4 TON), and destroy (0.05 TON). The constructor accepts an address and optional options including gasConstants. Method signatures for creating claim and unstake bodies, getting transaction params, and fetching farming data demonstrate the contract's interface. The getFarmingData method returns status, isSoulbound, stakedTokens, and claimedPerUnitNanorewards, with status meanings: 0 uninitialized, 1 active, 2 unstaked, 3 claiming.

```ts
export class FarmNftItemV1 extends Contract {
  public static readonly version: FARM_VERSION = FARM_VERSION.v1;

  public static readonly gasConstants = {
    claimRewards: toNano("0.3"),
    unstake: toNano("0.4"),
    destroy: toNano("0.05"),
  };
  ...
}
```

```ts
constructor(
  address: AddressType,
  { gasConstants, ...options }: FarmNftItemV1Options = {},
)
```

```ts
public async createClaimRewardsBody(params?: {
  queryId?: QueryIdType;
}): Promise<Cell>

public async getClaimRewardsTxParams(
  provider: ContractProvider,
  params?: {
    gasAmount?: AmountType;
    queryId?: QueryIdType;
  },
): Promise<SenderArguments>
```

```ts
public async createUnstakeBody(params?: {
  queryId?: QueryIdType;
}): Promise<Cell>

public async getUnstakeTxParams(
  provider: ContractProvider,
  params?: {
    gasAmount?: AmountType;
    queryId?: QueryIdType;
  },
): Promise<SenderArguments>
```

```ts
public async getFarmingData(provider: ContractProvider)
```

--------------------------------

### Usage example: getJettonData with DEX.v1.Pool

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/core-contracts.md

Shows how to open a pool using the STON.fi DEX v1 Pool and call getJettonData. Requires a TonClient instance and a pool address. Logs totalSupply and contentRaw to the console.

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

const client = new TonClient({ endpoint: "https://toncenter.com/api/v2/jsonRPC" });
const pool = client.open(DEX.v1.Pool.create(poolAddress));

const data = await pool.getJettonData();
console.log(data.totalSupply, data.contentRaw);
```

--------------------------------

### sendStake

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/stake-sdk.md

Example of staking 1 STON for 3 months using the StakeNftMinter contract.

```APIDOC
## [POST] sendStake

### Description
Sends a stake transaction to the StakeNftMinter contract, locking a specified amount of a jetton for a given duration.

### Method
POST

### Endpoint
StakeNftMinter.sendStake

### Parameters
#### Request Body
- **jettonAddress** (string) - Required - The address of the jetton to stake.
- **userWalletAddress** (string) - Required - The address of the user's wallet.
- **jettonAmount** (bigint) - Required - The amount of jetton to stake, in nano units.
- **durationSeconds** (number) - Required - The staking duration in seconds. The contract range is 3 to 24 months.

### Request Example
```ts
await minter.sendStake(wallet.sender(keypair.secretKey), {
  jettonAddress: STON_JETTON,
  userWalletAddress: wallet.address,
  jettonAmount: toNano("1"), // 1 STON
  durationSeconds: MONTH_IN_SECONDS * 3, // 3 months (contract range: 3–24)
});
```

### Response
No response body is returned. The transaction is sent to the blockchain.
```

--------------------------------

### Example — error handling for unsupported versions

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/helpers.md

Shows how to catch errors thrown by dexFactory for unsupported versions or router types. The error messages are 'Unsupported dex version: 3.0' and 'Unsupported router type: unknown-type'.

```typescript
import { dexFactory } from "@ston-fi/sdk";

try {
  dexFactory({ majorVersion: 3, minorVersion: 0 });
} catch (error) {
  // Error: "Unsupported dex version: 3.0"
  console.error(error);
}

try {
  dexFactory({
    majorVersion: 2,
    minorVersion: 2,
    routerType: "unknown-type",
  });
} catch (error) {
  // Error: "Unsupported router type: unknown-type"
  console.error(error);
}
```

--------------------------------

### FARM.v3.NftItem.getUnstakeTxParams

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/farm-v3.md

Example demonstrating how to get transaction parameters for unstaking from a Farm v3 NFT item using the FARM.v3.NftItem.getUnstakeTxParams method.

```APIDOC
## [FARM.v3.NftItem.getUnstakeTxParams]

### Description
Retrieves the transaction parameters for unstaking tokens from a Farm v3 NFT item.

### Method
N/A (SDK method)

### Endpoint
N/A (SDK method)

### Parameters
No parameters.

### Request Example
```ts
const unstakeTx = await item.getUnstakeTxParams();
```

### Response
#### Success Response
- **unstakeTx** (object) - The transaction parameters object, containing `to`, `value`, and `body` fields.

#### Response Example
```ts
await tonConnectUI.sendTransaction({
  validUntil: Math.floor(Date.now() / 1000) + 300,
  messages: [{
    address: unstakeTx.to.toString(),
    amount: unstakeTx.value.toString(),
    payload: unstakeTx.body?.toBoc().toString("base64"),
  }],
});
```
```

--------------------------------

### Constructor

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/lp-account-v2.md

Creates an instance of LpAccountV2_1 or LpAccountV2_2 with the given address and optional gas constants.

```APIDOC
## Constructor

### Description
Creates an instance of LpAccountV2_1 or LpAccountV2_2 with the given address and optional gas constants.

### Method
constructor

### Parameters
- `address` (AddressType) - Required - LpAccount address (from `Pool.getLpAccountAddress`)
- `gasConstants` (Partial<typeof LpAccountV2_1.gasConstants>) - Optional - Gas overrides. Default: `refund` 0.8 TON, `directAddLp` 0.3 TON, `resetGas` 0.02 TON

### Request Example
```ts
const lpAccount = new LpAccountV2_1(address, { gasConstants: { refund: toNano("0.8") } });
```
```

--------------------------------

### constructor

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/lp-account-v1.md

Creates a new LpAccountV1 instance with the given address and optional gas constants and contract options.

```APIDOC
## constructor

### Description
Creates a new LpAccountV1 instance.

### Signature
```ts
constructor(
  address: AddressType,
  { gasConstants, ...options }: LpAccountV1Options = {},
)
```

### Parameters
- **address** (AddressType) - Required - LpAccount address (obtain via `Pool.getLpAccountAddress`)
- **gasConstants** (Partial<typeof LpAccountV1.gasConstants>) - Optional - Overrides for `refund`/`directAddLp`/`resetGas` (all `0.3` TON)
- **options** (ContractOptions) - Optional - Base options
```

--------------------------------

### DEX.v2_2.Router.CPI.create

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/configuration.md

Shows how to create a router instance with custom gas and deadline settings.

```APIDOC
## [DEX.v2_2.Router.CPI.create] [routerAddress, options]

### Description
Creates a router instance with custom gas constants and transaction deadline overrides. This is used to configure the router before calling transaction parameter methods.

### Method
create

### Endpoint
DEX.v2_2.Router.CPI.create(routerAddress, options)

### Parameters
#### Constructor Parameters
- **routerAddress** (string) - Required - The address of the router contract.
- **options** (object) - Optional - Configuration options.
  - **gasConstants** (object) - Optional - Gas constants overrides.
    - **swapJettonToJetton** (object) - Optional - Gas settings for swapJettonToJetton operation.
      - **gasAmount** (AmountType) - Optional - The gas amount for the operation.
  - **txDeadline** (number) - Optional - Transaction deadline in seconds (default is 15 minutes).

### Request Example
```ts
const router = client.open(
  DEX.v2_2.Router.CPI.create(routerAddress, {
    gasConstants: {
      swapJettonToJetton: { gasAmount: toNano("0.5") },
    },
    txDeadline: 5 * 60, // 5 minutes instead of the default 15
  }),
);
```

### Response
Returns a router instance that can be used to call transaction parameter methods.

```

--------------------------------

### getJettonWallet

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/pool-v1.md

Gets the JettonWallet instance for an owner.

```APIDOC
## getJettonWallet

### Description
Returns a `JettonWallet` instance at the LP wallet address of `ownerAddress`.

### Method
getJettonWallet

### Signature
```ts
public async getJettonWallet(
  provider: ContractProvider,
  params: { ownerAddress: AddressType },
)
```

### Parameters
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `provider` | `ContractProvider` | yes | Provider |
| `ownerAddress` | `AddressType` | yes | Owner address |

### Returns
`Promise<JettonWallet>` - A `JettonWallet` instance.
```

--------------------------------

### getLpAccount

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/pool-v1.md

Gets the LP account instance for an owner.

```APIDOC
## getLpAccount

### Description
Returns an `LpAccountV1` instance via `LpAccountV1.create(getLpAccountAddress(...))`.

### Method
getLpAccount

### Signature
```ts
public async getLpAccount(
  provider: ContractProvider,
  params: { ownerAddress: AddressType },
)
```

### Parameters
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `provider` | `ContractProvider` | yes | Provider |
| `ownerAddress` | `AddressType` | yes | Owner address |

### Returns
`Promise<LpAccountV1>` - An `LpAccountV1` instance.
```

--------------------------------

### getLpAccountAddress

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/pool-v1.md

Gets the LP account address for an owner.

```APIDOC
## getLpAccountAddress

### Description
Calls `get_lp_account_address`.

### Method
getLpAccountAddress

### Signature
```ts
public async getLpAccountAddress(
  provider: ContractProvider,
  params: { ownerAddress: AddressType },
)
```

### Parameters
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `provider` | `ContractProvider` | yes | Provider |
| `ownerAddress` | `AddressType` | yes | Owner address |

### Returns
`Promise<Address>` - The LP account address.
```

--------------------------------

### constructor

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/stake-sdk.md

Initializes a new StakeNftMinter instance with the given address and optional gas constants.

```APIDOC
## Constructor

### Description
Creates a new StakeNftMinter instance.

### Signature
```ts
constructor(
  address: AddressType,
  { gasConstants, ...options }: StakeNftMinterOptions = {},
)
```

### Parameters
- **address** (AddressType) - Required - Stake minter address
- **gasConstants** (Partial<typeof StakeNftMinter.gasConstants>) - Optional - Gas overrides. Default: `stake` 0.4 TON, `stakeForward` 0.3 TON
```

--------------------------------

### Catch UnmatchedPtonVersion by message

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/errors.md

Example of catching an UnmatchedPtonVersion error. Because the class is not exported from the package root, the catch is performed by checking the error message contains "does not match the expected version". The example illustrates a v1 pTON used on a v2 router, which triggers the error.

```ts
import { DEX } from "@ston-fi/sdk";
import { UnmatchedPtonVersion } from "@ston-fi/sdk"; // NOT exported from package root

// The class is not re-exported at the package entry, so catch by the
// distinctive message or by prototype detection on the base Error.
try {
  await router.getSwapTonToJettonTxParams({
    userWalletAddress: wallet.address,
    proxyTon: DEX.v1.pTON.create(), // v1 on a v2 router
    askJettonAddress: USDT_JETTON,
    offerAmount: toNano("1"),
    minAskAmount: toUnits("5", 6),
  });
} catch (error) {
  if (error instanceof Error && error.message.includes("does not match the expected version")) {
    console.error("pTON version mismatch", error);
  }
}
```

--------------------------------

### constructor(address, options)

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/router-v1.md

Creates a new RouterV1 instance. The address defaults to the mainnet v1 router address, and gas constants can be overridden per operation.

```APIDOC
## [CONSTRUCTOR] constructor(address, options)

### Description
Creates a new RouterV1 instance. The address defaults to the mainnet v1 router address, and gas constants can be overridden per operation.

### Method
CONSTRUCTOR

### Endpoint
constructor(address, options)

### Parameters
#### Path Parameters
- **address** (AddressType) - Optional - Router contract address. Defaults to static `RouterV1.address` (mainnet v1 router).

#### Request Body
- **gasConstants** (Partial<typeof RouterV1.gasConstants>) - Optional - Per-operation gas overrides, merged over the static defaults.
- **options** (ContractOptions) - Optional - Base options (currently empty).

### Request Example
```ts
const router = new RouterV1();
```

### Response
#### Success Response (200)
- **router** (RouterV1) - The created RouterV1 instance.

#### Response Example
```ts
const router = new RouterV1();
```
```

--------------------------------

### getExpectedTokens

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/pool-v1.md

Gets estimated LP tokens for two input amounts.

```APIDOC
## getExpectedTokens

### Description
Calls `get_expected_tokens`; returns estimated LP tokens minted for two input amounts.

### Method
getExpectedTokens

### Signature
```ts
public async getExpectedTokens(
  provider: ContractProvider,
  params: {
    amount0: AmountType;
    amount1: AmountType;
  },
)
```

### Parameters
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `provider` | `ContractProvider` | yes | Provider |
| `amount0` | `AmountType` | yes | Amount of token 0 |
| `amount1` | `AmountType` | yes | Amount of token 1 |

### Returns
`Promise<bigint>` - Estimated LP tokens minted.
```

--------------------------------

### Usage with SDK contracts

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/client.md

Shows how to use the SDK with the override. The client.open method provides a ContractProvider to contract methods, and the override automatically handles the get_wallet_address call on the minter.

```ts
import { Client, DEX } from "@ston-fi/sdk";

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

// `open` gives every contract method a ContractProvider as first argument.
// The override triggers automatically on the minter's get_wallet_address call.
const router = client.open(DEX.v2_1.Router.CPI.create(routerAddress));

const swapTx = await router.getSwapJettonToJettonTxParams({
  userWalletAddress: walletAddress,
  offerJettonAddress: STON_JETTON,
  askJettonAddress: USDT_JETTON,
  offerAmount: toUnits("10", 9),
  minAskAmount: toUnits("5", 6),
});
```

--------------------------------

### new Client(options)

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/client.md

Creates a new Client instance with the provided options. The options include standard TonClient parameters (endpoint, apiKey, timeout, pingInterval) and an optional stonApiClient for STON.fi REST API.

```APIDOC
## Constructor: new Client(options)

### Description
Creates a new Client instance that extends TonClient. It accepts standard TonClient parameters and an optional stonApiClient for routing get_wallet_address calls through the STON.fi REST API.

### Signature
```ts
constructor(
  options: ConstructorParameters<typeof TonClient>[0] & {
    stonApiClient?: StonApiClient;
  },
)
```

### Parameters
- **endpoint** (string) - Required - TON HTTP API endpoint, e.g. `https://toncenter.com/api/v2/jsonRPC`.
- **apiKey** (string) - Optional - API key for the endpoint provider.
- **timeout** (number) - Optional - Request timeout in ms (default: `30000`).
- **pingInterval** (number) - Optional - Reconnect interval for WS endpoints (default: `90000`).
- **stonApiClient** (StonApiClient) - Optional - Client for the STON.fi REST API; defaults to `new StonApiClient()`.

### Example
```ts
import { Client } from "@ston-fi/sdk";

const client = new Client({
  endpoint: "https://toncenter.com/api/v2/jsonRPC",
  apiKey: "your-api-key",
});

const router = client.open(
  // DEX.v2_2.Router.CPI.create(...) or any other contract class
  DEX.v2_2.Router.CPI.create("EQD4..."),
);

const poolData = await router.getPoolData(router.provider);
```
```

--------------------------------

### sendTonTransfer

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/pton.md

Example of sending a direct TON transfer through the pTON contract with error handling.

```APIDOC
## [Direct pTON transfer with error handling]

### Description
This example demonstrates how to send a direct TON transfer through the pTON contract. It opens the pTON contract and calls the `sendTonTransfer` method, with error handling to catch any failures.

### Method
`sendTonTransfer`

### Parameters
- **tonAmount** (bigint) - Required - The amount of TON to transfer.
- **destinationAddress** (Address) - Required - The address to receive the TON.
- **refundAddress** (Address) - Required - The address to receive any refunds.
- **forwardTonAmount** (bigint) - Required - The amount of TON to forward.

### Request Example
```ts
import { DEX } from "@ston-fi/sdk";

const pton = client.open(DEX.v2_1.pTON.create(ptonMasterAddress));

try {
  await pton.sendTonTransfer(wallet.sender(secretKey), {
    tonAmount: toNano("0.5"),
    destinationAddress: receiverAddress,
    refundAddress: wallet.address,
    forwardTonAmount: toNano("0.05"),
  });
} catch (error) {
  console.error("Transfer failed", error);
}
```
```

--------------------------------

### constructor

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/farm-v1-v2.md

Creates a new FarmNftItemV1 contract instance with the given address and optional gas constants and other options.

```APIDOC
## Constructor

### Description
Creates a new FarmNftItemV1 contract instance.

### Signature
```ts
constructor(
  address: AddressType,
  { gasConstants, ...options }: FarmNftItemV1Options = {},
)
```

### Parameters
- **address** (AddressType) - Required - The address of the farming NFT contract.
- **options** (FarmNftItemV1Options) - Optional - Configuration options, including `gasConstants` for overriding default gas amounts.
```

--------------------------------

### getUnstakeTxParams

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/stake-sdk.md

Example of unstaking via TonConnect with error handling, using the StakeNftItem contract.

```APIDOC
## [GET] getUnstakeTxParams

### Description
Retrieves the transaction parameters needed to unstake a stake NFT. This method returns the destination address, amount, and payload required to construct an unstake transaction.

### Method
GET

### Endpoint
StakeNftItem.getUnstakeTxParams

### Parameters
No parameters are required.

### Request Example
```ts
const params = await stakeNft.getUnstakeTxParams();
```

### Response
#### Success Response (200)
- **to** (Address) - The destination address for the unstake transaction.
- **value** (bigint) - The amount of TON to send with the transaction.
- **body** (Cell) - The payload of the transaction, encoded as a base64 string when sent.

#### Response Example
```ts
const params = await stakeNft.getUnstakeTxParams();
// params.to, params.value, params.body
```
```

--------------------------------

### PtonV1.constructor

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/pton.md

Creates a new PtonV1 instance. The constructor accepts an optional address and gas constants for customization.

```APIDOC
## PtonV1.constructor

### Description
Creates a new PtonV1 instance. The constructor accepts an optional address and gas constants for customization.

### Parameters
- `address` (AddressType) - Optional - Default: static mainnet pTON v1 address - pTON contract address
- `gasConstants` (Partial<typeof PtonV1.gasConstants>) - Optional - Default: { deployWallet: 1.05 TON } - Gas overrides
```

--------------------------------

### PtonV2_1

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/pton.md

Documentation for the PtonV2_1 class, including constructor, static properties, and methods for building and sending TON transfer and deploy wallet transactions.

```APIDOC
## Class: PtonV2_1

### Description
PtonV2_1 extends PtonV1 and implements AbstractPton. It represents the pTON v2.1 contract and provides methods to build and send TON transfer and deploy wallet transactions.

### Constructor

```ts
constructor(
  address: AddressType,
  { gasConstants, ...options }: PtonV2_1Options = {},
)
```

#### Parameters
- **address** (AddressType) - Required - pTON v2.1 contract address (e.g. `simulation.router.ptonMasterAddress` from `@ston-fi/api`)
- **gasConstants** (Partial<typeof PtonV2_1.gasConstants>) - Optional - Gas overrides. Default: `{ tonTransfer: 0.01 TON, deployWallet: 0.1 TON }`

### Static Properties

- **version** (readonly) - `pTON_VERSION.v2_1`
- **gasConstants** (readonly) - `{ tonTransfer: toNano("0.01"), deployWallet: toNano("0.1") }`

### Methods

#### `createTonTransferBody`

```ts
public async createTonTransferBody(params: {
  tonAmount: AmountType;
  refundAddress: AddressType;
  forwardPayload?: Cell;
  queryId?: QueryIdType;
}): Promise<Cell>
```

Builds the native v2 `TON_TRANSFER` body (opcode `0x01f3835d`), with a 0/1-bit flag for an optional `forwardPayload` ref. Since SDK 2.7.0 the 0 bit is set when no payload is provided (see CHANGELOG).

#### `getTonTransferTxParams` (override)

```ts
public override async getTonTransferTxParams(
  provider: ContractProvider,
  params: {
    tonAmount: AmountType;
    destinationAddress: AddressType;
    destinationWalletAddress?: AddressType;
    refundAddress: AddressType;
    forwardPayload?: Cell;
    forwardTonAmount?: AmountType;
    queryId?: QueryIdType;
  },
): Promise<SenderArguments>
```

Builds the native `TON_TRANSFER` body (not a Jetton transfer); `value = tonAmount + forwardTonAmount + gasConstants.tonTransfer` (`0.01` TON).

#### `createDeployWalletBody` (override)

```ts
public override async createDeployWalletBody(params: {
  ownerAddress: AddressType;
  excessAddress: AddressType;
  queryId?: QueryIdType;
}): Promise<Cell>
```

Additionally stores an `excessAddress` (required in `getDeployWalletTxParams`), and the deploy default gas is `0.1` TON.

#### `sendTonTransfer` (override)

Inherited from PtonV1, overridden to use the v2.1 transfer body.

#### `getDeployWalletTxParams` / `sendDeployWallet` (override)

Inherited from PtonV1, overridden to use the v2.1 deploy body with `excessAddress`.
```

--------------------------------

### getSwapJettonToJettonTxParams

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/configuration.md

Shows how to get swap transaction parameters with per-call gas and deadline overrides.

```APIDOC
## [getSwapJettonToJettonTxParams] [params]

### Description
Retrieves transaction parameters for swapping one jetton to another. Accepts per-call overrides for gas amounts and other parameters.

### Method
getSwapJettonToJettonTxParams

### Endpoint
router.getSwapJettonToJettonTxParams(params)

### Parameters
#### Request Body
- **userWalletAddress** (string) - Required - The address of the user's wallet.
- **offerJettonAddress** (string) - Required - The address of the jetton being offered.
- **askJettonAddress** (string) - Required - The address of the jetton being asked for.
- **offerAmount** (AmountType) - Required - The amount of the offer jetton.
- **minAskAmount** (AmountType) - Required - The minimum amount of the ask jetton to receive.
- **gasAmount** (AmountType) - Optional - Per-call override for gas amount.
- **forwardGasAmount** (AmountType) - Optional - Per-call override for forward gas amount.
- **queryId** (type) - Optional - Custom query ID.
- **deadline** (type) - Optional - Deadline for the transaction (v2 bodies).
- **transferExcessAddress** (string) - Optional - Address override for excess transfer.
- **refundAddress** (string) - Optional - Address override for refunds.
- **excessesAddress** (string) - Optional - Address override for excesses.

### Request Example
```ts
const txParams = await router.getSwapJettonToJettonTxParams({
  userWalletAddress: wallet.address,
  offerJettonAddress: STON_JETTON,
  askJettonAddress: USDT_JETTON,
  offerAmount: toUnits("10", 9),
  minAskAmount: toUnits("5", 6),
  // per-call override wins over the constructor override:
  gasAmount: toNano("1"),
  forwardGasAmount: toNano("0.3"),
});
```

### Response
Returns transaction parameters for the swap.

```

--------------------------------

### getLpAccountAddress / getLpAccount

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/pool-v2.md

Methods to get the LP account address or LP account object for an owner.

```APIDOC
## getLpAccountAddress / getLpAccount

### Description
Retrieves the LP account address or the LP account object for a given owner. `getLpAccount` returns `LpAccountV2_1.create(...)` (or `LpAccountV2_2` on v2_2 pools).

### Method
- `getLpAccountAddress` (async)
- `getLpAccount` (async)

### Parameters
- `provider` (`ContractProvider`) - Required - Provider
- `params` (object) - Required
  - `ownerAddress` (`AddressType`) - Required - Owner address

### Request Example
```ts
const lpAccountAddress = await pool.getLpAccountAddress(provider, { ownerAddress: 'EQ...' });
const lpAccount = await pool.getLpAccount(provider, { ownerAddress: 'EQ...' });
```

### Response
- `getLpAccountAddress` returns `Promise<Address>`
- `getLpAccount` returns `Promise<LpAccountV2_1>` (or `LpAccountV2_2` on v2_2 pools)
```

--------------------------------

### getFarmingData

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/farm-v1-v2.md

Get the farming state of a Farm v1 NFT item, including the status used to determine if rewards can be claimed.

```APIDOC
## [GET] getFarmingData

### Description
Retrieves the current farming state of a Farm v1 NFT item, including the status and reward information.

### Method
GET

### Endpoint
`FARM.v1.NftItem.getFarmingData`

### Parameters
No parameters are documented.

### Request Example
```ts
import { FARM } from "@ston-fi/sdk";

const item = client.open(FARM.v1.NftItem.create(farmNftAddress));

const state = await item.getFarmingData();
```

### Response
#### Success Response (200)
- **status** (number) - The current farming status. A value of `>= 1` indicates that rewards are available to claim.

#### Response Example
```ts
const state = await item.getFarmingData();
if (state.status >= 1) {
  // rewards are available
}
```
```

--------------------------------

### routerFactory internal logic

Source: https://github.com/ston-fi/sdk/blob/main/_autodocs/api-reference/helpers.md

Shows the internal implementation of routerFactory, which uses dexFactory to get the Router class and then creates an instance with the provided address.

```typescript
const { Router } = dexFactory(routerInfo);
return Router.create(routerInfo.address);
```
Tokens:
Raw