# Instaswap-hook

You can find full example codes here =>  [instaswap-hook-example](https://github.com/RatioFinance/instaswap-hook-example)

#### 1. Install Instaswap-hook

```
yarn add @ratio-finance/instaswap-hook
```

#### 2. Import useInstaSwap and its props type

```
import { 
    useInstaSwap, 
    useInstaSwapProps, 
    PLATFORMS 
} from "@ratio-finance/instaswap-hook";
```

#### 3. Wrap with InstaSwapProvider

```
import { InstaSwapProvider } from "@ratio-finance/instaswap-hook";

const InstaSwapWrapper: React.FC = ({ children }) => {
  const { connection } = useConnection();
  const wallet = useWallet();
  return (
    <InstaSwapProvider connection={connection} userPublicKey={wallet.publicKey}>
      {children}
    </InstaSwapProvider>
  )
}
```

#### 4. Get values via useInstaSwap

* Parameter type of ***useInstaSwap***

```
export type useInstaSwapProps = {
  amount?: number;
  token?: string;
  lpToken?: string;
  slippage?: number;
  direction?: boolean;  // true: Buy LP Mode,  false: Sell LP Mode
}
```

* Get values of instaswap context via useInstaSwap.

```
const { 
  avaLpTokens,           // Map<string, LpTokenInfo>
  avaTokens,             // Map<string, TokenInfo>
  estimatedOutAmount,    // number
  avaLpMints,            // string[]
  avaTokenMints,         // string[]
  loading,               // boolean
  execute                // (props: ExecuteParams) => Promise<{ err?: any }>,
} = useInstaSwap({
  amount: 1,
  token: USDC_MINT,
  lpToken: RAYDIUM_USDT_USDC_LP,
  slippage: 1, // 0.1%,
  direction: true        // direction is True as default
});
```

You can check the type of `LpTokenInfo` and `TokenInfo` in [instaswap-core](https://docs.ratio.finance/for-developers/instaswap-core#3.-types-and-interfaces).

* **`avaLpTokens`**

Available LP tokens which current insta-swap offers.

* **`avaTokens`**

Available tokens which can be swapped into LP tokens in insta-swap.

* **`estimatedOutAmount`**

Estimated output amount of LP token.\
This is not decimals amount but is ui amount, so that you can directly show this value on ui.

* **`avaLpMints, avaTokenMints`**

avaLpMints:        Mint addresses of **`avaLpTokens`**

avaTokenMints:  Mint addresses of **`avaTokens`**

#### 5. Execute insta-swap

* Parameter type of execute function

```
export type ExecuteParams = {
  wallet: Pick<SignerWalletAdapter, 'signAllTransactions' | 'publicKey' | 'sendTransaction' | 'signTransaction'>,
  beforeSend?: (txTotalCnt: number, txIdx: number) => void;
  afterSend?: (txTotalCnt: number, txIdx: number, txHash: string) => void;
  onSuccess?: (txResult: string[]) => void;
  onFail?: (txResult: string[]) => void;
  confirmType?: ConfirmTypes; // Default is Processed
}
```

```
// ConfirmTypes
export const enum ConfirmTypes {
  Confirmed,  // Confirm every transactions as 'confirmed' after sent
  Processed,  // Confirm every transactions as 'processed' after sent
  ConfirmLastTx,  // Confirm every transactions as 'processed' 
                  // and for only last transaction confirm as 'confirmed'
}
```

* Code snippet to show how to run `execute` function.

```
  const executeInstaswap = () => {
    if (
      wallet.sendTransaction &&
      wallet.signAllTransactions &&
      wallet.signTransaction
    ) {
      execute({
        connection,
        wallet: {
          sendTransaction: wallet.sendTransaction,
          publicKey: wallet.publicKey,
          signAllTransactions: wallet.signAllTransactions,
          signTransaction: wallet.signTransaction,
        },
        beforeSend: (txTotalCnt, txIdx) => {
          console.log(`sending ${txIdx + 1} of ${txTotalCnt} transactions`);
        },
        afterSend: (txTotalCnt, txIdx, txHash: string) => {
          console.log(
            `sent ${txIdx + 1} of ${txTotalCnt} transactions, txHash: ${txHash}`
          );
        },
        onSuccess: (txResults: string[]) => {
          console.log(`swap success. Hashes: ${txResults}`);
        },
        onFail: (txResults: string[]) => {
          console.log(`swap failed. Hashes: ${txResults}`);
        },
      }).then(res => {
        if (res.err) {
          console.error(res.err);
        } else {
          console.log('Success: no error');
        }
      })
    }
  }
```

There might be several transactions for insta-swap.

This callback is called before sending a transaction.

`txTotalCnt` is the count of total transactions and `txIdx` is the index of transaction being sent.

> `beforeSend(txTotalCnt, txIdx) => void`

This callback is called after sending a transaction whose hash is `txHash`

> `afterSend(txTotalCnt, txIdx, txHash: string) => void`

This callback is called when insta-swap is finished successfully.\
`txResult` is the array of transaction hashes which sent for insta-swap.

> `onSuccess(txResult: string[]) => void`

This callback is called when insta-swap is failed.

> `onFail(txResult: string[]) => void`