# Velar SDK 0.6.9

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;
    outToken: string;
}

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

enum SwapType {
  ONE = 1,
  TWO = 2
}

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

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

## VELAR SDK Interface:

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

## Swap Exact Tokens For Tokens and Multihop:

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

const sdk = new VelarSDK();

async () => {
  // getTokens will return you all of the tokens symbols which currently Velar supporting
  const { VELAR, STX } = await getTokens();
  const account = '';

  // setup swap instance
  const swapInstance: ISwapService = await sdk.getSwapInstance({
    account: account,
    inToken: VELAR,
    outToken: STX,
  });

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

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

  // 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);
};
```

## Swap Tokens For Exact Tokens:

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

const sdk = new VelarSDK();

async () => {
  // getTokens will return you all of the tokens symbols which currently Velar supporting
  const { VELAR, STX } = await getTokens();
  const account = '';

  // setup swap instance
  const swapInstance: ISwapService = await sdk.getSwapInstance({
    account: account,
    inToken: VELAR,
    outToken: STX,
  });

  // to display amount in
  const amount: number = await swapInstance.getComputedAmount({
    type: SwapType.TWO,
    amount: 10,
  });

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

  // 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);
};
```

## getPairs:

```typescript
const pairs = await sdk.getPairs('VELAR'); // ['STX', 'aeUSDC']
```

## Available tokens:

```typescript
const Tokens = {
  SOME: 'SOME',
  ROCK: 'ROCK',
  VELAR: 'VELAR',
  MICK: 'MICK',
  LONG: 'LONG',
  PEPE: 'PEPE',
  $ROO: '$ROO',
  WELSH: 'WELSH',
  LEO: 'LEO',
  stSTX: 'stSTX',
  aeUSDC: 'aeUSDC',
  aBTC: 'aBTC',
  STX: 'STX',
  ODIN: 'ODIN',
  sODIN: 'sODIN',
  sROO: 'sROO',
  sWELSH: 'sWELSH',
  Hat: 'Hat',
  HASHIKO: 'HASHIKO',
  POMBOO: 'POMBOO',
  $MOONCH: '$MOONCH',
  NOT: 'NOT',
  ALUX: 'ALUX',
  GOATSTX: 'GOATSTX',
  MWM: 'MWM',
};
```

## Pairs:

```typescript
const Pairs = [
  {
    "symbol": "SOME",
    "pairs": [
      "STX"
    ]
  },
  {
    "symbol": "ROCK",
    "pairs": [
      "STX"
    ]
  },
  {
    "symbol": "VELAR",
    "pairs": [
      "STX",
      "aeUSDC"
    ]
  },
  // ... (other pairs omitted for brevity)
];
```

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.6.9.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.