# Reference (v1)

## Router

#### `address`

Address of the Router contract

#### `gasConstants`

### Getters

#### `getPoolAddress`

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name     | Type                | Description                                         |
| -------- | ------------------- | --------------------------------------------------- |
| `token0` | `Address \| string` | The address of the router's wallet of first Jetton  |
| `token1` | `Address \| string` | The address of the router's wallet of second Jetton |

**Result**

Returns an address of a pool for a specified pair of assets.

#### `getPoolAddressByJettonMinters`

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name     | Type                | Description                                           |
| -------- | ------------------- | ----------------------------------------------------- |
| `token0` | `Address \| string` | The address of the first pool Jetton `Minter` wallet  |
| `token1` | `Address \| string` | The address of the second pool Jetton `Minter` wallet |

**Result**

Returns an address of a pool for a specified pair of assets.

#### `getPool`

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name     | Type                | Description                                           |
| -------- | ------------------- | ----------------------------------------------------- |
| `token0` | `Address \| string` | The address of the first pool Jetton `Minter` wallet  |
| `token1` | `Address \| string` | The address of the second pool Jetton `Minter` wallet |

**Result**

Returns an instance of `PoolV1` with specified Jetton token addresses.

#### `getRouterData`

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

**Result**

Returns structure containing current state of the router.

| Name                 | Type      | Description                                                                                                      |
| -------------------- | --------- | ---------------------------------------------------------------------------------------------------------------- |
| `isLocked`           | `boolean` | true if `transfer_notification` operations are locked (`swap`, `provide_lp`)                                     |
| `adminAddress`       | `Address` | Address of contract's admin account                                                                              |
| `tempUpgrade`        | `Cell`    | A structure describing state of contract's code & admin upgrade; zero values indicate that no upgrade is pending |
| `poolCode`           | `Cell`    | Code of the router's liquidity pool contract                                                                     |
| `jettonLpWalletCode` | `Cell`    | Code of lp wallet contract                                                                                       |
| `lpAccountCode`      | `Cell`    | Code of lp account contract                                                                                      |

### Operations

#### `createSwapBody`

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

| Name                     | Type                             | Description                                              |
| ------------------------ | -------------------------------- | -------------------------------------------------------- |
| `userWalletAddress`      | `Address \| string`              | User's address                                           |
| `minAskAmount`           | `bigint \| number \| string`     | Minimum amount of tokens received (in basic token units) |
| `askJettonWalletAddress` | `Address \| string`              | Jetton router's wallet address of tokens to be received  |
| `referralAddress`        | `Address \| string \| undefined` | referral address                                         |

#### `getSwapJettonToJettonTxParams`

Build all data required to execute a jetton to jetton `swap` transaction

```typescript
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>
```

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name                 | Type                                      | Description                                                    |
| -------------------- | ----------------------------------------- | -------------------------------------------------------------- |
| `userWalletAddress`  | `Address \| string`                       | User's address                                                 |
| `offerJettonAddress` | `Address \| string`                       | Jetton `Minter` address of a token to be swapped               |
| `askJettonAddress`   | `Address \| string`                       | Jetton `Minter` address of a token to be received              |
| `offerAmount`        | `bigint \| number \| string`              | Amount of tokens to be swapped (in basic token units)          |
| `minAskAmount`       | `bigint \| number \| string`              | Minimum amount of tokens to be received (in basic token units) |
| `referralAddress`    | `Address \| string \| undefined`          | Referral address                                               |
| `gasAmount`          | `bigint \| number \| string \| undefined` | Transaction gas                                                |
| `forwardGasAmount`   | `bigint \| number \| string \| undefined` | Forward amount of gas for the next transaction (in nanoTons)   |
| `queryId`            | `bigint \| number \| undefined`           | Query id                                                       |

**Result**

| Name    | Type                        | Description                                                 |
| ------- | --------------------------- | ----------------------------------------------------------- |
| `to`    | `Address`                   | Address of the router's Jetton wallet for the swapped token |
| `value` | `bigint`                    | Recommended amount of TON (in nanoTons) sent as gas         |
| `body`  | `Cell \| null \| undefined` | Optional `Cell` with data to be send                        |

#### `sendSwapJettonToJetton`

#### `getSwapJettonToTonTxParams`

Build all data required to execute a jetton to ton `swap` transaction

```typescript
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>
```

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name                 | Type                                      | Description                                                    |
| -------------------- | ----------------------------------------- | -------------------------------------------------------------- |
| `userWalletAddress`  | `Address \| string`                       | User's address                                                 |
| `offerJettonAddress` | `Address \| string`                       | Jetton `Minter` address of a token to be swapped               |
| `proxyTon`           | `PtonV1`                                  | instance of pTON contract                                      |
| `offerAmount`        | `bigint \| number \| string`              | Amount of tokens to be swapped (in basic token units)          |
| `minAskAmount`       | `bigint \| number \| string`              | Minimum amount of tokens to be received (in basic token units) |
| `referralAddress`    | `Address \| string \| undefined`          | Referral address                                               |
| `gasAmount`          | `bigint \| number \| string \| undefined` | Transaction gas                                                |
| `forwardGasAmount`   | `bigint \| number \| string \| undefined` | Forward amount of gas for the next transaction (in nanoTons)   |
| `queryId`            | `bigint \| number \| undefined`           | Query id                                                       |

**Result**

| Name    | Type                        | Description                                                 |
| ------- | --------------------------- | ----------------------------------------------------------- |
| `to`    | `Address`                   | Address of the router's Jetton wallet for the swapped token |
| `value` | `bigint`                    | Recommended amount of TON (in nanoTons) sent as gas         |
| `body`  | `Cell \| null \| undefined` | Optional `Cell` with data to be send                        |

#### `sendSwapJettonToTon`

#### `getSwapTonToJettonTxParams`

Build all data required to execute a ton to jetton `swap` transaction

```typescript
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>
```

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name                | Type                                      | Description                                                    |
| ------------------- | ----------------------------------------- | -------------------------------------------------------------- |
| `userWalletAddress` | `Address \| string`                       | User's address                                                 |
| `proxyTon`          | `PtonV1`                                  | instance of pTON contract                                      |
| `askJettonAddress`  | `Address \| string`                       | Jetton `Minter` address of a token to be received              |
| `offerAmount`       | `bigint \| number \| string`              | Amount of tokens to be swapped (in basic token units)          |
| `minAskAmount`      | `bigint \| number \| string`              | Minimum amount of tokens to be received (in basic token units) |
| `referralAddress`   | `Address \| string \| undefined`          | Referral address                                               |
| `forwardGasAmount`  | `bigint \| number \| string \| undefined` | Forward amount of gas for the next transaction (in nanoTons)   |
| `queryId`           | `bigint \| number \| undefined`           | Query id                                                       |

**Result**

| Name    | Type                        | Description                                                 |
| ------- | --------------------------- | ----------------------------------------------------------- |
| `to`    | `Address`                   | Address of the router's Jetton wallet for the swapped token |
| `value` | `bigint`                    | Recommended amount of TON (in nanoTons) sent as gas         |
| `body`  | `Cell \| null \| undefined` | Optional `Cell` with data to be send                        |

#### `sendSwapTonToJetton`

#### `createProvideLiquidityBody`

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

| Name                  | Type                         | Description                                                       |
| --------------------- | ---------------------------- | ----------------------------------------------------------------- |
| `routerWalletAddress` | `Address \| string`          | Address of the router's Jetton token wallet                       |
| `minLpOut`            | `bigint \| number \| string` | Minimum amount of created liquidity tokens (in basic token units) |

#### `getProvideLiquidityJettonTxParams`

Collect all data required to execute a jetton `provide_lp` transaction

```typescript
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>
```

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name                | Type                                      | Description                                                                     |
| ------------------- | ----------------------------------------- | ------------------------------------------------------------------------------- |
| `userWalletAddress` | `Address \| string`                       | User's address                                                                  |
| `sendTokenAddress`  | `Address \| string`                       | Address of the first Jetton token or a proxy ton contract                       |
| `otherTokenAddress` | `Address \| string`                       | Address of the second Jetton token                                              |
| `sendAmount`        | `bigint \| number \| string`              | Amount of the first/second tokens deposited as liquidity (in basic token units) |
| `minLpOut`          | `bigint \| number \| string`              | Minimum amount of created liquidity tokens (in basic token units)               |
| `gasAmount`         | `bigint \| number \| string \| undefined` | Transaction gas                                                                 |
| `forwardGasAmount`  | `bigint \| number \| string \| undefined` | Forward amount of gas for the next transaction (in nanoTons)                    |
| `queryId`           | `bigint \| number \| undefined`           | Query id                                                                        |

**Result**

| Name    | Type                        | Description                                                 |
| ------- | --------------------------- | ----------------------------------------------------------- |
| `to`    | `Address`                   | Address of the router's Jetton wallet for the swapped token |
| `value` | `bigint`                    | Recommended amount of TON (in nanoTons) sent as gas         |
| `body`  | `Cell \| null \| undefined` | Optional `Cell` with data to be send                        |

#### `sendProvideLiquidityJetton`

#### `getProvideLiquidityTonTxParams`

Collect all data required to execute a proxy ton `provide_lp` transaction

```typescript
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>
```

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name                | Type                                      | Description                                                                     |
| ------------------- | ----------------------------------------- | ------------------------------------------------------------------------------- |
| `userWalletAddress` | `Address \| string`                       | User's address                                                                  |
| `proxyTon`          | `PtonV1`                                  | instance of pTON contract                                                       |
| `otherTokenAddress` | `Address \| string`                       | Address of the second Jetton token                                              |
| `sendAmount`        | `bigint \| number \| string`              | Amount of the first/second tokens deposited as liquidity (in basic token units) |
| `minLpOut`          | `bigint \| number \| string`              | Minimum amount of created liquidity tokens (in basic token units)               |
| `forwardGasAmount`  | `bigint \| number \| string \| undefined` | Forward amount of gas for the next transaction (in nanoTons)                    |
| `queryId`           | `bigint \| number \| undefined`           | Query id                                                                        |

**Result**

| Name    | Type                        | Description                                                 |
| ------- | --------------------------- | ----------------------------------------------------------- |
| `to`    | `Address`                   | Address of the router's Jetton wallet for the swapped token |
| `value` | `bigint`                    | Recommended amount of TON (in nanoTons) sent as gas         |
| `body`  | `Cell \| null \| undefined` | Optional `Cell` with data to be send                        |

#### `sendProvideLiquidityTon`

## Pool

#### `address`

Address of the Pool contract

#### `gasConstants`

### Getters

#### `getPoolData`

```typescript
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;
}>
```

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

**Result**

Returns structure containing current state of the pool.

| Name                         | Type      | Description                                                                  |
| ---------------------------- | --------- | ---------------------------------------------------------------------------- |
| `reserve0`                   | `bigint`  | Amount of the first token (in basic token units)                             |
| `reserve1`                   | `bigint`  | Amount of the second token (in basic token units)                            |
| `token0WalletAddress`        | `Address` | Address of the first Jetton token                                            |
| `token1WalletAddress`        | `Address` | Address of the second Jetton token                                           |
| `lpFee`                      | `bigint`  | Liquidity pool fee value                                                     |
| `protocolFee`                | `bigint`  | Protocol fee                                                                 |
| `refFee`                     | `bigint`  | Referral fee                                                                 |
| `protocolFeeAddress`         | `Address` | Address for receiving protocol fees                                          |
| `collectedToken0ProtocolFee` | `bigint`  | Amount of collected protocol fees of the first token (in basic token units)  |
| `collectedToken1ProtocolFee` | `bigint`  | Amount of collected protocol fees of the second token (in basic token units) |

Notes:

* fee ratio is the value of fee divided by `FEE_DIVIDER` (10000); so a fee of 1% has a value of 100

#### `getExpectedOutputs`

Estimate expected result of the amount of jettonWallet tokens swapped to the other type of tokens of the pool

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name           | Type                         | Description                                                                     |
| -------------- | ---------------------------- | ------------------------------------------------------------------------------- |
| `amount`       | `bigint \| number \| string` | Amount of tokens to swap (in basic token units)                                 |
| `jettonWallet` | `Address \| string`          | Token Jetton address (must be equal to one of the Jetton addresses of the pool) |

**Result**

Returns structure with expected result of a token swap

| Name              | Type     | Description                                                 |
| ----------------- | -------- | ----------------------------------------------------------- |
| `jettonToReceive` | `bigint` | Amount of tokens received (in basic token units)            |
| `protocolFeePaid` | `bigint` | Amount tokens paid for protocol fees (in basic token units) |
| `refFeePaid`      | `bigint` | Amount tokens paid for referral fees (in basic token units) |

#### `getExpectedTokens`

Estimate an expected amount of lp tokens minted when providing liquidity.

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name      | Type                         | Description                                                   |
| --------- | ---------------------------- | ------------------------------------------------------------- |
| `amount0` | `bigint \| number \| string` | Amount of tokens for the first Jetton (in basic token units)  |
| `amount1` | `bigint \| number \| string` | Amount of tokens for the second Jetton (in basic token units) |

**Result**

Returns an estimated amount of liquidity tokens to be minted

#### `getExpectedLiquidity`

Estimate expected liquidity freed upon burning liquidity tokens.

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name           | Type                         | Description                                       |
| -------------- | ---------------------------- | ------------------------------------------------- |
| `jettonAmount` | `bigint \| number \| string` | Amount of liquidity tokens (in basic token units) |

**Result**

Returns structure with expected freed liquidity

| Name      | Type     | Description                                                   |
| --------- | -------- | ------------------------------------------------------------- |
| `amount0` | `bigint` | Amount of tokens for the first Jetton (in basic token units)  |
| `amount1` | `bigint` | Amount of tokens for the second Jetton (in basic token units) |

#### `getLpAccountAddress`

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name           | Type                | Description       |
| -------------- | ------------------- | ----------------- |
| `ownerAddress` | `Address \| string` | Address of a user |

**Result**

Function `getLpAccountAddress` returns the lp account address of a user

#### `getLpAccount`

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name           | Type                | Description       |
| -------------- | ------------------- | ----------------- |
| `ownerAddress` | `Address \| string` | Address of a user |

**Result**

returns an instance of `LpAccountV1`

#### `getJettonData`

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

**Result**

Returns a structure with Jetton data

| Name               | Type      | Description                               |
| ------------------ | --------- | ----------------------------------------- |
| `totalSupply`      | `bigint`  | Total token supply (in basic token units) |
| `isMintable`       | `boolean` | If mintable                               |
| `adminAddress`     | `Address` | Admin address                             |
| `jettonContentUri` | `string`  | Offchain uri with Jetton data             |
| `jettonWalletCode` | `Cell`    | Code of the lp Jetton wallet              |

#### `getWalletAddress`

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

**Arguments**

| Name           | Type                | Description                               |
| -------------- | ------------------- | ----------------------------------------- |
| `provider`     | `ContractProvider`  | Instance of `@ton/core` contract provider |
| `ownerAddress` | `Address \| string` | Address of a user                         |

**Result**

returns a calculated lp wallet address of a user

#### `getJettonWallet`

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

**Arguments**

| Name           | Type                | Description       |
| -------------- | ------------------- | ----------------- |
| `ownerAddress` | `Address \| string` | Address of a user |

| Name           | Type                | Description       |
| -------------- | ------------------- | ----------------- |
| `ownerAddress` | `Address \| string` | Address of a user |

**Result**

Function `getJettonWallet` returns a `JettonWallet` instance for an address returned by `getWalletAddress`

### Operations

#### `createCollectFeesBody`

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

#### `getCollectFeeTxParams`

Build all data required to execute a `collect_fees` transaction.

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name        | Type                                      | Description     |
| ----------- | ----------------------------------------- | --------------- |
| `gasAmount` | `bigint \| number \| string \| undefined` | Transaction gas |
| `queryId`   | `bigint \| number \| undefined`           | Query id        |

**Result**

| Name    | Type                        | Description                                                 |
| ------- | --------------------------- | ----------------------------------------------------------- |
| `to`    | `Address`                   | Address of the router's Jetton wallet for the swapped token |
| `value` | `bigint`                    | Recommended amount of TON (in nanoTons) sent as gas         |
| `body`  | `Cell \| null \| undefined` | Optional `Cell` with data to be send                        |

Notes:

* `param` is entirely optional
* the default value for `gasAmount` is equal to 1.1 TON

#### `sendCollectFees`

#### `createBurnBody`

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

#### `getBurnTxParams`

Build all data required to execute a `burn` transaction.

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name              | Type                                      | Description       |
| ----------------- | ----------------------------------------- | ----------------- |
| `amount`          | `bigint \| number \| string`              | Lp tokens to burn |
| `responseAddress` | `Address \| string`                       | Excesses address  |
| `gasAmount`       | `bigint \| number \| string \| undefined` | Transaction gas   |
| `queryId`         | `bigint \| number \| undefined`           | Query id          |

#### `sendBurn`

## LpAccount

#### `address`

Address of the LpAccount contract

#### `gasConstants`

### Getters

#### `getLpAccountData`

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

**Result**

Returns structure containing current state of the lp account.

| Name          | Type      | Description                                               |
| ------------- | --------- | --------------------------------------------------------- |
| `userAddress` | `Address` | Owner's address                                           |
| `poolAddress` | `Address` | Pool's address                                            |
| `amount0`     | `bigint`  | Balance of the first Jetton token (in basic token units)  |
| `amount1`     | `bigint`  | Balance of the second Jetton token (in basic token units) |

### Operations

#### `createRefundBody`

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

#### `getRefundTxParams`

Build all data required to execute a `refund_me` transaction.

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name        | Type                                      | Description     |
| ----------- | ----------------------------------------- | --------------- |
| `gasAmount` | `bigint \| number \| string \| undefined` | Transaction gas |
| `queryId`   | `bigint \| number \| undefined`           | Query id        |

**Result**

| Name    | Type                        | Description                                                 |
| ------- | --------------------------- | ----------------------------------------------------------- |
| `to`    | `Address`                   | Address of the router's Jetton wallet for the swapped token |
| `value` | `bigint`                    | Recommended amount of TON (in nanoTons) sent as gas         |
| `body`  | `Cell \| null \| undefined` | Optional `Cell` with data to be send                        |

#### `sendRefund`

#### `createDirectAddLiquidityBody`

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

#### `getDirectAddLiquidityTxParams`

Build all data required to execute a `direct_add_liquidity` transaction.

```typescript
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>
```

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name              | Type                                      | Description                                                        |
| ----------------- | ----------------------------------------- | ------------------------------------------------------------------ |
| `amount0`         | `bigint \| number \| string`              | Amount of the first Jetton tokens (in basic token units)           |
| `amount1`         | `bigint \| number \| string`              | Amount of the second Jetton tokens (in basic token units)          |
| `minimumLpToMint` | `bigint \| number \| string \| undefined` | Minimum amount of received liquidity tokens (in basic token units) |
| `gasAmount`       | `bigint \| number \| string \| undefined` | Transaction gas                                                    |
| `queryId`         | `bigint \| number \| undefined`           | Query id                                                           |

**Result**

| Name    | Type                        | Description                                                 |
| ------- | --------------------------- | ----------------------------------------------------------- |
| `to`    | `Address`                   | Address of the router's Jetton wallet for the swapped token |
| `value` | `bigint`                    | Recommended amount of TON (in nanoTons) sent as gas         |
| `body`  | `Cell \| null \| undefined` | Optional `Cell` with data to be send                        |

Notes:

* addition of liquidity will fail if a user should receive less than `minimumLpToMint` of lp tokens as a result
* the default value for `gasAmount` is equal to 0.3 TON

#### `sendDirectAddLiquidity`

#### `createResetGasBody`

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

#### `getResetGasTxParams`

Build all data required to execute a `reset_gas` transaction.

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

**Arguments**

| Name       | Type               | Description                               |
| ---------- | ------------------ | ----------------------------------------- |
| `provider` | `ContractProvider` | Instance of `@ton/core` contract provider |

| Name        | Type                                      | Description     |
| ----------- | ----------------------------------------- | --------------- |
| `gasAmount` | `bigint \| number \| string \| undefined` | Transaction gas |
| `queryId`   | `bigint \| number \| undefined`           | Query id        |

**Result**

| Name    | Type                        | Description                                                 |
| ------- | --------------------------- | ----------------------------------------------------------- |
| `to`    | `Address`                   | Address of the router's Jetton wallet for the swapped token |
| `value` | `bigint`                    | Recommended amount of TON (in nanoTons) sent as gas         |
| `body`  | `Cell \| null \| undefined` | Optional `Cell` with data to be send                        |

Notes:

* `params` is entirely optional
* the default value for `gasAmount` is equal to 0.3 TON

#### `sendResetGas`


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.ston.fi/developer-section/dex/sdk/v1/reference.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.