# Velar SDK 0.7.0-beta \[Latest]

Installation:

```bash
npm i @velarprotocol/velar-sdk
```

## Velar SDK Types:

```typescript
  import { ContractPrincipalCV, PostCondition, PostConditionMode, UIntCV } from "@stacks/transactions";

  export interface SwapConfig {
      account: string;
      inToken: string;  // Token Symbol or Token Contract Address
      outToken: string; // Token Symbol or Token Contract Address
  }

  export interface ISwapService {
    swap(args: SwapPayload): Promise<SwapResponse>;
    getComputedAmount(args: ComputedAmountPayload): Promise<AmountOutResponse>;
  }

  export interface ComputedAmountPayload {
    amount: Number;
    slippage?: Number;
  }

  interface DestinationToken {
    symbol: string,
    contractAddress: string,
    tokenDecimalNum: Number,
    assetName: string,
  }

  export interface AmountOutResponse {
    value: Number,
    amountOut: Number // raw amount out
    path: Array<string> // route contract addresses
    path2: Array<string> // route symbols
    destinationToken: { symbol: string,  contractAddress: string,  tokenDecimalNum: Number,  assetName: string } // destination token details
    amountOutDecimal: Number // amountOutWithDecimals
    route?: Array<string>, // multihop optimal route
    result?: any // multihop routes results
  }

  export interface SwapResponse {
    contractAddress: string,
    contractName: string,
    functionName: string,
    functionArgs: [
      UIntCV,                  // pool id
      ContractPrincipalCV,    // pool token0 address
      ContractPrincipalCV,    // pool token1 address
      ContractPrincipalCV,    // in token address
      ContractPrincipalCV,    // out token address
      ContractPrincipalCV,    // staking contract
      UIntCV,                 // amount in
      UIntCV                  // amount out
    ],
    postConditions: Array<PostCondition>,
    postConditionMode: PostConditionMode,
  }

  export declare class SwapService {
    constructor(args: SwapConfig);
    swap(args: SwapPayload): Promise<SwapResponse>;
    getComputedAmount(args: ComputedAmountPayload): Promise<AmountOutResponse>;
  }
```

## VELAR SDK Interface:

```typescript
  export declare class VelarSDK {
    getPairs (symbol: string): Promise<Array<string>>;
    getSwapInstance(args: SwapConfig): SwapService;
  }
```

## Swap:

```typescript
import {
  VelarSDK,
  getTokens,
  ISwapService,
  SwapResponse,
} from '@velarprotocol/velar-sdk';
import { openContractCall } from '@stacks/connect';

const sdk = new VelarSDK();

async () => {
  const account = '';
  // setup swap instance
  const swapInstance: ISwapService = await sdk.getSwapInstance({
    account: account,
    inToken: 'SP1Y5YSTAHZ88XYK1VPDH24GY0HPX5J4JECTMY4A1.wstx',
    outToken: 'SP1Y5YSTAHZ88XYK1VPDH24GY0HPX5J4JECTMY4A1.velar-token',
  });

  // to display amount out
  const amount: AmountOutResponse = await swapInstance.getComputedAmount({
    amount: 10,
  });

  // get swap calculated arguments for contract call
  const swapOptions: SwapResponse = await swapInstance.swap({
    amount: 10,
  });

  // build options for contract call
  const options = {
    ...swapOptions,
    network: AppService.getNetwork(),
    appDetails: AppService.getAppDetails(),
    anchorMode: AnchorMode.Any,
    onFinish: data => {},
    onCancel: ex => {},
  };

  // open contract call
  await openContractCall(options);
};
```

## Available tokens:

<https://sdk-beta.velar.network/tokens/symbols>

For more detailed information and additional functions, please refer to the npm library [here](https://www.npmjs.com/package/@velarprotocol/velar-sdk).


---

# 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.velar.com/velar/developers/velar-sdk/velar-sdk-0.7.0-beta-latest.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.