@galacticcouncil/sdk 0.0.6 → 0.0.7

package/dist/types/api/{router.d.ts → Router.d.ts}

@@ -1,5 +1,5 @@
 import { PoolService, PoolBase, Hop, Pool, PoolAsset, PoolType } from '../types';
-export declare type RouterOptions = {
+export type RouterOptions = {
     includeOnly?: PoolType[];
 };
 export declare class Router {

package/dist/types/api/{tradeRouter.d.ts → TradeRouter.d.ts}

@@ -1,23 +1,7 @@
-import { Router } from './router';
+import { Router } from './Router';
 import { Trade, Amount } from '../types';
 import { BigNumber } from '../utils/bignumber';
 export declare class TradeRouter extends Router {
-    /**
-     * Calculate and return best possible spot price for tokenIn>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;
     /**
      * Check whether trade is direct or not
      *
@@ -25,6 +9,13 @@ export declare class TradeRouter extends Router {
      * @returns true if direct trade, otherwise false
      */
     private isDirectTrade;
+    /**
+     * Find best sell swap without errors, if there is none return first one found
+     *
+     * @param swaps - All possible sell routes
+     * @returns best sell swap if exist, otherwise first one found
+     */
+    private findBestSellRoute;
     /**
      * Calculate and return best possible sell trade for assetIn>assetOut
      *
@@ -53,6 +44,21 @@ export declare class TradeRouter extends Router {
      * @returns Sell swaps for given path with corresponding pool pairs
      */
     private toSellSwaps;
+    /**
+     * Calculate and return best possible spot price for tokenIn>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>;
+    /**
+     * Find best buy swap without errors, if there is none return first one found
+     *
+     * @param swaps - All possible sell routes
+     * @returns best sell swap if exist, otherwise first one found
+     */
+    private findBestBuyRoute;
     /**
      * Calculate and return best possible buy trade for assetIn>assetOut
      *

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

@@ -1,2 +1,2 @@
-export { Router } from './router';
-export { TradeRouter } from './tradeRouter';
+export { Router } from './Router';
+export { TradeRouter } from './TradeRouter';

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

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

package/dist/types/errors.d.ts

@@ -5,3 +5,15 @@ export declare class PoolConfigNotFound extends Error {
 export declare class RouteNotFound extends Error {
     constructor(assetIn: string, assetOut: string);
 }
+export declare class AssetNotFound extends Error {
+    constructor(asset: string);
+}
+export declare class StorageConfigNotFound extends Error {
+    constructor(param: string);
+}
+export declare class SubscriptionNotSupported extends Error {
+    constructor(subscriptionType: string);
+}
+export declare class ProviderConfigNotFound extends Error {
+    constructor(message: string);
+}

package/dist/types/index.d.ts

@@ -1,5 +1,8 @@
 export { Router, TradeRouter } from './api';
 export * from './pool';
+export * from './registry';
+export * from './storage';
+export * from './wallet';
 export * from './types';
 export * from './errors';
 export * from './consts';

package/dist/types/pool/{polkadotApiPoolService.d.ts → PolkadotApiPoolService.d.ts}

@@ -1,7 +1,7 @@
 import { Hop, PoolBase, PoolService, PoolType, Transaction } from '../types';
-import { XykPolkadotApiClient } from './xyk/xykPolkadotApiClient';
-import { LbpPolkadotApiClient } from './lbp/lbpPolkadotApiClient';
-import { OmniPolkadotApiClient } from './omni/omniPolkadotApiClient';
+import { XykPolkadotApiClient } from './xyk/XykPolkadotApiClient';
+import { LbpPolkadotApiClient } from './lbp/LbpPolkadotApiClient';
+import { OmniPolkadotApiClient } from './omni/OmniPolkadotApiClient';
 import { BigNumber } from '../utils/bignumber';
 import { ApiPromise } from '@polkadot/api';
 export declare class PolkadotApiPoolService implements PoolService {

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

@@ -1,8 +1,8 @@
-export { PolkadotApiPoolService } from './polkadotApiPoolService';
-export { PoolFactory } from './poolFactory';
-export { XykPool } from './xyk/xykPool';
-export { XykMath } from './xyk/xykMath';
-export { OmniPool } from './omni/omniPool';
-export { OmniMath } from './omni/omniMath';
-export { LbpPool } from './lbp/lbpPool';
-export { LbpMath } from './lbp/lbpMath';
+export { PolkadotApiPoolService } from './PolkadotApiPoolService';
+export { PoolFactory } from './PoolFactory';
+export { XykPool } from './xyk/XykPool';
+export { XykMath } from './xyk/XykMath';
+export { OmniPool } from './omni/OmniPool';
+export { OmniMath } from './omni/OmniMath';
+export { LbpPool } from './lbp/LbpPool';
+export { LbpMath } from './lbp/LbpMath';

package/dist/types/pool/lbp/{lbpPool.d.ts → LbpPool.d.ts}

@@ -1,13 +1,13 @@
 import { BuyTransfer, Pool, PoolBase, PoolFee, PoolPair, PoolToken, PoolType, SellTransfer } from '../../types';
 import { BigNumber } from '../../utils/bignumber';
-export declare type WeightedPoolPair = PoolPair & {
+export type WeightedPoolPair = PoolPair & {
     weightIn: BigNumber;
     weightOut: BigNumber;
 };
-export declare type WeightedPoolToken = PoolToken & {
+export type WeightedPoolToken = PoolToken & {
     weight: BigNumber;
 };
-export declare type LbpPoolBase = PoolBase & {
+export type LbpPoolBase = PoolBase & {
     repayFee: PoolFee;
     repayFeeApply: boolean;
 };

package/dist/types/pool/omni/{omniPool.d.ts → OmniPool.d.ts}

@@ -1,16 +1,16 @@
 import { BuyTransfer, Pool, PoolBase, PoolFee, PoolPair, PoolToken, PoolType, SellTransfer } from '../../types';
 import { BigNumber } from '../../utils/bignumber';
-export declare type OmniPoolPair = PoolPair & {
+export type OmniPoolPair = PoolPair & {
     hubReservesIn: BigNumber;
     hubReservesOut: BigNumber;
     sharesIn: BigNumber;
     sharesOut: BigNumber;
 };
-export declare type OmniPoolToken = PoolToken & {
+export type OmniPoolToken = PoolToken & {
     hubReserves: BigNumber;
     shares: BigNumber;
 };
-export declare type OmniPoolBase = PoolBase & {
+export type OmniPoolBase = PoolBase & {
     assetFee: PoolFee;
     protocolFee: PoolFee;
     hubAssetId: string;

package/dist/types/registry/Registry.d.ts

@@ -0,0 +1,20 @@
+import { Chain, ChainAsset } from './types';
+declare abstract class Registry {
+    protected chains: Chain[];
+    protected assets: Record<number, ChainAsset[]>;
+    constructor();
+    protected abstract initChains(): void;
+    protected abstract initAssets(): void;
+    getChains(): Chain[];
+    getChain(chainId: number): Chain;
+    getAssets(chainId: number): ChainAsset[];
+}
+export declare class PolkadotRegistry extends Registry {
+    protected initChains(): void;
+    protected initAssets(): void;
+}
+export declare class KusamaRegistry extends Registry {
+    protected initChains(): void;
+    protected initAssets(): void;
+}
+export {};

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

@@ -0,0 +1,2 @@
+export { PolkadotRegistry, KusamaRegistry } from './Registry';
+export { Chain, ChainAsset, ChainAssetType } from './types';

package/dist/types/registry/types.d.ts

@@ -0,0 +1,22 @@
+export interface Chain {
+    chainkey: string;
+    name: string;
+    id: string;
+    paraID: number;
+    WSEndpoints: string[];
+    relaychain: string;
+}
+export interface ChainAssetType {
+    Erc20: string;
+    ForeignAsset: string;
+    LiquidCrowdloan: string;
+    StableAsset: string;
+    Token: string;
+}
+export interface ChainAsset {
+    asset: ChainAssetType;
+    name: string;
+    symbol: string;
+    decimals: number;
+    xcmInteriorKey: string;
+}

package/dist/types/route/bfs.d.ts

@@ -1,5 +1,5 @@
-export declare type Path = Node[];
-export declare type Node = [id: number, from: string];
+export type Path = Node[];
+export type Node = [id: number, from: string];
 /**
  * Breadth First Search.
  *

package/dist/types/route/graph.d.ts

@@ -1,6 +1,6 @@
 import { PoolBase } from '../types';
-export declare type Edge = [address: string, from: string, to: string];
-export declare type NodeEdges = {
+export type Edge = [address: string, from: string, to: string];
+export type NodeEdges = {
     [node: string]: Edge[];
 };
 /**

package/dist/types/storage/Storage.d.ts

@@ -0,0 +1,18 @@
+import { ApiPromise, ApiRx } from '@polkadot/api';
+import { Observable } from 'rxjs';
+export type StorageOptions = {
+    api: ApiPromise | ApiRx;
+    path: string;
+    params: any[];
+};
+export declare class Storage<T> {
+    readonly options: StorageOptions;
+    private subject;
+    constructor(options: StorageOptions);
+    static create<T>(options: StorageOptions): Storage<T>;
+    get observable(): Observable<T>;
+    private subscribeWithApiPromise;
+    private subscribeWithApiRx;
+    private getQuery;
+    private subscribe;
+}

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

@@ -0,0 +1 @@
+export { Storage } from './Storage';

package/dist/types/types.d.ts

@@ -1,5 +1,5 @@
 import { BigNumber } from './utils/bignumber';
-export declare type PoolAsset = {
+export type PoolAsset = {
     id: string;
     symbol: string;
 };
@@ -22,7 +22,7 @@ export interface PoolPair {
     balanceIn: BigNumber;
     balanceOut: BigNumber;
 }
-export declare type PoolBase = {
+export type PoolBase = {
     address: string;
     type: PoolType;
     tradeFee: PoolFee;
@@ -31,26 +31,26 @@ export declare type PoolBase = {
     maxOutRatio: number;
     minTradingLimit: number;
 };
-export declare type PoolLimits = Pick<PoolBase, 'maxInRatio' | 'maxOutRatio' | 'minTradingLimit'>;
-export declare type PoolFee = [numerator: number, denominator: number];
-export declare type PoolToken = PoolAsset & {
+export type PoolLimits = Pick<PoolBase, 'maxInRatio' | 'maxOutRatio' | 'minTradingLimit'>;
+export type PoolFee = [numerator: number, denominator: number];
+export type PoolToken = PoolAsset & {
     balance: string;
     decimals: number;
 };
-export declare type PoolSell = {
+export type PoolSell = {
     calculatedOut: BigNumber;
 };
-export declare type PoolBuy = {
+export type PoolBuy = {
     calculatedIn: BigNumber;
 };
-export declare type Transfer = {
+export type Transfer = {
     amountIn: BigNumber;
     amountOut: BigNumber;
     feePct: number;
     errors: PoolError[];
 };
-export declare type SellTransfer = Transfer & PoolSell;
-export declare type BuyTransfer = Transfer & PoolBuy;
+export type SellTransfer = Transfer & PoolSell;
+export type BuyTransfer = Transfer & PoolBuy;
 export interface Pool extends PoolBase {
     validPair(tokenIn: string, tokenOut: string): boolean;
     parsePoolPair(tokenIn: string, tokenOut: string): PoolPair;
@@ -72,13 +72,13 @@ export interface Transaction {
     name?: string;
     get<T>(): T;
 }
-export declare type Hop = {
+export type Hop = {
     poolType: PoolType;
     poolId: string;
     assetIn: string;
     assetOut: string;
 };
-export declare type Swap = Hop & Humanizer & {
+export type Swap = Hop & Humanizer & {
     assetInDecimals: number;
     assetOutDecimals: number;
     amountIn: BigNumber;
@@ -88,8 +88,8 @@ export declare type Swap = Hop & Humanizer & {
     priceImpactPct: number;
     errors: PoolError[];
 };
-export declare type SellSwap = Swap & PoolSell;
-export declare type BuySwap = Swap & PoolBuy;
+export type SellSwap = Swap & PoolSell;
+export type BuySwap = Swap & PoolBuy;
 export declare enum TradeType {
     Buy = "Buy",
     Sell = "Sell"
@@ -108,7 +108,13 @@ export interface Trade extends Humanizer {
 export interface Humanizer {
     toHuman(): any;
 }
-export declare type Amount = {
+export type Amount = {
     amount: BigNumber;
     decimals: number;
 };
+export interface AssetBalance {
+    free: BigNumber;
+    locked: BigNumber;
+    reserved: BigNumber;
+    available: BigNumber;
+}

package/dist/types/wallet/Wallet.d.ts

@@ -0,0 +1,21 @@
+import { ApiPromise, ApiRx } from '@polkadot/api';
+import { ChainAsset } from '../registry';
+import { BalanceAdapter, EvmProvider } from './types';
+import { Observable } from 'rxjs';
+import { AssetBalance } from '../types';
+interface WalletConfigs {
+    evmProvider?: EvmProvider;
+}
+export declare class Wallet {
+    readonly api: ApiPromise | ApiRx;
+    readonly assets: ChainAsset[];
+    readonly adapters: Record<string, BalanceAdapter>;
+    constructor(api: ApiPromise | ApiRx, assets: ChainAsset[], cfg?: WalletConfigs);
+    getAssets(): ChainAsset[];
+    getAsset(assetSymbol: string, assetType?: string): ChainAsset | undefined;
+    subscribeBalance(assetSymbol: string, assetType: string | undefined, address: string): Observable<AssetBalance>;
+    getBalance(assetSymbol: string, assetType: string | undefined, address: string): Promise<AssetBalance>;
+    private validateAsset;
+    private validateAdapter;
+}
+export {};

package/dist/types/wallet/balance/Erc20BalanceAdapter.d.ts

@@ -0,0 +1,11 @@
+import { AbstractProvider } from 'ethers';
+import { Observable } from 'rxjs';
+import { AssetBalance } from '../../types';
+import { ChainAsset } from '../../registry';
+import { BalanceAdapter, EvmProvider } from '../types';
+export declare class Erc20BalanceAdapter implements BalanceAdapter {
+    readonly client: AbstractProvider;
+    readonly evmProvider: EvmProvider;
+    constructor(evmProvider: EvmProvider);
+    getObserver(asset: ChainAsset, address: string): Observable<AssetBalance>;
+}

package/dist/types/wallet/balance/NativeBalanceAdapter.d.ts

@@ -0,0 +1,14 @@
+import { ApiPromise, ApiRx } from '@polkadot/api';
+import { AssetBalance } from '../../types';
+import { BigNumber } from '../../utils/bignumber';
+import { Observable } from 'rxjs';
+import { ChainAsset } from '../../registry';
+import { BalanceAdapter } from '../types';
+export declare abstract class NativeBalanceAdapter implements BalanceAdapter {
+    readonly nativeToken: string;
+    readonly decimals: number;
+    readonly ed: BigNumber;
+    constructor(api: ApiPromise | ApiRx);
+    private getDeposit;
+    abstract getObserver(token: ChainAsset, address: string): Observable<AssetBalance>;
+}

package/dist/types/wallet/balance/TokenBalanceAdapter.d.ts

@@ -0,0 +1,12 @@
+import { ApiPromise, ApiRx } from '@polkadot/api';
+import { AssetBalance } from '../../types';
+import { Observable } from 'rxjs';
+import { ChainAsset } from '../../registry';
+import { NativeBalanceAdapter } from './NativeBalanceAdapter';
+export declare class TokenBalanceAdapter extends NativeBalanceAdapter {
+    private storages;
+    constructor(api: ApiPromise | ApiRx);
+    getObserver(asset: ChainAsset, address: string): Observable<AssetBalance>;
+    private getSystemAccountBalanceObserver;
+    private getTokenAccountBalanceObserver;
+}

package/dist/types/wallet/evm/AcalaEvmProvider.d.ts

@@ -0,0 +1,9 @@
+import { ApiPromise, ApiRx } from '@polkadot/api';
+import { EvmProvider } from '../types';
+export declare class AcalaEvmProvider implements EvmProvider {
+    readonly api: ApiPromise | ApiRx;
+    readonly endpoint: string;
+    constructor(api: ApiPromise | ApiRx, endpoint: string);
+    toEvmAddress(address: string): Promise<string>;
+    getEndpoint(): string;
+}

package/dist/types/wallet/evm/DefaultEvmProvider.d.ts

@@ -0,0 +1,7 @@
+import { EvmProvider } from '../types';
+export declare class DefaultEvmProvider implements EvmProvider {
+    readonly endpoint: string;
+    constructor(endpoint: string);
+    toEvmAddress(address: string): Promise<string>;
+    getEndpoint(): string;
+}

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

@@ -0,0 +1,5 @@
+export { Wallet } from './Wallet';
+export { TokenBalanceAdapter } from './balance/TokenBalanceAdapter';
+export { Erc20BalanceAdapter } from './balance/Erc20BalanceAdapter';
+export { DefaultEvmProvider } from './evm/DefaultEvmProvider';
+export { AcalaEvmProvider } from './evm/AcalaEvmProvider';

package/dist/types/wallet/types.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from 'rxjs';
+import { AssetBalance } from '../types';
+import { ChainAsset } from '../registry';
+export interface BalanceAdapter {
+    getObserver(asset: ChainAsset, address: string): Observable<AssetBalance>;
+}
+export interface EvmProvider {
+    toEvmAddress(address: string): Promise<string>;
+    getEndpoint(): string;
+}

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

@@ -0,0 +1,19 @@
+export declare const ADDRESS_FORMAT: {
+    ss58: string;
+    h160: string;
+    snow: string;
+    arctic: string;
+    pubKey: string;
+};
+export declare const CHAIN_PREFIX: {
+    snow: number;
+    ss58: number;
+    arctic: number;
+};
+export declare function convertH160ToSs58(h160Addr: string): string;
+export declare function convertSs58ToH160(ss58Addr: string): string;
+export declare function getPubKey(ss58addr: string): string;
+export declare function encodePubKey(pubKey: string, prefix: number): string;
+export declare function encodePolkadotAddress(addr: string, prefix: number): string;
+export declare function validateSs58(ss58Addr: string): void;
+export declare function validatePubKey(pubkey: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacticcouncil/sdk",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "private": false,
   "description": "Galactic SDK",
   "author": "Pavol Noha <palo@hydradx.io>",
@@ -8,10 +8,19 @@
   "module": "dist/index.esm.js",
   "types": "dist/types/index.d.ts",
   "scripts": {
+    "build": "node ./esbuild.mjs && tsc --emitDeclarationOnly --outDir dist/types/",
+    "cleanup": "rimraf out && rimraf dist",
     "test": "jest",
     "test:coverage": "jest --coverage",
-    "build": "node ./esbuild.mjs && tsc --emitDeclarationOnly --outDir dist/types/",
-    "cleanup": "rimraf out && rimraf dist"
+    "pckg:build": "npm run cleanup && npm run build",
+    "pckg:release": "npm run pckg:build && standard-version --tag-prefix=''",
+    "pckg:publish": "git push --follow-tags origin master && npm publish",
+    "xcmgr:sync": "node ./xcmgr.sync.mjs"
+  },
+  "standard-version": {
+    "skip": {
+      "changelog": true
+    }
   },
   "devDependencies": {
     "@types/jest": "^28.1.8",
@@ -21,6 +30,7 @@
     "fs-extra": "^10.1.0",
     "prettier": "^2.3.2",
     "rimraf": "^3.0.2",
+    "standard-version": "^9.5.0",
     "ts-jest": "^28.0.8",
     "tsx": "^3.8.2",
     "typescript": "^4.7.4"
@@ -34,6 +44,7 @@
   },
   "peerDependencies": {
     "@polkadot/api": "^9.9.1",
-    "capi": "^0.1.0-beta.12"
+    "capi": "^0.1.0-beta.12",
+    "ethers": "^6.0.5"
   }
 }

package/xcmgr.sync.mjs

@@ -0,0 +1,65 @@
+import { mkdirSync, existsSync, writeFileSync } from 'fs';
+
+const XCMGAR_REPO = 'https://raw.githubusercontent.com/colorfulnotion/xcm-global-registry/main';
+const RELAY_CHAINS = ['kusama', 'polkadot'];
+const DEST = './src/registry/data';
+
+function pairs2Map(pairs) {
+  const result = new Map();
+  pairs.forEach((pair) => result.set(pair[0], pair[1]));
+  return result;
+}
+
+const writeJsonSync = (path, data) => {
+  writeFileSync(path, JSON.stringify(data, null, 4));
+};
+
+const fetchPublicEndpoints = async (relay) => {
+  const response = await fetch(`${XCMGAR_REPO}/publicEndpoints/${relay}_publicEndpoints.json`);
+  return await response.json();
+};
+
+// TODO: Fetch XcAssets
+const fetchXcAssets = async (relay, chainKey) => {
+  const response = await fetch(`${XCMGAR_REPO}/xcAssets/${relay}/${chainKey}_xcAssets.json`);
+  return await response.json();
+};
+
+const fetchAssets = async (relay, chainKey) => {
+  const response = await fetch(`${XCMGAR_REPO}/assets/${relay}/${chainKey}_assets.json`);
+  return await response.json();
+};
+
+const syncAssets = async (relay, chainKeys) => {
+  const assets = await Promise.all(
+    chainKeys
+      .map((chainKey) => chainKey.replace('-', '_'))
+      .map(async (chainKey) => {
+        let assets = [];
+        try {
+          assets = await fetchAssets(relay, chainKey);
+        } catch (err) {}
+        return [chainKey.replace(`${relay}_`, ''), assets];
+      })
+  );
+
+  const assetMap = pairs2Map(assets);
+  const ASSETS_FILE_PATH = `${DEST}/${relay}/assets.json`;
+  writeJsonSync(ASSETS_FILE_PATH, Object.fromEntries(assetMap));
+};
+
+(async () => {
+  RELAY_CHAINS.forEach(async (relay) => {
+    const fld = `${DEST}/${relay}`;
+    if (!existsSync(fld)) {
+      mkdirSync(fld);
+    }
+    const ENDPOINT_FILE_PATH = `${DEST}/${relay}/endpoints.json`;
+    const endpoints = await fetchPublicEndpoints(relay);
+
+    await syncAssets(relay, Object.keys(endpoints));
+
+    writeJsonSync(ENDPOINT_FILE_PATH, Object.values(endpoints));
+    console.log(`${relay} done ✅`);
+  });
+})();