@storm-trade/trading-sdk 1.0.0 → 1.0.2

package/dist/api-clients/utils/cache.d.ts

@@ -0,0 +1,8 @@
+export declare class Cache<V> {
+    private readonly map;
+    private readonly cacheKeySeparator;
+    private checkFlatOrMap;
+    get(key: string[] | string): V | undefined;
+    getOrThrow(key: string[] | string): V & ({} | null);
+    set(key: string[] | string, value: V): void;
+}

package/dist/api-clients/utils/cache.esm.js

@@ -0,0 +1,22 @@
+class Cache {
+    map = new Map();
+    cacheKeySeparator = ':';
+    checkFlatOrMap(key) {
+        return Array.isArray(key) ? key.join(this.cacheKeySeparator) : key;
+    }
+    get(key) {
+        return this.map.get(this.checkFlatOrMap(key));
+    }
+    getOrThrow(key) {
+        const v = this.get(key);
+        if (v === undefined)
+            throw new Error(`Could not find value for ${key} in ${this.map}`);
+        return v;
+    }
+    set(key, value) {
+        this.map.set(this.checkFlatOrMap(key), value);
+    }
+}
+
+export { Cache };
+//# sourceMappingURL=cache.esm.js.map

package/dist/api-clients/utils/cache.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.esm.js","sources":["../../../src/api-clients/utils/cache.ts"],"sourcesContent":[null],"names":[],"mappings":"MAAa,KAAK,CAAA;AACC,IAAA,GAAG,GAAoB,IAAI,GAAG,EAAE;IAEhC,iBAAiB,GAAG,GAAG;AAEhC,IAAA,cAAc,CAAC,GAAsB,EAAA;QAC3C,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,GAAG;;AAG7D,IAAA,GAAG,CAAC,GAAsB,EAAA;AAC/B,QAAA,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;;AAGxC,IAAA,UAAU,CAAC,GAAsB,EAAA;QACtC,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;QACvB,IAAI,CAAC,KAAK,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,CAA4B,yBAAA,EAAA,GAAG,CAAO,IAAA,EAAA,IAAI,CAAC,GAAG,CAAE,CAAA,CAAC;AACtF,QAAA,OAAO,CAAC;;IAGH,GAAG,CAAC,GAAsB,EAAE,KAAQ,EAAA;AACzC,QAAA,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC;;AAEhD;;;;"}

package/dist/api-clients/utils/cache.js

@@ -0,0 +1,24 @@
+'use strict';
+
+class Cache {
+    map = new Map();
+    cacheKeySeparator = ':';
+    checkFlatOrMap(key) {
+        return Array.isArray(key) ? key.join(this.cacheKeySeparator) : key;
+    }
+    get(key) {
+        return this.map.get(this.checkFlatOrMap(key));
+    }
+    getOrThrow(key) {
+        const v = this.get(key);
+        if (v === undefined)
+            throw new Error(`Could not find value for ${key} in ${this.map}`);
+        return v;
+    }
+    set(key, value) {
+        this.map.set(this.checkFlatOrMap(key), value);
+    }
+}
+
+exports.Cache = Cache;
+//# sourceMappingURL=cache.js.map

package/dist/api-clients/utils/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sources":["../../../src/api-clients/utils/cache.ts"],"sourcesContent":[null],"names":[],"mappings":";;MAAa,KAAK,CAAA;AACC,IAAA,GAAG,GAAoB,IAAI,GAAG,EAAE;IAEhC,iBAAiB,GAAG,GAAG;AAEhC,IAAA,cAAc,CAAC,GAAsB,EAAA;QAC3C,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,GAAG;;AAG7D,IAAA,GAAG,CAAC,GAAsB,EAAA;AAC/B,QAAA,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;;AAGxC,IAAA,UAAU,CAAC,GAAsB,EAAA;QACtC,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;QACvB,IAAI,CAAC,KAAK,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,CAA4B,yBAAA,EAAA,GAAG,CAAO,IAAA,EAAA,IAAI,CAAC,GAAG,CAAE,CAAA,CAAC;AACtF,QAAA,OAAO,CAAC;;IAGH,GAAG,CAAC,GAAsB,EAAE,KAAQ,EAAA;AACzC,QAAA,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC;;AAEhD;;;;"}

package/dist/sdk/sdk.d.ts

@@ -1,9 +1,9 @@
-import { StormClient } from '../api-clients';
-import { TonClient, TonClient4, Address } from '@ton/ton';
+import { Address, TonClient, TonClient4 } from '@ton/ton';
 import { LiteClient } from 'ton-lite-client';
-import { TXParams } from '../common-packers';
-import { AddMarginParams, CancelOrderParams, LimitOrderParams, MarketCloseOrderParams as ClosePositionOrderParams, MarketOpenOrderParams, ProvideLiquidityParams, RemoveMarginParams, StopLimitOrderParams, StopLossOrderParams, StopMarketOrderParams, TakeProfitOrderParams, WithdrawLiquidityParams } from './sdk.types';
+import { StormClient } from '../api-clients';
 import { PositionManagerData } from '../api-clients/contracts/position-manager/position-manager.types';
+import { TXParams } from '../common-packers';
+import { AddMarginParams, AddMarginWithOraclePayload, AssetsParams, CancelOrderParams, CollateralAssets, LimitOrderParams, MarketCloseOrderParams as ClosePositionOrderParams, MarketOpenOrderParams, ProvideLiquidityParams, RemoveMarginParams, RemoveMarginWithOraclePayload, StopLimitOrderParams, StopLossOrderParams, StopMarketOrderParams, TakeProfitOrderParams, WithdrawLiquidityParams } from './sdk.types';
 export declare class StormTradingSdk {
     private readonly stormClient;
     private readonly tonClient;
@@ -14,28 +14,56 @@ export declare class StormTradingSdk {
     private readonly jettonMasters;
     private readonly vaults;
     private readonly positionManagers;
+    private lpWalletsAddressCache;
     constructor(stormClient: StormClient, tonClient: TonClient | TonClient4 | LiteClient, traderAddress: Address | string);
     init(): Promise<void>;
-    getPositionManagerAddressByAssets(baseAssetName: string, collateralAssetName: string): Promise<Address>;
+    getPositionManagerAddressByAssets(opts: AssetsParams): Promise<Address>;
     getPositionManagerData(positionManagerAddress: Address): Promise<PositionManagerData | null>;
+    prefetchCreateMarketOpenOrder(opts: AssetsParams): Promise<void>;
+    syncCreateMarketOpenOrder(opts: MarketOpenOrderParams): TXParams;
     createMarketOpenOrder(opts: MarketOpenOrderParams): Promise<TXParams>;
+    prefetchCreateClosePositionOrder: (opts: AssetsParams) => Promise<void>;
+    syncCreateClosePositionOrder(opts: ClosePositionOrderParams): TXParams;
     createClosePositionOrder(opts: ClosePositionOrderParams): Promise<TXParams>;
-    createStopLossOrder(opts: StopLossOrderParams): Promise<TXParams>;
-    createTakeProfitOrder(opts: TakeProfitOrderParams): Promise<TXParams>;
+    prefetchCreateLimitOrder: (opts: AssetsParams) => Promise<void>;
+    syncCreateLimitOrder(opts: LimitOrderParams): TXParams;
     createLimitOrder(opts: LimitOrderParams): Promise<TXParams>;
+    prefetchCreateStopLimitOrder: (opts: AssetsParams) => Promise<void>;
+    syncCreateStopLimitOrder(opts: StopLimitOrderParams): TXParams;
     createStopLimitOrder(opts: StopLimitOrderParams): Promise<TXParams>;
+    prefetchCreateStopMarketOrder: (opts: AssetsParams) => Promise<void>;
+    syncCreateStopMarketOrder(opts: StopMarketOrderParams): TXParams;
     createStopMarketOrder(opts: StopMarketOrderParams): Promise<TXParams>;
+    prefetchCreteStopLossOrder: (opts: AssetsParams) => Promise<void>;
+    syncCreateStopLossOrder(opts: StopLossOrderParams): TXParams;
+    createStopLossOrder(opts: StopLossOrderParams): Promise<TXParams>;
+    prefetchCreteTakeProfitOrder: (opts: AssetsParams) => Promise<void>;
+    syncCreateTakeProfitOrder(opts: TakeProfitOrderParams): TXParams;
+    createTakeProfitOrder(opts: TakeProfitOrderParams): Promise<TXParams>;
+    prefetchAddMarginCaches(opts: AssetsParams): Promise<void>;
+    syncAddMargin(opts: AddMarginWithOraclePayload): TXParams;
+    addMargin(opts: AddMarginParams): Promise<TXParams>;
+    prefetchRemoveMarginCaches(opts: AssetsParams): Promise<void>;
+    syncRemoveMargin(opts: RemoveMarginWithOraclePayload): TXParams;
+    removeMargin(opts: RemoveMarginParams): Promise<TXParams>;
+    prefetchCancelOrderCaches(opts: AssetsParams): Promise<void>;
+    syncCreateCancelOrder(opts: CancelOrderParams): TXParams;
     cancelOrder(opts: CancelOrderParams): Promise<TXParams>;
+    prefetchProvideLiquidity(opts: ProvideLiquidityParams): Promise<void>;
+    syncProvideLiquidity(opts: ProvideLiquidityParams): TXParams;
     provideLiquidity(opts: ProvideLiquidityParams): Promise<TXParams>;
+    prefetchWithdrawLiquidityCaches(assetName: CollateralAssets): Promise<void>;
+    syncWithdrawLiquidity(opts: WithdrawLiquidityParams): TXParams;
     withdrawLiquidity(opts: WithdrawLiquidityParams): Promise<TXParams>;
-    addMargin(opts: AddMarginParams): Promise<TXParams>;
-    removeMargin(opts: RemoveMarginParams): Promise<TXParams>;
     private getJettonWalletAddressByAssetName;
     private isNativeVault;
     private checkIsPositionManagerInitialized;
     private getOraclePayloadByAssets;
     private createSLTPOrder;
+    private syncCreateSLTPOrder;
+    private prefetchSLTPOrderCaches;
     private internalCreateLimitOrder;
+    private syncInternalCreateLimitOrder;
     private getVaultContract;
     private getJettonMasterContract;
     private getPositionManagerContract;

package/dist/sdk/sdk.esm.js

@@ -1,12 +1,13 @@
-import '@hastom/fetch';
 import { Address } from '@ton/ton';
+import '@hastom/fetch';
 import { TonClientAbstract } from '../api-clients/utils/ton-client-abstract.esm.js';
 import { JettonMasterContract } from '../api-clients/contracts/jetton-master.esm.js';
 import { VaultContract } from '../api-clients/contracts/vault.esm.js';
 import { PositionManagerContract } from '../api-clients/contracts/position-manager.esm.js';
-import { createMarketOrderTx, createCancelOrderTx, createProvideLiquidityTx, createWithdrawLiquidityTx, createAddMarginTx, createRemoveMarginTx, createSLTPOrderTx, createLimitOrderTx } from '../common-packers/order-packers.esm.js';
+import { Cache } from '../api-clients/utils/cache.esm.js';
 import { OrderType } from '../base-packers/order-packers.types.esm.js';
 import '../base-packers/opcodes.esm.js';
+import { createMarketOrderTx, createAddMarginTx, createRemoveMarginTx, createCancelOrderTx, createProvideLiquidityTx, createWithdrawLiquidityTx, createSLTPOrderTx, createLimitOrderTx } from '../common-packers/order-packers.esm.js';
 
 const marketOpenDefaultExpiration = () => Math.floor(Date.now() / 1000) + 15 * 60;
 const limitDefaultExpiration = () => Math.floor(Date.now() / 1000) + 60 * 24 * 60 * 60;
@@ -14,12 +15,13 @@ class StormTradingSdk {
     stormClient;
     tonClient;
     traderAddress;
-    jettonWalletsAddressCache = new Map();
-    positionManagerAddressCache = new Map();
-    initializedPositionManagersCache = new Set();
-    jettonMasters = new Map();
-    vaults = new Map();
-    positionManagers = new Map();
+    jettonWalletsAddressCache = new Cache();
+    positionManagerAddressCache = new Cache();
+    initializedPositionManagersCache = new Cache();
+    jettonMasters = new Cache();
+    vaults = new Cache();
+    positionManagers = new Cache();
+    lpWalletsAddressCache = new Cache();
     constructor(stormClient, tonClient, traderAddress) {
         this.stormClient = stormClient;
         this.traderAddress =
@@ -32,8 +34,12 @@ class StormTradingSdk {
             this.stormClient.config.fetchAssetsConfig(),
         ]);
     }
-    async getPositionManagerAddressByAssets(baseAssetName, collateralAssetName) {
-        const positionAddressByAssetNameAndBaseAsset = this.positionManagerAddressCache.get(baseAssetName + ':' + collateralAssetName);
+    async getPositionManagerAddressByAssets(opts) {
+        const { baseAssetName, collateralAssetName } = opts;
+        const positionAddressByAssetNameAndBaseAsset = this.positionManagerAddressCache.get([
+            baseAssetName,
+            collateralAssetName,
+        ]);
         if (positionAddressByAssetNameAndBaseAsset) {
             return positionAddressByAssetNameAndBaseAsset;
         }
@@ -49,127 +55,142 @@ class StormTradingSdk {
         const positionManagerContract = this.getPositionManagerContract(positionManagerAddress.toRawString());
         return positionManagerContract.getData();
     }
-    async createMarketOpenOrder(opts) {
-        const { baseAssetName, collateralAssetName } = opts;
-        const vault = this.stormClient.config.requireVaultConfigByAssetName(collateralAssetName);
-        const positionManagerAddress = await this.getPositionManagerAddressByAssets(baseAssetName, collateralAssetName);
-        const isPositionManagerInitialized = await this.checkIsPositionManagerInitialized(positionManagerAddress);
-        const assetId = this.stormClient.config.requireAssetIndexByName(baseAssetName);
-        const orderParams = {
-            assetId,
-            initPositionManager: !isPositionManagerInitialized,
+    // Market open
+    async prefetchCreateMarketOpenOrder(opts) {
+        const { collateralAssetName } = opts;
+        const positionManagerAddress = await this.getPositionManagerAddressByAssets(opts);
+        await this.checkIsPositionManagerInitialized(positionManagerAddress);
+        if (!this.isNativeVault(collateralAssetName)) {
+            await this.getJettonWalletAddressByAssetName(collateralAssetName);
+        }
+    }
+    syncCreateMarketOpenOrder(opts) {
+        const positionManagerAddress = this.positionManagerAddressCache.getOrThrow([
+            opts.baseAssetName,
+            opts.collateralAssetName,
+        ]);
+        const vault = this.stormClient.config.requireVaultConfigByAssetName(opts.collateralAssetName);
+        const vaultAddress = Address.parse(vault.vaultAddress);
+        const baseParams = {
+            traderAddress: this.traderAddress,
+            vaultAddress,
             amount: opts.amount,
-            direction: opts.direction,
-            leverage: opts.leverage,
-            expiration: opts.expiration ?? marketOpenDefaultExpiration(),
+        };
+        const initPositionManager = !this.initializedPositionManagersCache.get(positionManagerAddress.toRawString());
+        const orderParams = {
+            ...opts,
             limitPrice: 0n,
+            assetId: this.stormClient.config.requireAssetIndexByName(opts.baseAssetName),
+            initPositionManager,
+            expiration: marketOpenDefaultExpiration(),
             minBaseAssetAmount: opts.minBaseAssetAmount ?? 0n,
             stopTriggerPrice: opts.stopTriggerPrice ?? 0n,
             takeTriggerPrice: opts.takeTriggerPrice ?? 0n,
         };
-        const baseParams = {
-            traderAddress: this.traderAddress,
-            amount: opts.amount,
-            positionManagerAddress,
-            vaultAddress: Address.parse(vault.vaultAddress),
-            orderParams,
-        };
-        if (this.isNativeVault(collateralAssetName)) {
+        if (this.isNativeVault(opts.collateralAssetName)) {
             return createMarketOrderTx({
+                orderParams,
                 ...baseParams,
                 vaultType: 'native',
             });
         }
         else {
-            const traderJettonWalletAddress = await this.getJettonWalletAddressByAssetName(collateralAssetName);
+            const traderJettonWalletAddress = this.jettonWalletsAddressCache.getOrThrow(opts.collateralAssetName);
             return createMarketOrderTx({
+                orderParams,
                 ...baseParams,
                 vaultType: 'jetton',
                 traderJettonWalletAddress,
             });
         }
     }
-    async createClosePositionOrder(opts) {
-        return this.createTakeProfitOrder({
+    async createMarketOpenOrder(opts) {
+        await this.prefetchCreateMarketOpenOrder(opts);
+        return this.syncCreateMarketOpenOrder(opts);
+    }
+    // Market close
+    prefetchCreateClosePositionOrder = this.prefetchSLTPOrderCaches;
+    syncCreateClosePositionOrder(opts) {
+        return this.syncCreateTakeProfitOrder({
             ...opts,
             amount: opts.size,
             triggerPrice: 0n,
         });
     }
-    async createStopLossOrder(opts) {
-        return this.createSLTPOrder({
+    async createClosePositionOrder(opts) {
+        return this.createTakeProfitOrder({
             ...opts,
-            type: OrderType.stopLoss,
+            amount: opts.size,
+            triggerPrice: 0n,
         });
     }
-    async createTakeProfitOrder(opts) {
-        return this.createSLTPOrder({
-            ...opts,
-            type: OrderType.takeProfit,
-        });
+    // Limit order
+    prefetchCreateLimitOrder = this.prefetchCreateMarketOpenOrder;
+    syncCreateLimitOrder(opts) {
+        return this.syncInternalCreateLimitOrder({ ...opts, stopPrice: 0n });
     }
     async createLimitOrder(opts) {
         return this.internalCreateLimitOrder({ ...opts, stopPrice: 0n });
     }
+    // Stop limit order
+    prefetchCreateStopLimitOrder = this.prefetchCreateMarketOpenOrder;
+    syncCreateStopLimitOrder(opts) {
+        return this.syncInternalCreateLimitOrder(opts);
+    }
     async createStopLimitOrder(opts) {
         return this.internalCreateLimitOrder(opts);
     }
+    // Stop market order
+    prefetchCreateStopMarketOrder = this.prefetchCreateMarketOpenOrder;
+    syncCreateStopMarketOrder(opts) {
+        return this.syncInternalCreateLimitOrder({ ...opts, limitPrice: 0n });
+    }
     async createStopMarketOrder(opts) {
         return this.internalCreateLimitOrder({ ...opts, limitPrice: 0n });
     }
-    async cancelOrder(opts) {
-        const positionManagerAddress = await this.getPositionManagerAddressByAssets(opts.baseAssetName, opts.collateralAssetName);
-        return createCancelOrderTx({
-            positionManagerAddress,
-            orderParams: {
-                orderType: opts.orderType,
-                orderIndex: opts.orderIndex,
-                direction: opts.direction,
-            },
+    // Stop loss order
+    prefetchCreteStopLossOrder = this.prefetchSLTPOrderCaches;
+    syncCreateStopLossOrder(opts) {
+        return this.syncCreateSLTPOrder({
+            ...opts,
+            type: OrderType.stopLoss,
         });
     }
-    async provideLiquidity(opts) {
-        const { assetName } = opts;
-        const vault = this.stormClient.config.requireVaultConfigByAssetName(assetName);
-        const baseParams = {
-            traderAddress: this.traderAddress,
-            amount: opts.amount,
-            vaultAddress: Address.parse(vault.vaultAddress),
-        };
-        if (this.isNativeVault(assetName)) {
-            return createProvideLiquidityTx({ vaultType: 'native', ...baseParams });
-        }
-        else {
-            const traderJettonWalletAddress = await this.getJettonWalletAddressByAssetName(assetName);
-            return createProvideLiquidityTx({
-                vaultType: 'jetton',
-                traderJettonWalletAddress,
-                ...baseParams,
-            });
-        }
+    async createStopLossOrder(opts) {
+        return this.createSLTPOrder({
+            ...opts,
+            type: OrderType.stopLoss,
+        });
     }
-    async withdrawLiquidity(opts) {
-        const { assetName } = opts;
-        const vault = this.stormClient.config.requireVaultConfigByAssetName(assetName);
-        const lpJettonMasterContract = this.getJettonMasterContract(vault.lpJettonMaster);
-        const lpWalletAddress = await lpJettonMasterContract.getJettonWalletAddress(this.traderAddress);
-        return createWithdrawLiquidityTx({
-            lpWalletAddress,
-            amount: opts.amountOfSLP,
-            userAddress: this.traderAddress,
+    // Take profit order
+    prefetchCreteTakeProfitOrder = this.prefetchSLTPOrderCaches;
+    syncCreateTakeProfitOrder(opts) {
+        return this.syncCreateSLTPOrder({
+            ...opts,
+            type: OrderType.takeProfit,
         });
     }
-    async addMargin(opts) {
-        const vault = this.stormClient.config.requireVaultConfigByAssetName(opts.collateralAssetName);
+    async createTakeProfitOrder(opts) {
+        return this.createSLTPOrder({
+            ...opts,
+            type: OrderType.takeProfit,
+        });
+    }
+    // Add margin
+    async prefetchAddMarginCaches(opts) {
+        if (!this.isNativeVault(opts.collateralAssetName)) {
+            await this.getJettonWalletAddressByAssetName(opts.collateralAssetName);
+        }
+    }
+    syncAddMargin(opts) {
+        const { collateralAssetName } = opts;
+        const vault = this.stormClient.config.requireVaultConfigByAssetName(collateralAssetName);
         const assetId = this.stormClient.config.requireAssetIndexByName(opts.baseAssetName);
-        const oraclePayload = opts.oraclePayload
-            ? opts.oraclePayload
-            : await this.getOraclePayloadByAssets(opts.baseAssetName, opts.collateralAssetName);
         const orderParams = {
             amount: opts.amount,
             direction: opts.direction,
             assetId,
-            oracle: oraclePayload,
+            oracle: opts.oraclePayload,
         };
         const baseParams = {
             traderAddress: this.traderAddress,
@@ -177,11 +198,11 @@ class StormTradingSdk {
             vaultAddress: Address.parse(vault.vaultAddress),
             orderParams,
         };
-        if (this.isNativeVault(opts.collateralAssetName)) {
+        if (this.isNativeVault(collateralAssetName)) {
             return createAddMarginTx({ vaultType: 'native', ...baseParams });
         }
         else {
-            const traderJettonWalletAddress = await this.getJettonWalletAddressByAssetName(opts.collateralAssetName);
+            const traderJettonWalletAddress = this.jettonWalletsAddressCache.getOrThrow(collateralAssetName);
             return createAddMarginTx({
                 vaultType: 'jetton',
                 traderJettonWalletAddress,
@@ -189,17 +210,26 @@ class StormTradingSdk {
             });
         }
     }
-    async removeMargin(opts) {
+    async addMargin(opts) {
+        await this.prefetchAddMarginCaches(opts);
+        const oraclePayload = await this.getOraclePayloadByAssets(opts);
+        return this.syncAddMargin({ ...opts, oraclePayload });
+    }
+    // Remove margin
+    async prefetchRemoveMarginCaches(opts) {
+        await this.getPositionManagerAddressByAssets(opts);
+    }
+    syncRemoveMargin(opts) {
         const assetId = this.stormClient.config.requireAssetIndexByName(opts.baseAssetName);
-        const oraclePayload = opts.oraclePayload
-            ? opts.oraclePayload
-            : await this.getOraclePayloadByAssets(opts.baseAssetName, opts.collateralAssetName);
-        const positionManagerAddress = await this.getPositionManagerAddressByAssets(opts.baseAssetName, opts.collateralAssetName);
+        const positionManagerAddress = this.positionManagerAddressCache.getOrThrow([
+            opts.baseAssetName,
+            opts.collateralAssetName,
+        ]);
         const orderParams = {
             assetId,
             amount: opts.amount,
             direction: opts.direction,
-            oracle: oraclePayload,
+            oracle: opts.oraclePayload,
         };
         const baseParams = {
             traderAddress: this.traderAddress,
@@ -209,6 +239,87 @@ class StormTradingSdk {
         };
         return createRemoveMarginTx({ ...baseParams });
     }
+    async removeMargin(opts) {
+        await this.prefetchRemoveMarginCaches(opts);
+        const oraclePayload = await this.getOraclePayloadByAssets(opts);
+        return this.syncRemoveMargin({ ...opts, oraclePayload });
+    }
+    // Cancel order
+    async prefetchCancelOrderCaches(opts) {
+        await this.getPositionManagerAddressByAssets(opts);
+    }
+    syncCreateCancelOrder(opts) {
+        const positionManagerAddress = this.positionManagerAddressCache.getOrThrow([
+            opts.baseAssetName,
+            opts.collateralAssetName,
+        ]);
+        return createCancelOrderTx({
+            positionManagerAddress,
+            orderParams: {
+                orderType: opts.orderType,
+                orderIndex: opts.orderIndex,
+                direction: opts.direction,
+            },
+        });
+    }
+    async cancelOrder(opts) {
+        await this.prefetchCancelOrderCaches(opts);
+        return this.syncCreateCancelOrder(opts);
+    }
+    // Provide liquidity
+    async prefetchProvideLiquidity(opts) {
+        if (!this.isNativeVault(opts.assetName)) {
+            await this.getJettonWalletAddressByAssetName(opts.assetName);
+        }
+    }
+    syncProvideLiquidity(opts) {
+        const { assetName } = opts;
+        const vault = this.stormClient.config.requireVaultConfigByAssetName(assetName);
+        const baseParams = {
+            traderAddress: this.traderAddress,
+            amount: opts.amount,
+            vaultAddress: Address.parse(vault.vaultAddress),
+        };
+        if (this.isNativeVault(assetName)) {
+            return createProvideLiquidityTx({ vaultType: 'native', ...baseParams });
+        }
+        else {
+            const traderJettonWalletAddress = this.jettonWalletsAddressCache.getOrThrow(opts.assetName);
+            return createProvideLiquidityTx({
+                vaultType: 'jetton',
+                traderJettonWalletAddress,
+                ...baseParams,
+            });
+        }
+    }
+    async provideLiquidity(opts) {
+        await this.prefetchProvideLiquidity(opts);
+        return this.syncProvideLiquidity(opts);
+    }
+    // Withdraw liquidity
+    async prefetchWithdrawLiquidityCaches(assetName) {
+        if (this.lpWalletsAddressCache.get(assetName)) {
+            return;
+        }
+        const vault = this.stormClient.config.requireVaultConfigByAssetName(assetName);
+        const lpJettonMasterContract = this.getJettonMasterContract(vault.lpJettonMaster);
+        const lpWalletAddress = await lpJettonMasterContract.getJettonWalletAddress(this.traderAddress);
+        this.lpWalletsAddressCache.set(assetName, lpWalletAddress);
+    }
+    syncWithdrawLiquidity(opts) {
+        const lpWalletAddress = this.lpWalletsAddressCache.getOrThrow(opts.assetName);
+        return createWithdrawLiquidityTx({
+            lpWalletAddress,
+            amount: opts.amountOfSLP,
+            userAddress: this.traderAddress,
+        });
+    }
+    async withdrawLiquidity(opts) {
+        const { assetName } = opts;
+        await this.prefetchWithdrawLiquidityCaches(assetName);
+        return this.syncWithdrawLiquidity(opts);
+    }
+    //
     async getJettonWalletAddressByAssetName(collateralAssetName) {
         let jettonWalletAddress = this.jettonWalletsAddressCache.get(collateralAssetName);
         if (jettonWalletAddress) {
@@ -224,13 +335,13 @@ class StormTradingSdk {
         return collateralAssetName === 'TON';
     }
     async checkIsPositionManagerInitialized(positionManagerAddress) {
-        if (this.initializedPositionManagersCache.has(positionManagerAddress.toRawString())) {
+        if (this.initializedPositionManagersCache.get(positionManagerAddress.toRawString())) {
             return true;
         }
         try {
             const positionManagerData = await this.getPositionManagerData(positionManagerAddress);
             if (!(positionManagerData === null || positionManagerData.referralData === null)) {
-                this.initializedPositionManagersCache.add(positionManagerAddress.toRawString());
+                this.initializedPositionManagersCache.set(positionManagerAddress.toRawString(), true);
                 return true;
             }
             else {
@@ -241,11 +352,15 @@ class StormTradingSdk {
             return false;
         }
     }
-    async getOraclePayloadByAssets(baseAssetName, collateralAssetName) {
+    async getOraclePayloadByAssets(opts) {
+        const { baseAssetName, collateralAssetName } = opts;
         const oraclePriceResp = await this.stormClient.oracleClient.getPrice(baseAssetName);
         const oraclePayload = { ...oraclePriceResp.result_message };
         if (collateralAssetName === 'USDT') {
-            return { ...oraclePayload, oraclePayloadKind: 'simple' };
+            return {
+                ...oraclePayload,
+                oraclePayloadKind: 'simple',
+            };
         }
         const { priceRef, signaturesRef } = oraclePayload;
         if (collateralAssetName === baseAssetName) {
@@ -266,8 +381,14 @@ class StormTradingSdk {
         };
     }
     async createSLTPOrder(opts) {
-        const { baseAssetName, collateralAssetName } = opts;
-        const positionManagerAddress = await this.getPositionManagerAddressByAssets(baseAssetName, collateralAssetName);
+        await this.prefetchSLTPOrderCaches(opts);
+        return this.syncCreateSLTPOrder(opts);
+    }
+    syncCreateSLTPOrder(opts) {
+        const positionManagerAddress = this.positionManagerAddressCache.getOrThrow([
+            opts.baseAssetName,
+            opts.collateralAssetName,
+        ]);
         return createSLTPOrderTx({
             positionManagerAddress,
             orderParams: {
@@ -279,15 +400,24 @@ class StormTradingSdk {
             },
         });
     }
+    async prefetchSLTPOrderCaches(opts) {
+        await this.getPositionManagerAddressByAssets(opts);
+    }
     async internalCreateLimitOrder(opts) {
-        const { baseAssetName, collateralAssetName } = opts;
-        const vault = this.stormClient.config.requireVaultConfigByAssetName(collateralAssetName);
-        const positionManagerAddress = await this.getPositionManagerAddressByAssets(baseAssetName, collateralAssetName);
-        const assetId = this.stormClient.config.requireAssetIndexByName(baseAssetName);
-        const isPositionManagerInitialized = await this.checkIsPositionManagerInitialized(positionManagerAddress);
+        await this.prefetchCreateMarketOpenOrder(opts);
+        return this.syncInternalCreateLimitOrder(opts);
+    }
+    syncInternalCreateLimitOrder(opts) {
+        const vault = this.stormClient.config.requireVaultConfigByAssetName(opts.collateralAssetName);
+        const assetId = this.stormClient.config.requireAssetIndexByName(opts.baseAssetName);
+        const positionManagerAddress = this.positionManagerAddressCache.getOrThrow([
+            opts.baseAssetName,
+            opts.collateralAssetName,
+        ]);
+        const initPositionManager = !this.initializedPositionManagersCache.get(positionManagerAddress.toRawString());
         const orderParams = {
             assetId,
-            initPositionManager: !isPositionManagerInitialized,
+            initPositionManager,
             amount: opts.amount,
             leverage: opts.leverage,
             stopPrice: opts.stopPrice,
@@ -296,6 +426,7 @@ class StormTradingSdk {
             stopTriggerPrice: opts.stopTriggerPrice ?? 0n,
             takeTriggerPrice: opts.takeTriggerPrice ?? 0n,
             expiration: opts.expiration ?? limitDefaultExpiration(),
+            referralId: opts.referralId
         };
         const baseParams = {
             traderAddress: this.traderAddress,
@@ -304,14 +435,14 @@ class StormTradingSdk {
             positionManagerAddress,
             vaultAddress: Address.parse(vault.vaultAddress),
         };
-        if (this.isNativeVault(collateralAssetName)) {
+        if (this.isNativeVault(opts.collateralAssetName)) {
             return createLimitOrderTx({
                 ...baseParams,
                 vaultType: 'native',
             });
         }
         else {
-            const traderJettonWalletAddress = await this.getJettonWalletAddressByAssetName(collateralAssetName);
+            const traderJettonWalletAddress = this.jettonWalletsAddressCache.getOrThrow(opts.collateralAssetName);
             return createLimitOrderTx({
                 ...baseParams,
                 vaultType: 'jetton',