@galacticcouncil/sdk 0.0.1-beta.10 → 0.0.1-beta.12

package/dist/types/api/router.d.ts

@@ -4,8 +4,8 @@ export declare type RouterOptions = {
 };
 export declare class Router {
     private readonly routeSuggester;
-    private readonly poolService;
     private readonly routerOptions;
+    protected readonly poolService: PoolService;
     private readonly defaultRouterOptions;
     /**
      * @param poolService - Fetch pool data from substrate based pools
@@ -27,47 +27,48 @@ export declare class Router {
     /**
      * Calculate and return list of all assets, given token can be trade with
      *
-     * @param {string} token - Storage key of token
+     * @param {string} asset - Storage key of asset
      * @returns {PoolAsset[]} List of all available assets, given token can be trade with
      */
-    getAssetPairs(token: string): Promise<PoolAsset[]>;
+    getAssetPairs(asset: string): Promise<PoolAsset[]>;
     /**
-     * Calculate and return all possible paths for best swap tokenIn>tokenOut
+     * Calculate and return all possible paths for best swap assetIn>assetOut
      *
-     * @param {string} tokenIn - Storage key of tokenIn
-     * @param {string} tokenOut - Storage key of tokenOut
+     * @param {string} assetIn - Storage key of assetIn
+     * @param {string} assetOut - Storage key of assetOut
      * @returns {<Hop[][]>} All possible paths containing route hops
      */
-    getAllPaths(tokenIn: string, tokenOut: string): Promise<Hop[][]>;
+    getAllPaths(assetIn: string, assetOut: string): Promise<Hop[][]>;
     /**
      * Return map of all available assets from substrate based pools
      *
+     * @param pools - pools
      * @returns Map of all available assets
      */
-    protected getAssets(): Promise<Map<string, PoolAsset>>;
+    protected getAssets(pools: PoolBase[]): Promise<Map<string, PoolAsset>>;
     /**
-     * Calculate and return all possible paths for best swap tokenIn>tokenOut
+     * Calculate and return all possible paths for best swap assetIn>assetOut
      *
-     * @param tokenIn - Storage key of tokenIn
-     * @param tokenOut - Storage key of tokenOut
+     * @param assetIn - Storage key of assetIn
+     * @param assetOut - Storage key of assetOut
      * @param poolsMap - pools map
      * @param pools - pools
      * @returns All possible paths containing route hops
      */
-    protected getPaths(tokenIn: string, tokenOut: string | null, poolsMap: Map<string, Pool>, pools: PoolBase[]): Hop[][];
+    protected getPaths(assetIn: string, assetOut: string | null, poolsMap: Map<string, Pool>, pools: PoolBase[]): Hop[][];
     /**
      * Ckeck if input asset pair is valid and throw expection if not
      *
-     * @param tokenIn - Storage key of tokenIn
-     * @param tokenOut - Storage key of tokenOut
+     * @param assetIn - Storage key of assetIn
+     * @param assetOut - Storage key of assetOut
      * @returns Pool assets & map
      */
-    protected validateTokenPair(tokenIn: string, tokenOut: string, pools: PoolBase[]): Promise<{
+    protected validateTokenPair(assetIn: string, assetOut: string, pools: PoolBase[]): Promise<{
         assets: Map<string, PoolAsset>;
         poolsMap: Map<string, Pool>;
     }>;
     /**
-     * Ckeck if input asset is valid and throw expection if not
+     * Ckeck if input asset is valid and throw exception if not
      *
      * @param token - Storage key of token
      * @returns Pool assets & map

package/dist/types/api/tradeRouter.d.ts

@@ -1,41 +1,57 @@
 import { Router } from './router';
-import { Trade } from '../types';
+import { Trade, Amount } from '../types';
 import { BigNumber } from '../utils/bignumber';
 export declare class TradeRouter extends Router {
     /**
-     * Calculate and return best possible sell trade for tokenIn>tokenOut
+     * Calculate and return best possible spot price for tokenIn>tokenOut
      *
-     * @param {string} tokenIn - Storage key of tokenIn
-     * @param {string} tokenOut - Storage key of tokenOut
-     * @param {BigNumber} amountIn - Amount of tokenIn to sell for tokenOut
+     * @param {string} assetIn - Storage key of tokenIn
+     * @param {string} assetOut - Storage key of tokenOut
+     * @return Best possible spot price of given token pair
+     */
+    getBestSpotPrice(assetIn: string, assetOut: string): Promise<Amount>;
+    /**
+     * Calculate and return spot price for given path
+     *
+     * @param path - current path
+     * @param poolsMap - pools map
+     * @returns Spot price for given path
+     */
+    private getSpotPrice;
+    /**
+     * Calculate and return best possible sell trade for assetIn>assetOut
+     *
+     * @param {string} assetIn - Storage key of assetIn
+     * @param {string} assetOut - Storage key of assetOut
+     * @param {BigNumber} amountIn - Amount of assetIn to sell for assetOut
      * @returns Best possible sell trade of given token pair
      */
-    getBestSell(tokenIn: string, tokenOut: string, amountIn: BigNumber | string | number): Promise<Trade>;
+    getBestSell(assetIn: string, assetOut: string, amountIn: BigNumber | string | number): Promise<Trade>;
     /**
      * Calculate and return sell swaps for given path
      * - final amount of previous swap is entry to next one
      *
-     * @param amountIn - Amount of tokenIn to sell for tokenOut
+     * @param amountIn - Amount of assetIn to sell for assetOut
      * @param path - current path
      * @param poolsMap - pools map
      * @returns Sell swaps for given path with corresponding pool pairs
      */
     private toSellSwaps;
     /**
-     * Calculate and return best possible buy trade for tokenIn>tokenOut
+     * Calculate and return best possible buy trade for assetIn>assetOut
      *
-     * @param {string} tokenIn - Storage key of tokenIn
-     * @param {string} tokenOut - Storage key of tokenOut
+     * @param {string} assetIn - Storage key of assetIn
+     * @param {string} assetOut - Storage key of assetOut
      * @param {BigNumber} amountOut - Amount of tokenOut to buy for tokenIn
      * @returns Best possible buy trade of given token pair
      */
-    getBestBuy(tokenIn: string, tokenOut: string, amountOut: BigNumber | string | number): Promise<Trade>;
+    getBestBuy(assetIn: string, assetOut: string, amountOut: BigNumber | string | number): Promise<Trade>;
     /**
      * Calculate and return buy swaps for given path
      * - final amount of previous swap is entry to next one
-     * - calculation is done backwards
+     * - calculation is done backwards (swaps in reversed order)
      *
-     * @param amountOut - Amount of tokenOut to buy for tokenIn
+     * @param amountOut - Amount of assetOut to buy for assetIn
      * @param path - current path
      * @param poolsMap - pools map
      * @returns Buy swaps for given path

package/dist/types/client/index.d.ts

@@ -1 +1 @@
-export { PolkadotClient } from './polkadot';
+export { PolkadotApiClient } from './polkadotApi';

package/dist/types/client/polkadotApi.d.ts

@@ -0,0 +1,17 @@
+import { ApiPromise } from '@polkadot/api';
+import type { StorageKey } from '@polkadot/types';
+import type { AnyTuple, Codec } from '@polkadot/types/types';
+import type { AssetMetadata } from '@polkadot/types/interfaces';
+import type { PoolToken } from '../types';
+import '@polkadot/api-augment';
+export declare class PolkadotApiClient {
+    protected readonly api: ApiPromise;
+    constructor(api: ApiPromise);
+    getStorageKey(asset: [StorageKey<AnyTuple>, Codec], index: number): string;
+    getStorageEntryArray(asset: [StorageKey<AnyTuple>, Codec]): string[];
+    getPoolTokens(poolAddress: string, assetKeys: string[]): Promise<PoolToken[]>;
+    getAssetMetadata(tokenKey: string): Promise<AssetMetadata>;
+    getAccountBalance(accountId: string, tokenKey: string): Promise<string>;
+    getSystemAccountBalance(accountId: string): Promise<string>;
+    getTokenAccountBalance(accountId: string, tokenKey: string): Promise<string>;
+}

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
 export { Router, TradeRouter } from './api';
-export { PolkadotPoolService, PoolFactory, XykPool } from './pool';
+export { PolkadotApiPoolService, PoolFactory, XykPool } from './pool';
 export * from './types';
 export * from './utils/bignumber';

package/dist/types/pool/index.d.ts

@@ -1,3 +1,3 @@
-export { PolkadotPoolService } from './polkadotPoolService';
+export { PolkadotApiPoolService } from './polkadotApiPoolService';
 export { PoolFactory } from './poolFactory';
 export { XykPool } from './xyk/xykPool';

package/dist/types/pool/lbp/lbpMath.d.ts

@@ -0,0 +1,13 @@
+declare function getSpotPrice(s: string, b: string, s_w: string, b_w: string, a: string): string;
+declare function calculateInGivenOut(s: string, b: string, s_w: string, b_w: string, a: string): string;
+declare function calculateOutGivenIn(s: string, b: string, s_w: string, b_w: string, a: string): string;
+declare function calculateLinearWeights(start_x: string, end_x: string, start_y: string, end_y: string, at: string): string;
+declare function calculatePoolTradeFee(a: string, fee_numerator: number, fee_denominator: number): string;
+declare const _default: {
+    getSpotPrice: typeof getSpotPrice;
+    calculateInGivenOut: typeof calculateInGivenOut;
+    calculateOutGivenIn: typeof calculateOutGivenIn;
+    calculateLinearWeights: typeof calculateLinearWeights;
+    calculatePoolTradeFee: typeof calculatePoolTradeFee;
+};
+export default _default;

package/dist/types/pool/lbp/lbpPolkadotApiClient.d.ts

@@ -0,0 +1,20 @@
+import { PolkadotApiClient } from '../../client';
+import { PoolBase, PoolFee } from '../../types';
+interface LbpPoolData {
+    readonly assets: string[];
+    readonly feeCollector: string;
+    readonly fee: number[];
+    readonly repayTarget: string;
+    readonly initialWeight: number;
+    readonly finalWeight: number;
+    readonly start: number;
+    readonly end: number;
+}
+export declare class LbpPolkadotApiClient extends PolkadotApiClient {
+    private readonly MAX_FINAL_WEIGHT;
+    getPools(): Promise<PoolBase[]>;
+    getLinearWeight(poolEntry: LbpPoolData): Promise<string>;
+    getRepayFee(): PoolFee;
+    isRepayFeeApplied(assetKey: string, poolEntry: LbpPoolData): Promise<boolean>;
+}
+export {};

package/dist/types/pool/lbp/lbpPool.d.ts

@@ -0,0 +1,40 @@
+import { BuyTransfer, Pool, PoolBase, PoolFee, PoolPair, PoolToken, PoolType, SellTransfer } from '../../types';
+import { BigNumber } from '../../utils/bignumber';
+export declare type WeightedPoolPair = PoolPair & {
+    weightIn: BigNumber;
+    weightOut: BigNumber;
+};
+export declare type WeightedPoolToken = PoolToken & {
+    weight: BigNumber;
+};
+export declare class LbpPool implements Pool {
+    type: PoolType;
+    address: string;
+    tradeFee: PoolFee;
+    tokens: WeightedPoolToken[];
+    repayFee: PoolFee;
+    repayFeeApply: boolean;
+    static fromPool(pool: PoolBase): LbpPool;
+    constructor(address: string, swapFee: PoolFee, tokens: WeightedPoolToken[], repayFee: PoolFee, repayFeeApply: boolean);
+    validPair(_tokenIn: string, _tokenOut: string): boolean;
+    parsePoolPair(tokenIn: string, tokenOut: string): WeightedPoolPair;
+    /**
+     * Validate buy transfer
+     *
+     * a) Accumulated asset is bought (out) from the pool for distributed asset (in) - User(Buyer) bears the fee
+     * b) Distributed asset is bought (out) from the pool for accumualted asset (in) - Pool bears the fee
+     */
+    validateBuy(poolPair: WeightedPoolPair, amountOut: BigNumber): BuyTransfer;
+    /**
+     * Validate sell transfer
+     *
+     * a) Accumulated asset is sold (in) to the pool for distributed asset (out) - Pool bears the fee
+     * b) Distributed asset is sold (in) to the pool for accumualted asset (out) - User(Seller) bears the fee
+     */
+    validateSell(poolPair: WeightedPoolPair, amountIn: BigNumber): SellTransfer;
+    calculateInGivenOut(poolPair: WeightedPoolPair, amountOut: BigNumber): BigNumber;
+    calculateOutGivenIn(poolPair: WeightedPoolPair, amountIn: BigNumber): BigNumber;
+    spotPriceInGivenOut(poolPair: WeightedPoolPair): BigNumber;
+    spotPriceOutGivenIn(poolPair: WeightedPoolPair): BigNumber;
+    calculateTradeFee(amount: BigNumber): BigNumber;
+}

package/dist/types/pool/polkadotApiPoolService.d.ts

@@ -0,0 +1,10 @@
+import { Hop, PoolBase, PoolService, Transaction } from '../types';
+import { ApiPromise } from '@polkadot/api';
+import { BigNumber } from '../utils/bignumber';
+export declare class PolkadotApiPoolService implements PoolService {
+    private readonly api;
+    constructor(api: ApiPromise);
+    getPools(): Promise<PoolBase[]>;
+    buildBuyTx(assetIn: string, assetOut: string, amountOut: BigNumber, maxAmountIn: BigNumber, route: Hop[]): Transaction;
+    buildSellTx(assetIn: string, assetOut: string, amountIn: BigNumber, minAmountOut: BigNumber, route: Hop[]): Transaction;
+}

package/dist/types/pool/xyk/xykMath.d.ts

@@ -1,9 +1,11 @@
 declare function getSpotPrice(a: string, b: string, c: string): string;
 declare function calculateInGivenOut(a: string, b: string, c: string): string;
 declare function calculateOutGivenIn(a: string, b: string, c: string): string;
+declare function calculatePoolTradeFee(a: string, fee_numerator: number, fee_denominator: number): string;
 declare const _default: {
     getSpotPrice: typeof getSpotPrice;
     calculateInGivenOut: typeof calculateInGivenOut;
     calculateOutGivenIn: typeof calculateOutGivenIn;
+    calculatePoolTradeFee: typeof calculatePoolTradeFee;
 };
 export default _default;

package/dist/types/pool/xyk/xykPolkadotApiClient.d.ts

@@ -0,0 +1,6 @@
+import { PolkadotApiClient } from '../../client';
+import { PoolBase, PoolFee } from '../../types';
+export declare class XykPolkadotApiClient extends PolkadotApiClient {
+    getPools(): Promise<PoolBase[]>;
+    getTradeFee(): PoolFee;
+}

package/dist/types/pool/xyk/xykPool.d.ts

@@ -1,16 +1,19 @@
-import { Pool, PoolBase, PoolPair, PoolToken, PoolType } from '../../types';
+import { BuyTransfer, Pool, PoolBase, PoolFee, PoolPair, PoolToken, PoolType, SellTransfer } from '../../types';
 import { BigNumber } from '../../utils/bignumber';
 export declare class XykPool implements Pool {
     type: PoolType;
     address: string;
-    tradeFee: string;
+    tradeFee: PoolFee;
     tokens: PoolToken[];
     static fromPool(pool: PoolBase): XykPool;
-    constructor(address: string, swapFee: string, tokens: PoolToken[]);
+    constructor(address: string, swapFee: PoolFee, tokens: PoolToken[]);
     validPair(_tokenIn: string, _tokenOut: string): boolean;
     parsePoolPair(tokenIn: string, tokenOut: string): PoolPair;
+    validateBuy(poolPair: PoolPair, amountOut: BigNumber): BuyTransfer;
+    validateSell(poolPair: PoolPair, amountIn: BigNumber): SellTransfer;
     calculateInGivenOut(poolPair: PoolPair, amountOut: BigNumber): BigNumber;
-    getSpotPriceIn(poolPair: PoolPair): BigNumber;
     calculateOutGivenIn(poolPair: PoolPair, amountIn: BigNumber): BigNumber;
-    getSpotPriceOut(poolPair: PoolPair): BigNumber;
+    spotPriceInGivenOut(poolPair: PoolPair): BigNumber;
+    spotPriceOutGivenIn(poolPair: PoolPair): BigNumber;
+    calculateTradeFee(amount: BigNumber): BigNumber;
 }

package/dist/types/types.d.ts

@@ -1,6 +1,6 @@
 import { BigNumber } from './utils/bignumber';
 export declare type PoolAsset = {
-    token: string;
+    id: string;
     symbol: string;
 };
 export declare enum PoolType {
@@ -9,10 +9,17 @@ export declare enum PoolType {
     Stable = "Stable",
     Omni = "Omni"
 }
+export declare enum PoolError {
+    TradingLimitReached = "TradingLimitReached",
+    InsufficientTradingAmount = "InsufficientTradingAmount",
+    InsufficientBalance = "InsufficientBalance",
+    MaxInRatioExceeded = "MaxInRatioExceeded",
+    AssetAmountNotReachedLimit = "AssetAmountNotReachedLimit",
+    AssetAmountExceededLimit = "AssetAmountExceededLimit"
+}
 export interface PoolPair {
-    tradeFee: BigNumber;
-    tokenIn: string;
-    tokenOut: string;
+    assetIn: string;
+    assetOut: string;
     decimalsIn: number;
     decimalsOut: number;
     balanceIn: BigNumber;
@@ -21,61 +28,85 @@ export interface PoolPair {
 export declare type PoolBase = {
     address: string;
     type: PoolType;
-    tradeFee: string;
+    tradeFee: PoolFee;
     tokens: PoolToken[];
+    repayFee?: PoolFee;
+    repayFeeApply?: boolean;
 };
-export declare type PoolToken = {
-    id: string;
+export declare type PoolFee = [numerator: number, denominator: number];
+export declare type PoolToken = PoolAsset & {
     balance: string;
     decimals: number;
-    symbol: string;
 };
+export declare type PoolSell = {
+    calculatedOut: BigNumber;
+};
+export declare type PoolBuy = {
+    calculatedIn: BigNumber;
+};
+export declare type Transfer = {
+    amountIn: BigNumber;
+    amountOut: BigNumber;
+    feePct: number;
+    errors: PoolError[];
+};
+export declare type SellTransfer = Transfer & PoolSell;
+export declare type BuyTransfer = Transfer & PoolBuy;
 export interface Pool extends PoolBase {
     validPair(tokenIn: string, tokenOut: string): boolean;
     parsePoolPair(tokenIn: string, tokenOut: string): PoolPair;
+    validateBuy(poolPair: PoolPair, amountOut: BigNumber): BuyTransfer;
+    validateSell(poolPair: PoolPair, amountOut: BigNumber): SellTransfer;
     calculateInGivenOut(poolPair: PoolPair, amountOut: BigNumber): BigNumber;
     calculateOutGivenIn(poolPair: PoolPair, amountIn: BigNumber): BigNumber;
-    getSpotPriceIn(poolPair: PoolPair): BigNumber;
-    getSpotPriceOut(poolPair: PoolPair): BigNumber;
+    spotPriceInGivenOut(poolPair: PoolPair): BigNumber;
+    spotPriceOutGivenIn(poolPair: PoolPair): BigNumber;
+    calculateTradeFee(amount: BigNumber): BigNumber;
 }
 export interface PoolService {
     getPools(): Promise<PoolBase[]>;
+    buildBuyTx(assetIn: string, assetOut: string, amountOut: BigNumber, maxAmountIn: BigNumber, route: Hop[]): Transaction;
+    buildSellTx(assetIn: string, assetOut: string, amountIn: BigNumber, minAmountOut: BigNumber, route: Hop[]): Transaction;
+}
+export interface Transaction {
+    hex: string;
+    name?: string;
+    get<T>(): T;
 }
 export declare type Hop = {
     poolType: PoolType;
     poolId: string;
-    tokenIn: string;
-    tokenOut: string;
-    tradeFeePct: string;
+    assetIn: string;
+    assetOut: string;
 };
-export declare type Swap = Humanizer & Hop & {
-    tokenInDecimals: number;
-    tokenOutDecimals: number;
+export declare type Swap = Hop & Humanizer & {
+    assetInDecimals: number;
+    assetOutDecimals: number;
     amountIn: BigNumber;
     amountOut: BigNumber;
-    finalAmount: BigNumber;
-    tradeFee: BigNumber;
     spotPrice: BigNumber;
-    priceImpactPct: BigNumber;
-};
-export declare type SellSwap = Swap & {
-    calculatedOut: BigNumber;
-};
-export declare type BuySwap = Swap & {
-    calculatedIn: BigNumber;
+    tradeFeePct: number;
+    priceImpactPct: number;
 };
+export declare type SellSwap = Swap & PoolSell;
+export declare type BuySwap = Swap & PoolBuy;
 export declare enum TradeType {
     Buy = "Buy",
     Sell = "Sell"
 }
-export declare type Trade = Humanizer & {
+export interface Trade extends Humanizer {
     type: TradeType;
     amountIn: BigNumber;
     amountOut: BigNumber;
     spotPrice: BigNumber;
-    priceImpactPct: BigNumber;
+    priceImpactPct: number;
     swaps: Swap[];
-};
+    toTx(tradeLimit: BigNumber): Transaction;
+}
 export interface Humanizer {
     toHuman(): any;
 }
+export declare type Amount = {
+    amount: BigNumber;
+    decimals: number;
+};

package/dist/types/utils/mapper.d.ts

@@ -0,0 +1,4 @@
+import { PoolFee } from '../types';
+import { BigNumber } from './bignumber';
+export declare function toHuman(amount: BigNumber, decimals: number): string;
+export declare function toPct(fee: PoolFee): number;

package/dist/types/utils/math.d.ts

@@ -1,16 +1,13 @@
 import { BigNumber } from './bignumber';
-export declare function pctToBn(pct: string): BigNumber;
-export declare function calculateTradeFee(amount: BigNumber, tradeFee: BigNumber): BigNumber;
 /**
  * Percentage Difference Formula
  *
  * (|𝑉1−𝑉2| / [(𝑉1+𝑉2)/2]) × 100
  *
- * @param amount - Amount of token in/out
- * @param decimals - Decimals of given token
+ * @param amount - Amount of asset in/out
+ * @param decimals - Decimals of given asset
  * @param spotPrice - Spot price
- * @param calculatedPrice - Calculated price
+ * @param calculatedAmount - Calculated amount of asset out/in
  * @returns Price impact percentage
  */
-export declare function calculatePriceImpact(amount: BigNumber, decimals: number, spotPrice: BigNumber, calculatedPrice: BigNumber): BigNumber;
-export declare function formatAmount(amount: BigNumber, decimals: number): string;
+export declare function calculatePriceImpact(amount: BigNumber, decimals: number, spotPrice: BigNumber, calculatedAmount: BigNumber): BigNumber;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacticcouncil/sdk",
-  "version": "0.0.1-beta.10",
+  "version": "0.0.1-beta.12",
   "private": false,
   "description": "Galactic SDK",
   "author": "Pavol Noha <palo@hydradx.io>",
@@ -26,6 +26,7 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
+    "@galacticcouncil/math-lbp": "^0.0.0-beta-1",
     "@galacticcouncil/math-xyk": "^0.0.0-beta-1",
     "@polkadot/api": "^9.0.1",
     "bignumber.js": "^9.1.0",