# Installation

## Using NPM: [click to redirect](https://www.npmjs.com/package/@kanalabs/aggregator)

```shell
 npm i @kanalabs/aggregator
```

## Using Yarn: [click to redirect](https://yarnpkg.com/package?q=kanalabs&name=%40kanalabs%2Faggregator)

```shell
 yarn add @kanalabs/aggregator
```

# TypeDoc:

[kanalabs aggregator SDK type doc - click to redirect](https://kanalabs.github.io/kanalabs-aggregator-sdk-v2/)

# Supported Chains

1. Aptos
2. Arbitrum
3. Avalanche
4. BSC (Binance Smart Chain)
5. Ethereum
6. Polygon
7. Solana
8. Sui
9. zkSync Era

# Supported Bridges

1. Wormhole
2. LayerZero
3. CCTP

# Usage

## Same Chain Swap

## **1. SwapQuotes function**

```typescript
 swapQuotes = async (params: SameChainSwapParams)
```

| **SameChainSwapParams** | **Description**                               |
| ----------------------- | --------------------------------------------- |
| inputToken              | The input token for the swap operation.       |
| outputToken             | The output token to receive after the swap.   |
| amountIn                | The amount of input tokens to be swapped.     |
| slippage                | The allowed slippage percentage for the swap. |
| network                 | The network ID for the swap operation.        |
| options                 | (Optional) Additional options for the swap.   |

## **2. ExecuteSwapInstruction**

```typescript
executeSwapInstruction = async (params: SameChainInstructionParams)
```

| **executeSwapInstruction** | **Description**                                                  |
| -------------------------- | ---------------------------------------------------------------- |
| quote                      | A `CommonRouteInterface` representing the quote response format. |
| address                    | The address related to the instruction.                          |
| options                    | (Optional) An object containing additional options.              |
| options.provider           | (Optional) The connection provider to use.                       |
| options.integrator         | (Optional) A string identifying the integrator.                  |

### 1 . APTOS :

#### 1.1 .Initialising The SDK

```typescript
const aptosConfig = new AptosConfig({ network: Network.MAINNET });
const aptosProvider = new Aptos(aptosConfig)

const aptosSigner = Account.fromPrivateKey({
  privateKey: new Ed25519PrivateKey(process.env.APTOS_PRIVATEKEY || ''),
  address:  AccountAddress.from(process.env.APTOS_ADDRESS || ''),
  legacy: true,
});

const swap = new SwapAggregator(Environment.production, {
  providers: {
    aptos: aptosProvider,
  },
  signers: {
    aptos: aptosSigner,
  },
});
```

> NOTE : SIGNER CAN BE A APTOS ACCOUNT INSTANCE DERIVED FROM PRIVATE KEY OR A SIGN AND SUBMIT FUNCTION FROM APTOS WALLET ADAPTER

#### 1.2 .Getting Swap Quotes

```typescript
const quote = await swap.swapQuotes({
  apiKey: APIKEY,
  inputToken: '0x1::aptos_coin::AptosCoin',
  outputToken: '0x6f986d146e4a90b828d8c12c14b6f4e003fdff11a8eecceceb63744363eaac01::mod_coin::MOD',
  amountIn: '100000',
  slippage: 0.5,
  network: NetworkId.aptos,
});

const optimalQuote = quote.data[0];
```

#### 1.3 .Executing Swap Quotes

```typescript
const executeSwap = await swap.executeSwapInstruction({
  apiKey: APIKEY,
  quote: optimalQuote,
  address: swap.signer?.aptos?.address().toString(),
});
```

### 2 . SUI :

#### 2.1 .Initialising The SDK

```typescript
const suiProvider = new JsonRpcProvider(new SuiConnection({ fullnode: 'SUI RPC NODE ' }));

const suiSigner = new RawSigner(Ed25519Keypair.deriveKeypair(process.env.SUIMNEMONICS || ''), suiProvider);

const swap = new SwapAggregator(Environment.production, {
  providers: {
    sui: suiProvider,
  },
  signers: {
    sui: suiSigner,
  },
});
```

#### 2.2 .Getting Swap Quotes

```typescript
const quote = await swap.swapQuotes({
  apiKey: APIKEY,
  inputToken: '0x2::sui::SUI',
  outputToken: '0xf0fe2210b4f0c4e3aff7ed147f14980cf14f1114c6ad8fd531ab748ccf33373b::bswt::BSWT',
  amountIn: '10000',
  slippage: 1,
  network: NetworkId.sui,
});
const optimalQuote = quote.data[0];
```

#### 2.3 .Executing Swap Quotes

```typescript
const executeSwap = await swap.executeSwapInstruction({
  apiKey: APIKEY,
  quote: optimalQuote,
  address: await swap.signer?.sui?.getAddress(),
});
```

### 3 . SOLANA :

#### 3.1 .Initialising The SDK

```typescript
const solanaProvider = new Connection(clusterApiUrl('mainnet-beta'));
const solanaSigner = Keypair.fromSecretKey(bs58.decode(process.env.SOLANAPAYER || ''));

const swap = new SwapAggregator(Environment.production, {
  providers: {
    solana: solanaProvider,
  },
  signers: {
    solana: solanaSigner,
  },
});
```

#### 3.2 .Getting Swap Quotes

```typescript
const quote = await swap.swapQuotes({
  apiKey: APIKEY,
  inputToken: 'So11111111111111111111111111111111111111112',
  outputToken: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
  amountIn: '1000',
  slippage: 1,
  network: NetworkId.solana,
});
const optimalQuote = quote.data[0];
```

#### 3.3 .Executing Swap Quotes

```typescript
const executeSwap = await swap.executeSwapInstruction({
  apiKey: APIKEY,
  quote: optimalQuote,
  address: swap.signer?.solana?.publicKey.toString(),
});
```

### 4 . EVM CHAINS :

#### 4.1 .Initialising The SDK

```typescript
const polygonRpc = process.env.ETH_NODE_URI_POLYGON as string;
const polygonProvider = ethers.getDefaultProvider(polygonRpc);
const polygonSigner = new ethers.Wallet(privateKey, polygonProvider);

const swap = new SwapAggregator(Environment.production, {
  providers: {
    polygon: polygonProvider,
  },
  signers: {
    polygon: polygonSigner,
  },
});
```

#### 4.2 .Getting Swap Quotes

```typescript
const quote = await swap.swapQuotes({
  apiKey: APIKEY,
  inputToken: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
  outputToken: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F',
  amountIn: utils.parseEther('0.05').toString(),
  slippage: 1,
  network: NetworkId.polygon,
});
const optimalQuote = quote.data[0];
```

#### 4.3 .Executing Swap Quotes

```typescript
const executeSwap = await swap.executeSwapInstruction({
  apiKey: APIKEY,
  quote: optimalQuote,
  address: await swap.signer?.polygon?.getAddress(),
});
```

## Cross Chain Swap

### **1. CrossChainQuote**

```typescript
crossChainQuote = async (params: CrossChainSwapParams)
```

| **CrossChainSwapParams** | **Description**                                      |
| ------------------------ | ---------------------------------------------------- |
| sourceToken              | The source token to be swapped.                      |
| targetToken              | The target token to receive after the swap.          |
| sourceChain              | The source network ID or chain for the swap.         |
| targetChain              | The target network ID or chain for the swap.         |
| amountIn                 | The amount of source tokens to be swapped.           |
| sourceSlippage           | The allowed slippage percentage on the source chain. |
| targetSlippage           | The allowed slippage percentage on the target chain. |
| options                  | (Optional) An object containing additional options.  |

### **2. Execute Cross Chain Transfer**

```typescript
executeTransfer = async (params: ExecuteCrossChainTransferParams)
```

| **CrossChainTransferParams** | **Description**                 |
| ---------------------------- | ------------------------------- |
| sourceProvider               | RPC Provider for source chain   |
| sourceSigner                 | Source chain signer             |
| quote                        | selected cross chain swap quote |
| sourceAddress                | source chain user address       |
| targetAddress                | Target chain user address       |
| targetSigner                 | target chain signer.            |
| targetProvider               | Rpc provider for target chain.  |

### **3. Execute Cross Chain Claim**

```typescript
executeClaim = async (params: ExecuteCrossChainClaimParams)
```

| **CrossChainSwapParams** | **Description**                                             |
| ------------------------ | ----------------------------------------------------------- |
| txHash                   | Transaction hash of the tranfer transaction in source chain |
| sourceProvider           | RPC Provider for source chain                               |
| targetProvider           | Rpc provider for target chain.                              |
| targetSigner             | target chain signer.                                        |
| quote                    | selected cross chain swap quote                             |
| sourceAddress            | source chain user address                                   |
| targetAddress            | Target chain user address                                   |

**A CrossChain swap consists of three steps**

> 1. Getting Swap Quotes: This step involves obtaining quotes for the selected chains and tokens.

> 2. Executing Transfer Instruction: In this phase, tokens are transferred across chains using a bridge to reach the selected destination chain.

> 3. Executing Claim Instruction: After the tokens have been successfully bridged to the destination chain, this step allows users to claim their tokens. It's worth noting that bridges utilizing a relayer may not require this specific claim step.

**What if the claim fails ?**

> In the event of a failure, users can redeem their tokens that were transferred via the bridge. Kanalabs exclusively transfers native stable coins / wrapped stable coins via the bridge. Therefore, users have the option to redeem their tokens and manually initiate the swap on the destination chain."

### 1 . POLYGON TO BSC

#### 1.1 . Initialising SDK

```typescript
const polygonRpc = process.env.ETH_NODE_URI_POLYGON as string;
const polygonProvider = ethers.getDefaultProvider(polygonRpc);
const polygonSigner = new ethers.Wallet(privateKey, polygonProvider);

const bscRpc = process.env.ETH_NODE_URI_BSC as string;
const bscProvider = ethers.getDefaultProvider(bscRpc);
const bscSigner = new ethers.Wallet(privateKey, bscProvider);

const crossChainAggregator = new SwapAggregator(Environment.production);
```

#### 1.2 . Getting Cross Chain Swap Quote

```typescript
const quotes = await crossChainAggregator.crossChainQuote({
  apiKey: APIKEY,
  sourceToken: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
  targetToken: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
  sourceChain: NetworkId.polygon,
  targetChain: NetworkId.bsc,
  amountIn: utils.parseUnits('0.01', 18).toString(),
  sourceSlippage: 0.1,
  targetSlippage: 0.1,
});

const optimalQuote = quotes.data[0];
```

#### 1.3 . Executing Transfer Instruction

```typescript
const transfer = await crossChainAggregator.executeTransfer({
  apiKey: APIKEY,
  quote: optimalQuote,
  sourceAddress: polygonSigner.getAddress() as string,
  targetAddress: bscSigner.getAddress() as string,
  sourceProvider: polygonProvider as providers.BaseProvider,
  sourceSigner: polygonSigner as EvmSignerType,
});
```

> For Bridges using relayers there is no need to execute claim Instruction

#### 1.4 . Execute Claim Instruction

```typescript
const claim = await crossChainAggregator.executeClaim({
  apiKey: APIKEY,
  txHash: transfer.txHash,
  sourceProvider: polygonProvider as providers.BaseProvider,
  targetProvider: bscProvider as providers.BaseProvider,
  targetSigner: bscSigner as EvmSignerType,
  quote: optimalQuote,
  sourceAddress: polygonSigner.getAddress() as string,
  targetAddress: bscSigner.getAddress() as string,
});
```

#### 1.5 . Redeeming tokens in case of failure

```typescript
const redeem = await crossChainAggregator.redeem({
  apiKey: APIKEY,
  sourceChain: NetworkId.polygon,
  targetChain: NetworkId.bsc,
  sourceProvider: polygonProvider as providers.BaseProvider,
  targetProvider: bscProvider as providers.BaseProvider,
  targetSigner: bscSigner as EvmSignerType,
  SourceHash: transfer.txHash,
  targetAddress: bscSigner.getAddress() as string,
  BridgeId: BridgeId.wormhole,
});
```

### 2 . APTOS TO SUI

#### 2.1 . Initialising SDK

```typescript
const suiProvider = new JsonRpcProvider(new SuiConnection({ fullnode: 'SUI RPC NODE' }));
const aptosConfig = new AptosConfig({ network: Network.MAINNET });
const aptosProvider = new Aptos(aptosConfig)

const suiSigner = new RawSigner(Ed25519Keypair.deriveKeypair(process.env.SUIMNEMONICS || ''), suiProvider);
const aptosSigner = Account.fromPrivateKey({
  privateKey: new Ed25519PrivateKey(process.env.APTOS_PRIVATEKEY || ''),
  address:  AccountAddress.from(process.env.APTOS_ADDRESS || ''),
  legacy: true,
});

const crossChainAggregator = new SwapAggregator(Environment.production);
```

#### 2.2 . Getting Cross Chain Swap Quote

```typescript
const crossChainQuotes = await crossChainAggregator.crossChainQuote({
  apiKey: APIKEY,
  sourceToken,
  targetToken,
  sourceChain: NetworkId.aptos,
  targetChain: NetworkId.sui,
  amountIn: '100000',
  sourceSlippage: 0.1,
  targetSlippage: 0.1,
});
const optimalRoute = crossChainQuotes.data[0];
```

#### 2.3 . Executing Transfer Instruction

```typescript
const transfer = await crossChainAggregator.executeTransfer({
  apiKey: APIKEY,
  sourceProvider: aptosProvider,
  sourceAddress: aptosSigner.accountAddress.toString(),
  sourceSigner: aptosSigner,
  quote: optimalRoute,
  targetAddress: await suiSigner.getAddress(),
});
```

> For Bridges using relayers there is no need to execute claim Instruction

#### 2.4 . Execute Claim Instruction

```typescript
const claim = await crossChainAggregator.executeClaim({
  apiKey: APIKEY,
  txHash: transfer.txHash,
  sourceProvider: aptosProvider,
  targetProvider: suiProvider,
  targetSigner: suiSigner,
  quote: optimalRoute,
  sourceAddress: aptosSigner.accountAddress.toString(),
  targetAddress: await suiSigner.getAddress(),
});
```

#### 2.5 . Redeeming tokens in case of failure

```typescript
const redeem = await crossChainAggregator.redeem({
  apiKey: APIKEY,
  sourceChain: NetworkId.aptos,
  targetChain: NetworkId.sui,
  sourceProvider: aptosProvider,
  targetProvider: suiProvider,
  targetSigner: suiSigner,
  SourceHash: transfer.txHash,
  targetAddress: await suiSigner.getAddress(),
  BridgeId: BridgeId.wormhole,
});
```

### 3 . SOLANA TO APTOS

#### 3.1 . Initialising SDK

```typescript
const solanaProvider = new Connection('SOLANA RPC NODE');
const solanaSigner = Keypair.fromSecretKey(bs58.decode(process.env.SOLANAPAYER || ''));
const aptosConfig = new AptosConfig({ network: Network.MAINNET });
const aptosProvider = new Aptos(aptosConfig)

const aptosSigner = Account.fromPrivateKey({
  privateKey: new Ed25519PrivateKey(process.env.APTOS_PRIVATEKEY || ''),
  address:  AccountAddress.from(process.env.APTOS_ADDRESS || ''),
  legacy: true,
});

const crossChainAggregator = new SwapAggregator(Environment.production);
```

#### 3.2 . Getting Cross Chain Swap Quote

```typescript
const crossChainQuotes = await crossChainAggregator.crossChainQuote({
  apiKey: APIKEY,
  'So11111111111111111111111111111111111111112',
  '0x1::aptos_coin::AptosCoin',
  sourceChain: NetworkId.solana,
  targetChain: NetworkId.aptos,
  amountIn: '100000',
  sourceSlippage: 0.5,
  targetSlippage: 0.1,
});
const optimalRoute = crossChainQuotes.data[0];
```

#### 3.3 . Executing Transfer Instruction

```typescript
const transfer = await crossChainAggregator.executeTransfer({
  apiKey: APIKEY,
  sourceProvider: solanaProvider,
  sourceAddress: solanaSigner.publicKey.toString(),
  sourceSigner: solanaSigner,
  quote: optimalRoute,
  targetAddress: aptosSigner.accountAddress.toString(),
});
```

> For Bridges using relayers there is no need to execute claim Instruction

#### 3.4 . Execute Claim Instruction

```typescript
const claim = await crossChainAggregator.executeClaim({
  apiKey: APIKEY,
  txHash: transfer.txHash,
  sourceProvider: solanaProvider,
  targetProvider: aptosProvider,
  targetSigner: aptosSigner,
  quote: optimalRoute,
  sourceAddress: solanaSigner.publicKey.toString(),
  targetAddress: aptosSigner.accountAddress.toString(),
});
```

#### 3.5 . Redeeming tokens in case of failure

```typescript
const redeem = await crossChainAggregator.redeem({
  apiKey: APIKEY,
  sourceChain: NetworkId.solana,
  targetChain: NetworkId.aptos,
  sourceProvider: solanaProvider,
  targetProvider: aptosProvider,
  targetSigner: aptosSigner,
  SourceHash: transfer.txHash,
  targetAddress: aptosSigner.accountAddress.toString(),
  BridgeId: BridgeId.wormhole,
});
```