Package Exports

@lifinity/sdk-v2
@lifinity/sdk-v2/lib/index.js

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (@lifinity/sdk-v2) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

lifinity-sdk-v2

Installation

yarn install @lifinity/sdk-v2

Usage

Get pools

import { getPoolList } from '@lifinity/sdk-v2';

const pools = getPoolList();

console.log("pools =", pools);

Get swap amount

import { Connection, PublicKey } from '@solana/web3.js';
import { getAmountOut, AmountOut } from '@lifinity/sdk-v2';

const connection: Connection = new Connection("https://api.mainnet-beta.solana.com");
const amountIn: number = 1; // Input amount
const fromMint: PublicKey = new PublicKey("---Mint address of the input token---");
const toMint: PublicKey = new PublicKey("---Mint address of the output token---");
const slippage: number = 1; // Slippage (%)

const res : AmountOut = await getAmountOut(
    connection,
    amountIn,
    fromMint,
    toMint,
    slippage
);

console.log("amountIn: number =", res.amountIn);
console.log("amountOut: number =", res.amountOut);
console.log("amountOutWithSlippage: number =", res.amountOutWithSlippage);
console.log("priceImpact: number =", res.priceImpact);
console.log("fee: number =", res.fee);
console.log("feePercent: number =", res.feePercent);

Breakdown of get swap amount
Please use the SDK for calculating amount out (getCurveAmount) as the protocol is still in beta and the math may be updated

import { Connection, PublicKey } from '@solana/web3.js';
import Decimal from 'decimal'
import { getPool, getMultipleAccounts, getParsedData, getCurveAmount, TradeDirection } from '@lifinity/sdk-v2'


const connection: Connection = new Connection("https://api.mainnet-beta.solana.com");
const amountIn: number = 1; // Input amount
const fromMint: PublicKey = new PublicKey("---Mint address of the intput token---");
const toMint: PublicKey = new PublicKey("---Mint address of the output token---");
const slippage: number = 1; // Slippage (%)

const poolInfo = getPool(fromMint.toString(), toMint.toString());
if (poolInfo) {

    let amount = new Decimal(amountIn);
    let tradeDirection: string;
    let inDecimal: number;
    let outDecimal: number;

    if (poolInfo.poolCoinMint === fromMint.toString()){
        amount = amount.times(new Decimal(10).pow(poolInfo.poolCoinDecimal));
        inDecimal = poolInfo.poolCoinDecimal;
        outDecimal = poolInfo.poolPcDecimal;
        tradeDirection = TradeDirection.AtoB;
    }else{
        amount = amount.times(new Decimal(10).pow(poolInfo.poolPcDecimal));
        inDecimal = poolInfo.poolPcDecimal;
        outDecimal = poolInfo.poolCoinDecimal
        tradeDirection = TradeDirection.BtoA;
    }

    const publicKeys = [
        new PublicKey(poolInfo.amm),
        new PublicKey(poolInfo.poolCoinTokenAccount),
        new PublicKey(poolInfo.poolPcTokenAccount),
    ];

    if (poolInfo.oracleMainAccount !== poolInfo.oracleSubAccount){
        publicKeys.push(new PublicKey(poolInfo.oracleMainAccount));
        publicKeys.push(new PublicKey(poolInfo.oracleSubAccount));
    }else{
        publicKeys.push(new PublicKey(poolInfo.oracleMainAccount));
    }

    if (poolInfo.oracleSubAccount !== poolInfo.oraclePcAccount){
        publicKeys.push(new PublicKey(poolInfo.oraclePcAccount));
    }

    try {
        const multipleInfo = await getMultipleAccounts(connection, publicKeys);

        const data: IAmmData = getParsedData(
            multipleInfo,
            poolInfo
        );

        const slot = await connection.getSlot();

        const curveAmount: ICurveAmount = getCurveAmount(
            amount,
            slot,
            data.amm,
            data.fees,
            data.coinBalance,
            data.pcBalance,
            data.config,
            data.oracleMain,
            data.oracleSub,
            data.oraclePc,
            tradeDirection,
        );
        console.log("amountSwapped: Decimal =", curveAmount.amountSwapped);
        console.log("priceImpact: Decimal =", curveAmount.priceImpact);
        console.log("fee: Decimal =", curveAmount.fee);
        console.log("feePercent: Decimal =", curveAmount.feePercent);

        const slippagePercent = new Decimal(slippage).div(100);
        const amountOutWithSlippage = new Decimal(Math.floor(curveAmount.amountSwapped.times(new Decimal(1).minus(slippagePercent)).toNumber()));
        const amountOutWithSlippageTokenAmount = amountOutWithSlippage.div(new Decimal(10).pow(outDecimal)).toNumber();
        const amountOutTokenAmount = curveAmount.amountSwapped.div(new Decimal(10).pow(outDecimal)).toNumber();
        const feeTokenAmount = curveAmount.fee.div(new Decimal(10).pow(inDecimal)).toNumber();

        console.log("slippagePercent: Decimal =", slippagePercent);
        console.log("amountOutWithSlippage: Decimal =", amountOutWithSlippage);
        console.log("amountOutWithSlippageTokenAmount: Decimal =", amountOutWithSlippageTokenAmount);
        console.log("amountOutTokenAmount: Decimal =", amountOutTokenAmount);
        console.log("feeTokenAmount: Decimal =", feeTokenAmount);

    }catch (error) {
        console.log(error)
        // Errors include failures to obtain accurate price feed from the oracle
    }
}

Get swap instruction

import { Connection, PublicKey } from '@solana/web3.js';
import { getSwapInstruction } from '@lifinity/sdk-v2'

const connection: Connection = new Connection("https://api.mainnet-beta.solana.com");
const ownerAccount: PublicKey = new PublicKey("---User's Solana address---")
const amountIn: number = 1; // Input amount
const minimumOut: number = 100; // Output amount
const fromMint: PublicKey = new PublicKey("---Mint address of the input token---");
const toMint: PublicKey = new PublicKey("---Mint address of the output token---");
const fromUserAccount: PublicKey = new PublicKey("---User's input token account---");
const toUserAccount: PublicKey = new PublicKey("---User's output token account---");
const approve = true; // Set false to skip approve instruction

const { approveInstruction, swapInstruction, signers } = await getSwapInstruction(
    connection,
    ownerAccount,
    amountIn, 
    minimumOut,
    fromMint,
    toMint,
    fromUserAccount,
    toUserAccount,
    approve,
);

console.log("approveInstruction: TransactionInstruction =", approveInstruction);
console.log("swapInstruction: TransactionInstruction =", swapInstruction);
console.log("signers: any[] =", signers);

Swap

import { Lifinity } from '@lifinity/sdk-v2'

const connection: Connection = new Connection("https://api.mainnet-beta.solana.com");
const wallet: any = "---User wallet---"
const amountIn: number = 1; // Input amount
const minimumOut: number = 100; // Output amount
const fromMint: PublicKey = new PublicKey("---Mint address of the input token---");
const toMint: PublicKey = new PublicKey("---Mint address of the output token---");

const lifinitySdk = await Lifinity.build(
    connection,
    wallet
);

const transactionId: string = await lifinitySdk.swap(
    amountIn,
    minimumOut,
    fromMint,
    toMint
);

console.log("transactionId: string =",transactionId)

Deposit

import { Lifinity } from '@lifinity/sdk-v2'

const connection: Connection = new Connection("https://api.mainnet-beta.solana.com");
const wallet: any = "---User wallet---"

const coinAmountIn: number = 1; // input coin token amount
const pcAmountIn: number = 0; 
const coinMint: PublicKey = new PublicKey("---Mint address of the pool coin token---");
const pcMint: PublicKey = new PublicKey("---Mint address of the pool pc token---");
const slippage: number = 1; // Slippage (%)

// If pcAmountIn = 0, calculate pcAmountIn from coinAmountIn
const depositAmount : IDepositAmountOut = await getDepositAmountOut(
  connection,
  coinAmountIn,
  pcAmountIn,
  coinMint,
  pcMint,
  slippage
);

const lifinitySdk = await Lifinity.build(
    connection,
    wallet
);

const transactionId: string = await lifinitySdk.deposit(
    depositAmount.coinMaximumIn,
    depositAmount.pcMaximumIn,
    depositAmount.lpRecive,
    coinMint,
    pcMint,
);

console.log("transactionId: string =",transactionId)

If you only want to get the deposit instruction, use getDepositInstruction ().

Withdraw

import { Lifinity } from '@lifinity/sdk-v2'

const connection: Connection = new Connection("https://api.mainnet-beta.solana.com");
const wallet: any = "---User wallet---"

const lpAmountIn: number = 1; // input lp token amount
const coinMint: PublicKey = new PublicKey("---Mint address of the pool coin token---");
const pcMint: PublicKey = new PublicKey("---Mint address of the pool pc token---");
const slippage: number = 1; // Slippage (%)

const withdrawAmount : IWithdrawAmountOut = await getWithdrawAmountOut(
  connection,
  lpAmountIn,
  coinMint,
  pcMint,
  slippage
);

const lifinitySdk = await Lifinity.build(
    connection,
    wallet
);

const transactionId: string = await lifinitySdk.withdraw(
    withdrawAmount.lpAmountIn,
    withdrawAmount.coinMinimumOut,
    withdrawAmount.pcMinimumOut,
    coinMint,
    pcMint,
);

console.log("transactionId: string =",transactionId)

If you only want to get the withdraw instruction, use getWithdrawInstruction ().