@ultrade/ultrade-js-sdk 0.2.7 → 2.0.0

package/dist/interfaces.d.ts

@@ -0,0 +1,136 @@
+import { STREAMS } from "./enums";
+export interface Signer {
+    signAndSend: ([]: Iterable<any, void, undefined>) => any;
+    signMessage: (msg: string, encoding?: BufferEncoding) => Promise<string>;
+    signMessageByToken: (msg: string, encoding?: BufferEncoding) => Promise<string>;
+}
+export interface TelegramData {
+    auth_date: number;
+    id: number;
+    first_name: string;
+    hash: string;
+    photo_url: string;
+    username: string;
+}
+export interface AppSocketState {
+    address: string;
+    appId: number;
+    orderFilter: string;
+    pairKey: string;
+    pairId: number;
+}
+export interface AuthCredentials {
+    company: string;
+    clientId?: string;
+    clientSecret?: string;
+    mnemonic?: string;
+    signer: Signer;
+}
+export interface WalletCredentials {
+    address: string;
+    chain: string;
+    provider: string;
+    token: string;
+    tradingKey?: string;
+}
+export interface SocketIOClient {
+    connected: boolean;
+    id: string;
+    on: (event: string, handler: (...args: unknown[]) => void) => void;
+    off: (event: string, handler?: (...args: unknown[]) => void) => void;
+    emit: (event: string, ...args: unknown[]) => void;
+    onAny: (handler: (event: string, ...args: unknown[]) => void) => void;
+    disconnect: () => void;
+    io: {
+        on: (event: string, handler: (...args: unknown[]) => void) => void;
+        off: (event: string, handler?: (...args: unknown[]) => void) => void;
+    };
+}
+export interface SocketIOFactory {
+    (url: string, options?: unknown): SocketIOClient;
+}
+export interface ClientOptions {
+    network: 'mainnet' | 'testnet' | 'local';
+    apiUrl?: string;
+    algoSdkClient: any;
+    websocketUrl: string;
+    companyId?: number;
+    socketIO: SocketIOFactory;
+}
+export interface CancelOrderArgs {
+    orderId: number;
+    orderSide: OrderSide;
+    orderType: OrderType;
+    amount: string;
+    price: string;
+    baseTokenAddress: string;
+    baseChain: string;
+    baseCurrency: string;
+    baseDecimal: number;
+    priceTokenAddress: string;
+    priceChain: string;
+    priceCurrency: string;
+    priceDecimal: number;
+}
+export interface CreateOrderArgs {
+    pairId: number;
+    companyId: number;
+    orderSide: OrderSide;
+    orderType: OrderType;
+    amount: string;
+    price: string;
+    decimalPrice: number;
+    address: string;
+    chainId: number;
+    baseTokenAddress: string;
+    baseTokenChainId: number;
+    baseChain: string;
+    baseCurrency: string;
+    baseDecimal: number;
+    priceTokenAddress: string;
+    priceTokenChainId: number;
+    priceChain: string;
+    priceCurrency: string;
+    priceDecimal: number;
+}
+export interface SubscribeOptions {
+    symbol: string;
+    streams: STREAMS[];
+    options: WSOptions;
+}
+interface WSOptions {
+    address: string;
+    token?: string;
+    tradingKey?: string;
+    message?: string;
+    signature?: string;
+    depth?: number;
+    companyId?: number;
+    interval?: string;
+}
+export interface ServerToClientEvents {
+    reconnect: () => void;
+}
+export interface ClientToServerEvents {
+    subscribe: (options: SubscribeOptions) => void;
+    unsubscribe: (options: SubscribeOptions) => void;
+}
+export interface TxnParams {
+    suggestedParams: any;
+    from: string;
+    to: string;
+    amount: number;
+    assetIndex?: number;
+}
+export type OrderSide = 'S' | 'B';
+export type OrderType = 'L' | 'I' | 'P' | 'M';
+export interface UserNotification {
+    id: number;
+    globalNotificationId: number;
+    priority: any;
+    status: any;
+    type: any;
+    message: string;
+    createdAt: Date;
+}
+export {};

package/dist/localStorage.d.ts

@@ -0,0 +1,9 @@
+import { WalletCredentials } from './interfaces';
+export declare class LocalStorageService {
+    private isBrowser;
+    private keys;
+    constructor();
+    setMainWallet(mainWallet: WalletCredentials): void;
+    getMainWallet(): WalletCredentials | null;
+    clearMainWallet(): void;
+}

package/dist/sockets.d.ts

@@ -0,0 +1,30 @@
+import { SubscribeOptions, SocketIOFactory, SocketIOClient } from './interfaces';
+export declare class SocketManager {
+    private onDisconnect?;
+    private onConnectError?;
+    private socket;
+    private socketPool;
+    private websocketUrl;
+    private socketIOFactory;
+    constructor(url: string, socketIOFactory: SocketIOFactory, onDisconnect?: (socketId: string) => void, onConnectError?: (error: Error) => void);
+    private initializeSocket;
+    getSocket(): SocketIOClient | null;
+    subscribe(subscribeOptions: SubscribeOptions, callback: Function): number;
+    unsubscribe(handlerId: number): void;
+    disconnect(): void;
+    isConnected(): boolean;
+    on(event: string, handler: (...args: unknown[]) => void): void;
+    off(event: string, handler?: (...args: unknown[]) => void): void;
+    emit(event: string, ...args: unknown[]): void;
+    emitCurrentPair(data: {
+        address: string;
+        pair: string;
+        pair_id: number;
+        order_filter: string;
+    }): void;
+    emitOrderFilter(data: {
+        order_filter: string;
+    }): void;
+    onReconnect(handler: () => void): () => void;
+    offReconnect(handler?: () => void): void;
+}

package/dist/utils.d.ts

@@ -1,4 +1,2 @@
-import { ABIContract, ABIMethod } from 'algosdk';
-export declare function sqrt(value: bigint): bigint;
-export declare function getMethodByName(contract: ABIContract, name: string): ABIMethod;
-export declare function decodeStateArray(stateArray: any[]): any;
+export declare const unpackData: (data: any) => any;
+export declare const decodeString: (value: Uint8Array) => string;

package/package.json

@@ -1,47 +1,34 @@
 {
   "name": "@ultrade/ultrade-js-sdk",
-  "version": "0.2.7",
-  "description": "Javascript SDK for interaction with the Ultrade AMM system",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "/dist"
-  ],
-  "directories": {
-    "test": "tests"
-  },
+  "version": "2.0.0",
+  "description": "This package contains the original js/ts SDK.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "npm run clean && tsc",
-    "test": "ts-mocha -p ./tsconfig.json -t 1000000 tests/**/*.spec.ts",
-    "lint:fix": "prettier */*.js \"*/**/*{.js,.ts}\" -w",
-    "lint": "prettier */*.js \"*/**/*{.js,.ts}\" --check",
-    "prepack": "npm run build",
-    "clean": "rm -rf ./dist"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ultrade-org/JS-SDK.git"
-  },
-  "author": "",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/ultrade-org/JS-SDK/issues"
+    "build:prod": "webpack --config webpack.config.js --env production=true",
+    "build:dev": "webpack --config webpack.config.js --env production=false",
+    "version:patch": "npm version patch"
   },
-  "homepage": "https://github.com/ultrade-org/JS-SDK#readme",
+  "files": [
+    "dist"
+  ],
   "devDependencies": {
-    "@types/chai": "^4.3.1",
-    "@types/mocha": "^9.1.1",
-    "@types/node": "^18.0.6",
-    "chai": "^4.3.6",
-    "dotenv": "^16.0.1",
-    "mocha": "^10.0.0",
-    "prettier": "^2.7.1",
-    "ts-mocha": "^10.0.0",
-    "ts-node": "^10.9.1",
-    "typescript": "^4.7.4"
+    "@types/node": "^18.7.17",
+    "@types/webpack": "^5.28.5",
+    "ts-loader": "^9.2.3",
+    "ts-node": "^10.0.0",
+    "typescript": "^5.6.3",
+    "webpack": "^5.102.1",
+    "webpack-cli": "^6.0.1",
+    "webpack-node-externals": "^3.0.0"
   },
-  "dependencies": {
-    "algosdk": "^2.1.0"
+  "peerDependencies": {
+    "algosdk": "^2.0.0",
+    "axios": "^1.13.2",
+    "react-secure-storage": "^1.3.2"
   },
-  "keywords": ["Ultrade", "DEX", "AMM", "SDK"]
+  "dependencies": {
+    "@ultrade/shared": "^1.0.2"
+  }
 }

package/README.md

@@ -1,39 +0,0 @@
-# Ultrade JS SDK
-
-## Warning
-SDK is under development
-## Structure of SDK
-
-Three are three classes: `AmmClient`, `TransactionComposer`, `PendingTxnResponse`.
-
-`AmmClient` contains main and util functions.
-
-main: 
-- constructor
-- create a pool for asset a and b
-- bootstrap 
-- add liquidity (mint)
-- remove liquidity (burn)
-- swap
-
-a main function returns an instance of `TransactionComposer`.
-
-utils:
-- get pairs
-- get LP token
-- get pool by assets
-- get pool by LP token
-- get balances of an address
-- get balance of an address per asset
-- check if an address opted in an asset
-
-`TransactionComposer` sign transactions with secret key or algorand session wallet and send them to blockchain. it has `signAndSend` public function returns `PendingTxnResponse`
-
-`PendingTxnResponse` contains transaction infomation.
-
-## Example of Usage
-
-Please checkout unit tests in `tests` folder.
-
-## License
-MIT

package/dist/amm.d.ts

@@ -1,345 +0,0 @@
-import algosdk from 'algosdk';
-import { AssetList, IAssetAmt, PoolList, PoolState, TokenPair, StablePoolState } from './types';
-export declare class PendingTxnResponse {
-    poolError: string;
-    txn: Record<string, any>;
-    applicationIndex: number | undefined;
-    assetIndex: number | undefined;
-    closeRewards: number | undefined;
-    closingAmount: number | undefined;
-    confirmedRound: number | undefined;
-    globalStateDelta: any;
-    localStateDelta: any;
-    receiverRewards: number | undefined;
-    senderRewards: number | undefined;
-    innerTxns: Array<any>;
-    logs: any;
-    constructor(response: Record<string, any>);
-}
-export declare class AmmClient {
-    private client;
-    private appId;
-    private masterContract;
-    private poolContract;
-    private stableContract;
-    private assetsCache;
-    private poolsCache;
-    /**
-     * construct AmmClient
-     *
-     * @param appId master app id
-     * @param cluster one of node
-     */
-    constructor(appId: number, client: algosdk.Algodv2);
-    getAssetCache(): AssetList;
-    getPoolsCache(): PoolList;
-    /**
-     * get status of current node.
-     *
-     * @returns
-     */
-    getStatus(): Promise<Record<string, any>>;
-    /**
-     * check if an asset is stable coin.
-     *
-     * @returns
-     */
-    isStableAsset(asset: number): Promise<boolean>;
-    /**
-     * Returns the common needed parameters for a new transaction.
-     *
-     * @returns
-     */
-    getTransactionParams(): Promise<import("algosdk/dist/types/types/transactions/base").SuggestedParamsWithMinFee>;
-    /**
-     * returns Algodv2 instance.
-     *
-     * @returns
-     */
-    getAlgodClient(): algosdk.Algodv2;
-    /**
-     * create a pool for asset A and B.
-     *
-     * @param sender the sender of transaction
-     * @param assetA
-     * @param assetB
-     * @returns
-     */
-    createPair(sender: string, assetA: number, assetB: number, signer: algosdk.TransactionSigner): Promise<{
-        confirmedRound: number;
-        txIDs: string[];
-        methodResults: algosdk.ABIResult[];
-    }>;
-    /**
-     * Add liquidity to A-B pool
-     *
-     * @param sender the sender of transaction
-     * @param aId id of asset A to send the A-B pool
-     * @param aAmt amount of asset A
-     * @param bId id of asset B
-     * @param bAmt amount of asset B to send the A-B pool
-     * @param mintAmt
-     * @returns
-     */
-    addLiquidity(sender: string, aId: number, aAmt: number | bigint, bId: number, bAmt: number | bigint, mintAmt: number | bigint, signer: algosdk.TransactionSigner): Promise<{
-        confirmedRound: number;
-        txIDs: string[];
-        methodResults: algosdk.ABIResult[];
-    }>;
-    /**
-     * remove liquidity from the pool
-     *
-     * @param sender the sender of transaction
-     * @param poolId
-     * @param poolTokenAmt
-     * @param aMinAmt
-     * @param bMinAmt
-     * @returns
-     */
-    removeLiquidity(sender: string, poolId: number, poolTokenAmt: number | bigint, aMinAmt: number | bigint, bMinAmt: number | bigint, signer: algosdk.TransactionSigner): Promise<{
-        confirmedRound: number;
-        txIDs: string[];
-        methodResults: algosdk.ABIResult[];
-    }>;
-    /**
-     * swap tokens
-     *
-     * @param sender the sender of transaction
-     * @param inId asset id of input
-     * @param inAmt input amount
-     * @param outId asset id of output
-     * @returns
-     */
-    swap(sender: string, inId: number, inAmt: number | bigint, outId: number, slippage: number, signer: algosdk.TransactionSigner): Promise<{
-        confirmedRound: number;
-        txIDs: string[];
-        methodResults: algosdk.ABIResult[];
-    }>;
-    /**
-     * get LP token by asset A and B
-     *
-     * @param assetA
-     * @param assetB
-     * @returns
-     */
-    getPoolToken(assetA: number, assetB: number): Promise<number>;
-    /**
-     * get pool app id by asset A and B
-     *
-     * @param assetA
-     * @param assetB
-     * @returns
-     */
-    getPoolIdByAssets(assetA: number, assetB: number): Promise<number>;
-    /**
-     * get pool app id by LP token
-     * @param tokenId
-     * @returns
-     */
-    getPoolByToken(tokenId: number): Promise<TokenPair>;
-    /**
-     * Get pool by asset A id and asset B id
-     * @param assetA
-     * @param assetB
-     * @returns
-     */
-    getPoolByAssets(assetA: number, assetB: number): Promise<TokenPair>;
-    /**
-     * get all pools
-     *
-     * @returns
-     */
-    getPairs(): Promise<TokenPair[]>;
-    /**
-     * get balances of an address
-     *
-     * @param address
-     * @returns
-     */
-    getBalances(address: string): Promise<any>;
-    /**
-     * get balance of an address per asset
-     *
-     * @param assetId
-     * @param address
-     * @returns
-     */
-    getBalance(assetId: number, address: string): Promise<number | bigint>;
-    /**
-     * check if an address opted in an asset
-     *
-     * @param assetId
-     * @param addr
-     * @returns
-     */
-    isOptedInAsset(assetId: number, addr: string): Promise<boolean>;
-    /**
-     * get assets of addr
-     *
-     * @param addr
-     * @returns
-     */
-    getAssetList(addr: string): Promise<{
-        id: any;
-        name: any;
-    }[]>;
-    /**
-     * get output amount when a user swap A to B
-     *
-     * @param assetIn id of input asset
-     * @param assetOut id of output asset
-     * @param state pool state
-     * @param amtIn input amount
-     * @returns
-     */
-    getSwapOutputByState(assetIn: number, assetOut: number, state: PoolState, amtIn: number | bigint): bigint;
-    /**
-     * get output amount after swap
-     *
-     * @param txId transaction id
-     * @returns
-     */
-    getAmountAfterSwap(txId: string): Promise<number>;
-    /**
-     * Get liquidity token amounts
-     *
-     * @param assetA id of asset A to send the A-B pool
-     * @param assetAAmt amount of asset A
-     * @param assetB id of asset B
-     * @param assetBAmt amount of asset B to send the A-B pool
-     * @returns int
-     */
-    getMintAmt(assetA: number, assetAAmt: number | bigint, assetB: number, assetBAmt: number | bigint): Promise<bigint>;
-    /**
-     * Get liquidity token amounts by pool state
-     *
-     * @param state pool state
-     * @param assetAAmt amount of asset A
-     * @param assetBAmt amount of asset B to send the A-B pool
-     * @returns int
-     */
-    getMintAmtByState(state: PoolState, assetAAmt: number | bigint, assetBAmt: number | bigint): bigint;
-    /**
-     * Make opt-in for asset/pool
-     *
-     * @param sender the sender of transaction
-     * @param assetId id of asset/pool
-     * @param signer transaction signer
-     * @returns
-     */
-    prepareOptInTxn(sender: string, assetId: number, signer: algosdk.TransactionSigner): Promise<{
-        confirmedRound: number;
-        txIDs: string[];
-        methodResults: algosdk.ABIResult[];
-    }>;
-    /**
-     * Get assets amounts after pool token burn
-     *
-     * @param assetA id of asset A
-     * @param assetB id of asset B
-     * @param burnAmt burn amount
-     * @returns
-     */
-    getAssetAmtAfterBurnLP(assetA: number, assetB: number, burnAmt: number): Promise<IAssetAmt>;
-    /**
-     * Get assets amounts after pool token burn by state
-     *
-     * @param state pool state
-     * @param burnAmt burn amount
-     * @returns
-     */
-    getAssetAmtAfterBurnLPByState(state: PoolState, burnAmt: number): {
-        assetA: bigint;
-        assetB: bigint;
-    };
-    /**
-     * get input amount from output when a user swap A to B
-     *
-     * @param assetIn id of input asset
-     * @param assetOut id of output asset
-     * @param amtOut output amount
-     * @returns
-     */
-    getSwapInput(assetIn: number, assetOut: number, amtOut: number | bigint): Promise<bigint>;
-    /**
-     * get input amount from output when a user swap A to B
-     *
-     * @param assetIn id of input asset
-     * @param assetOut id of output asset
-     * @param amtOut output amount
-     * @param state pool state
-     * @returns
-     */
-    getSwapInputByState(assetIn: number, assetOut: number, state: PoolState, amtOut: number | bigint): bigint;
-    /**
-     * get pool ratio
-     * @param assetIn id of asset A
-     * @param assetOut id of asset B
-     * @returns
-     */
-    getPoolRatio(assetIn: {
-        index: number;
-        decimals: number;
-    }, assetOut: {
-        index: number;
-        decimals: number;
-    }): Promise<number>;
-    /**
-     * get pool ratio
-     * @param state pool state
-     * @param aDecimals decimals of asset A
-     * @param bDecimals decimals of asset B
-     * @returns
-     */
-    getPoolRatioByState(state: PoolState, aDecimals: number, bDecimals: number): number;
-    /**
-     * Get pool state
-     * @param poolId id of pool
-     * @returns
-     */
-    getPoolState(poolId: number): Promise<PoolState | StablePoolState>;
-    /**
-     * Get all pool states
-     * @returns
-     */
-    getPoolStates(): Promise<{
-        [key: number]: PoolState;
-    }>;
-    /**
-     * get price impact when a user swaps A to B
-     * @param assetA id of asset A
-     * @param assetB id of asset B
-     * @param inAmt input amout
-     * @returns
-     */
-    getPriceImpact(assetA: number, assetB: number, inAmt: number): Promise<number>;
-    /**
-     * get price impact when a user swaps A to B by state
-     * @param poolState pool state
-     * @param assetA id of asset A
-     * @param assetB id of asset B
-     * @param inAmt input amout
-     * @returns
-     */
-    getPriceImpactByState(poolState: PoolState, inId: number, outId: number, inAmt: number): number;
-    /**
-     * get price impact and swap amount when a user swaps A to B
-     * @param assetA id of asset A
-     * @param assetB id of asset B
-     * @param inAmt input amout
-     * @returns
-     */
-    getSwapResults(inId: number, outId: number, amount: number | bigint): Promise<{
-        swapOutput: bigint;
-        swapInput: bigint;
-    }>;
-    getSwapResultsByState(inId: number, outId: number, state: PoolState, amount: number | bigint): {
-        swapOutput: bigint;
-        swapInput: bigint;
-    };
-    private getTmpPoolId;
-    private getTmpStablePoolId;
-    private getAppState;
-    private checkIsPoolExist;
-    private getAsset;
-}