@bluefin-exchange/pro-sdk 0.1.61 → 0.2.0-pre-release.1

package/dist/esm/src/sdk.js

@@ -0,0 +1,786 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BluefinProSdk = void 0;
+const api_1 = require("./api");
+const configuration_1 = require("./configuration");
+const ws_1 = require("ws");
+const v3_1 = require("@firefly-exchange/library-sui/v3");
+const library_sui_1 = require("@firefly-exchange/library-sui");
+const bcs_1 = require("@mysten/bcs");
+const environmentConfig = {
+    mainnet: {
+        authHost: 'https://auth.api.sui-prod.bluefin.io',
+        apiHost: 'https://api.sui-prod.bluefin.io',
+        tradeHost: 'https://trade.api.sui-prod.bluefin.io',
+        marketWsHost: 'wss://stream.api.sui-prod.bluefin.io/ws/market',
+        accountWsHost: 'wss://stream.api.sui-prod.bluefin.io/ws/account',
+    },
+    testnet: {
+        authHost: 'https://auth.api.sui-staging.bluefin.io',
+        apiHost: 'https://api.sui-staging.bluefin.io',
+        tradeHost: 'https://trade.api.sui-staging.bluefin.io',
+        marketWsHost: 'wss://stream.api.sui-staging.bluefin.io/ws/market',
+        accountWsHost: 'wss://stream.api.sui-staging.bluefin.io/ws/account',
+    },
+    devnet: {
+        authHost: 'https://auth.api.sui-dev.bluefin.io',
+        apiHost: 'https://api.sui-dev.bluefin.io',
+        tradeHost: 'https://trade.api.sui-dev.bluefin.io',
+        marketWsHost: 'wss://stream.api.sui-dev.bluefin.io/ws/market',
+        accountWsHost: 'wss://stream.api.sui-dev.bluefin.io/ws/account',
+    },
+};
+var Services;
+(function (Services) {
+    Services[Services["Account"] = 0] = "Account";
+    Services[Services["Exchange"] = 1] = "Exchange";
+    Services[Services["Rewards"] = 2] = "Rewards";
+    Services[Services["Trade"] = 3] = "Trade";
+    Services[Services["Auth"] = 4] = "Auth";
+    Services[Services["MarketWebsocket"] = 5] = "MarketWebsocket";
+    Services[Services["AccountWebsocket"] = 6] = "AccountWebsocket";
+})(Services || (Services = {}));
+class BluefinProSdk {
+    constructor(bfSigner, environment = 'mainnet', suiClient, opts) {
+        var _a, _b, _c, _d, _e, _f;
+        this.bfSigner = bfSigner;
+        this.environment = environment;
+        this.suiClient = suiClient;
+        this.configs = {};
+        /**
+         * @description
+         * build gasless transaction payload bytes
+         * @param tx transcation block
+         * @returns string
+         * */
+        this.buildGaslessTxPayloadBytes = (txb) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield library_sui_1.SuiBlocks.buildGaslessTxPayloadBytes(txb, this.suiClient);
+            }
+            catch (error) {
+                throw new Error(error instanceof Error ? error.message : 'Build gasless tx payload bytes failed');
+            }
+        });
+        this.currentAccountAddress = opts === null || opts === void 0 ? void 0 : opts.currentAccountAddress;
+        this.isConnected = false;
+        this.updateTokenTimeout = null;
+        this.contractsConfig = undefined;
+        this.tokenResponse = null;
+        this.tokenSetAtSeconds = null;
+        this.disableLoginPromptOnLogout = (_a = opts === null || opts === void 0 ? void 0 : opts.disableLoginPromptOnLogout) !== null && _a !== void 0 ? _a : false;
+        this.onLogout = opts === null || opts === void 0 ? void 0 : opts.onLogout;
+        this.onAccessTokenUpdate = opts === null || opts === void 0 ? void 0 : opts.onAccessTokenUpdate;
+        this.isRefreshing = false;
+        this.refreshPromise = null;
+        this.visibilityChangeHandler = undefined;
+        this.onlineHandler = undefined;
+        this.offlineHandler = undefined;
+        // Initialize time offset based on provided currentTimeMs
+        if ((opts === null || opts === void 0 ? void 0 : opts.currentTimeMs) !== undefined) {
+            this.timeOffsetMs = opts.currentTimeMs - Date.now();
+        }
+        else {
+            this.timeOffsetMs = 0;
+        }
+        if ((opts === null || opts === void 0 ? void 0 : opts.refreshToken) && (opts === null || opts === void 0 ? void 0 : opts.refreshTokenValidForSeconds)) {
+            this.tokenResponse = {
+                accessToken: '',
+                accessTokenValidForSeconds: 0,
+                refreshToken: opts.refreshToken,
+                refreshTokenValidForSeconds: opts.refreshTokenValidForSeconds,
+            };
+            // Set timestamp when refresh token was provided
+            this.tokenSetAtSeconds = Date.now() / 1000;
+        }
+        const defaultConfig = environmentConfig[this.environment];
+        const basePaths = {
+            authHost: (_b = opts === null || opts === void 0 ? void 0 : opts.authHost) !== null && _b !== void 0 ? _b : defaultConfig.authHost,
+            apiHost: (_c = opts === null || opts === void 0 ? void 0 : opts.apiHost) !== null && _c !== void 0 ? _c : defaultConfig.apiHost,
+            tradeHost: (_d = opts === null || opts === void 0 ? void 0 : opts.tradeHost) !== null && _d !== void 0 ? _d : defaultConfig.tradeHost,
+            marketWsHost: (_e = opts === null || opts === void 0 ? void 0 : opts.marketWsHost) !== null && _e !== void 0 ? _e : defaultConfig.marketWsHost,
+            accountWsHost: (_f = opts === null || opts === void 0 ? void 0 : opts.accountWsHost) !== null && _f !== void 0 ? _f : defaultConfig.accountWsHost,
+        };
+        const authApiConfig = new configuration_1.Configuration({
+            basePath: basePaths.authHost,
+        });
+        this.configs[Services.Auth] = authApiConfig;
+        this.authApi = new api_1.AuthApi(authApiConfig);
+        const exchangeApiConfig = new configuration_1.Configuration({
+            basePath: basePaths.apiHost,
+        });
+        this.configs[Services.Exchange] = exchangeApiConfig;
+        this.exchangeDataApi = new api_1.ExchangeApi(exchangeApiConfig);
+        const rewardsApiConfig = new configuration_1.Configuration({
+            basePath: basePaths.apiHost,
+        });
+        this.configs[Services.Rewards] = rewardsApiConfig;
+        this.rewardsDataApi = new api_1.RewardsApi(rewardsApiConfig);
+        const accountDataApiConfig = new configuration_1.Configuration({
+            basePath: basePaths.apiHost,
+        });
+        this.configs[Services.Account] = accountDataApiConfig;
+        this.accountDataApi = new api_1.AccountDataApi(accountDataApiConfig);
+        const tradeApiConfig = new configuration_1.Configuration({
+            basePath: basePaths.tradeHost,
+        });
+        this.configs[Services.Trade] = tradeApiConfig;
+        this.tradeApi = new api_1.TradeApi(tradeApiConfig);
+        const marketWsConfig = new configuration_1.Configuration({
+            basePath: basePaths.marketWsHost,
+        });
+        this.configs[Services.MarketWebsocket] = marketWsConfig;
+        const accountWsConfig = new configuration_1.Configuration({
+            basePath: basePaths.accountWsHost,
+        });
+        this.configs[Services.AccountWebsocket] = accountWsConfig;
+    }
+    createWallet() {
+        const wallet = library_sui_1.Ed25519Keypair.generate();
+        const signerKey = wallet.getSecretKey();
+        const keyPair = (0, library_sui_1.decodeSuiPrivateKey)(signerKey);
+        const publicAddress = wallet.toSuiAddress();
+        return {
+            privateKey: (0, bcs_1.toHex)(keyPair.secretKey),
+            publicAddress,
+        };
+    }
+    getTokenResponse() {
+        return this.tokenResponse;
+    }
+    generateSalt() {
+        return (Date.now() + Math.floor(Math.random() * 1000000)).toString();
+    }
+    getCurrentTimeMs() {
+        return Date.now() + this.timeOffsetMs;
+    }
+    updateCurrentTimeMs(currentTimeMs) {
+        this.timeOffsetMs = currentTimeMs - Date.now();
+    }
+    isRefreshTokenValid() {
+        var _a;
+        if (!((_a = this.tokenResponse) === null || _a === void 0 ? void 0 : _a.refreshToken) || !this.tokenSetAtSeconds) {
+            return false;
+        }
+        const currentTimeSeconds = Date.now() / 1000;
+        const refreshTokenExpiryTime = this.tokenSetAtSeconds + this.tokenResponse.refreshTokenValidForSeconds;
+        // Add 60 second buffer to prevent using token right at expiry
+        return currentTimeSeconds < refreshTokenExpiryTime - 60;
+    }
+    isAccessTokenExpired() {
+        var _a;
+        if (!((_a = this.tokenResponse) === null || _a === void 0 ? void 0 : _a.accessToken) || !this.tokenSetAtSeconds) {
+            return true;
+        }
+        const currentTimeSeconds = Date.now() / 1000;
+        const tokenLifetimeSeconds = this.tokenResponse.accessTokenValidForSeconds;
+        const refreshAtLifetimePercentage = BluefinProSdk.TOKEN_REFRESH_THRESHOLD_PERCENTAGE;
+        const refreshAtSeconds = this.tokenSetAtSeconds +
+            tokenLifetimeSeconds * refreshAtLifetimePercentage;
+        // Token is considered "expired" if we've passed the 80% lifetime mark
+        return currentTimeSeconds >= refreshAtSeconds;
+    }
+    initializeTxBuilder() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            this.txBuilder = new v3_1.TxBuilder({
+                AdminCap: '',
+                ExternalDataStore: ((_a = this.contractsConfig) === null || _a === void 0 ? void 0 : _a.edsId) || '',
+                InternalDataStore: ((_b = this.contractsConfig) === null || _b === void 0 ? void 0 : _b.idsId) || '',
+                Operators: {
+                    admin: ((_c = this.contractsConfig) === null || _c === void 0 ? void 0 : _c.operators.admin) || '',
+                    fee: ((_d = this.contractsConfig) === null || _d === void 0 ? void 0 : _d.operators.fee) || '',
+                    funding: ((_e = this.contractsConfig) === null || _e === void 0 ? void 0 : _e.operators.funding) || '',
+                    pruning: '',
+                    sequencer: ((_f = this.contractsConfig) === null || _f === void 0 ? void 0 : _f.operators.sequencer) || '',
+                },
+                Package: ((_g = this.contractsConfig) === null || _g === void 0 ? void 0 : _g.currentContractAddress) || '',
+                Perpetuals: {},
+                SupportedAssets: ((_h = this.assets) === null || _h === void 0 ? void 0 : _h.reduce((agg, x) => {
+                    agg[x.symbol] = Object.assign(Object.assign({}, x), { coinType: x.assetType });
+                    return agg;
+                }, {})) || {},
+                TreasuryCap: '',
+                UpgradeCap: '',
+            });
+        });
+    }
+    initialize(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.initializeOptions = options;
+            yield this.setContractsConfig();
+            yield this.initializeTxBuilder();
+            yield this.loginAndUpdateToken();
+            this.setupVisibilityChangeListener();
+            this.setupNetworkChangeListener();
+        });
+    }
+    setContractsConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.exchangeDataApi.getExchangeInfo();
+            this.contractsConfig = response.data.contractsConfig;
+            this.contractsConfig.currentContractAddress = '0x3b985440fbf1624ec97932fce729a27c5fbea74a1d1781cee3f64fcb22c9cfef';
+            this.assets = response.data.assets;
+        });
+    }
+    loginAndUpdateToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield this.login();
+            // Safety check - if login failed or logout was called, tokenResponse might be null
+            if (!this.tokenResponse) {
+                throw new Error('Login failed - no token response available');
+            }
+            this.isConnected = true;
+            this.configs[Services.Account].accessToken =
+                this.tokenResponse.accessToken;
+            this.configs[Services.Trade].accessToken = this.tokenResponse.accessToken;
+            this.configs[Services.Rewards].accessToken =
+                this.tokenResponse.accessToken;
+            // Notify about token refresh
+            (_a = this.onAccessTokenUpdate) === null || _a === void 0 ? void 0 : _a.call(this, this.tokenResponse.accessToken);
+            // Schedule the next token refresh
+            this.scheduleTokenRefresh();
+        });
+    }
+    scheduleTokenRefresh() {
+        // Clear any existing timeout
+        if (this.updateTokenTimeout) {
+            clearTimeout(this.updateTokenTimeout);
+            this.updateTokenTimeout = null;
+        }
+        if (!this.isConnected ||
+            !this.tokenResponse ||
+            !this.tokenSetAtSeconds) {
+            return;
+        }
+        // Calculate when to refresh: at 80% of token lifetime (or 20% before expiry)
+        const currentTimeSeconds = Date.now() / 1000;
+        const tokenLifetimeSeconds = this.tokenResponse.accessTokenValidForSeconds;
+        const refreshAtLifetimePercentage = BluefinProSdk.TOKEN_REFRESH_THRESHOLD_PERCENTAGE;
+        const refreshAtSeconds = this.tokenSetAtSeconds +
+            tokenLifetimeSeconds * refreshAtLifetimePercentage;
+        const millisecondsUntilRefresh = (refreshAtSeconds - currentTimeSeconds) * 1000;
+        const delayMs = Math.max(millisecondsUntilRefresh, 0);
+        console.log(`Scheduling token refresh in ${Math.round(delayMs / 1000)} seconds`);
+        this.updateTokenTimeout = setTimeout(() => {
+            this.refreshToken(true);
+        }, delayMs);
+    }
+    setupVisibilityChangeListener() {
+        // Only set up in browser environment
+        if (typeof document !== 'undefined') {
+            this.visibilityChangeHandler = () => {
+                if (document.visibilityState === 'visible' && this.isConnected) {
+                    console.log('Page became visible, checking token status');
+                    this.handleVisible();
+                }
+            };
+            document.addEventListener('visibilitychange', this.visibilityChangeHandler);
+        }
+    }
+    setupNetworkChangeListener() {
+        // Only set up in browser environment
+        if (typeof navigator !== 'undefined' && 'onLine' in navigator) {
+            window.addEventListener('online', this.handleOnline);
+            window.addEventListener('offline', this.handleOffline);
+        }
+    }
+    handleVisible() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.tokenResponse || !this.tokenSetAtSeconds) {
+                return;
+            }
+            this.refreshToken();
+        });
+    }
+    handleOnline() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected || !this.tokenResponse || !this.tokenSetAtSeconds) {
+                return;
+            }
+            console.log('Network reconnected, resuming token refresh and checking token status');
+            this.refreshToken(true);
+        });
+    }
+    handleOffline() {
+        if (this.updateTokenTimeout) {
+            clearTimeout(this.updateTokenTimeout);
+            this.updateTokenTimeout = null;
+        }
+    }
+    login() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            console.log('Logging in to get the access token');
+            this.tokenSetAtSeconds = Date.now() / 1000;
+            if (!this.currentAccountAddress) {
+                this.currentAccountAddress = this.bfSigner.getAddress();
+            }
+            console.log(`Logging in as ${this.currentAccountAddress}`);
+            // Check if we have a valid refresh token first
+            if (((_a = this.tokenResponse) === null || _a === void 0 ? void 0 : _a.refreshToken) && this.isRefreshTokenValid()) {
+                try {
+                    console.log('Attempting to refresh token using refresh token');
+                    const response = yield this.authApi.authTokenRefreshPut({
+                        refreshToken: this.tokenResponse.refreshToken,
+                    });
+                    this.tokenResponse = response.data;
+                    console.log('Token refreshed successfully');
+                    return;
+                }
+                catch (e) {
+                    console.error('Error refreshing token:', e);
+                    // Throw the error to let the caller handle it
+                    throw new Error(`Token refresh failed: ${e instanceof Error ? e.message : 'Unknown error'}`);
+                }
+            }
+            // Fallback to full login only if refresh token is not available or invalid
+            // This should only happen during initial login or when refresh token is truly expired
+            try {
+                const loginRequest = {
+                    accountAddress: this.currentAccountAddress,
+                    signedAtMillis: this.getCurrentTimeMs(),
+                    audience: 'api',
+                };
+                const signature = yield this.bfSigner.signLoginRequest(loginRequest);
+                const response = yield this.authApi.authV2TokenPost(signature, loginRequest, (_b = this.initializeOptions) === null || _b === void 0 ? void 0 : _b.refreshTokenValidForSeconds, (_c = this.initializeOptions) === null || _c === void 0 ? void 0 : _c.readOnly);
+                this.tokenResponse = response.data;
+            }
+            catch (e) {
+                console.error('Full login failed:', e);
+                // If this fails and we're in a mode where logout should be disabled, don't logout
+                if (this.disableLoginPromptOnLogout) {
+                    throw new Error(`Login failed: ${e instanceof Error ? e.message : 'Unknown error'}`);
+                }
+                // Otherwise, throw the error and let the caller decide
+                throw new Error(`Login failed: ${e instanceof Error ? e.message : 'Unknown error'}`);
+            }
+        });
+    }
+    getAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.tokenResponse) {
+                yield this.login();
+            }
+            return this.tokenResponse.accessToken;
+        });
+    }
+    getOpenOrders(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.tradeApi.getOpenOrders(symbol);
+        });
+    }
+    getStandbyOrders(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.tradeApi.getStandbyOrders(symbol);
+        });
+    }
+    updateLeverage(symbol, leverageE9) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.contractsConfig) {
+                throw new Error('Missing contracts config');
+            }
+            const signedFields = {
+                accountAddress: this.currentAccountAddress,
+                idsId: this.contractsConfig.idsId,
+                symbol: symbol,
+                leverageE9: leverageE9,
+                salt: this.generateSalt(),
+                signedAtMillis: this.getCurrentTimeMs(),
+            };
+            const request = yield this.bfSigner.signLeverageUpdateRequest(signedFields);
+            return yield this.tradeApi.putLeverageUpdate({
+                signedFields,
+                signature: request,
+            });
+        });
+    }
+    createOrder(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.contractsConfig) {
+                throw new Error('Missing contracts config');
+            }
+            const signedFields = {
+                symbol: params.symbol,
+                idsId: this.contractsConfig.idsId,
+                accountAddress: this.currentAccountAddress,
+                priceE9: params.priceE9,
+                quantityE9: params.quantityE9,
+                side: params.side,
+                leverageE9: params.leverageE9,
+                isIsolated: params.isIsolated,
+                salt: this.generateSalt(),
+                expiresAtMillis: params.expiresAtMillis,
+                signedAtMillis: this.getCurrentTimeMs(),
+            };
+            const signature = yield this.bfSigner.signOrderRequest(signedFields);
+            const createOrderRequest = {
+                signedFields,
+                signature,
+                clientOrderId: params.clientOrderId,
+                type: params.type,
+                reduceOnly: (_a = params.reduceOnly) !== null && _a !== void 0 ? _a : false,
+                postOnly: (_b = params.postOnly) !== null && _b !== void 0 ? _b : false,
+                timeInForce: params.timeInForce,
+                triggerPriceE9: params.triggerPriceE9,
+                selfTradePreventionType: params.selfTradePreventionType,
+            };
+            console.log('Creating order:', createOrderRequest);
+            return yield this.tradeApi.postCreateOrder(createOrderRequest);
+        });
+    }
+    cancelOrder(cancelOrdersRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.tradeApi.cancelOrders(cancelOrdersRequest);
+        });
+    }
+    cancelStandbyOrder(cancelOrdersRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.tradeApi.cancelStandbyOrders(cancelOrdersRequest);
+        });
+    }
+    withdraw(assetSymbol, amountE9) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchangeInfo = yield this.exchangeDataApi.getExchangeInfo();
+            const asset = exchangeInfo.data.assets.find((asset) => asset.symbol === assetSymbol);
+            if (!asset) {
+                throw new Error(`Asset ${assetSymbol} not found`);
+            }
+            if (!this.contractsConfig) {
+                throw new Error('Missing contractsConfig');
+            }
+            const signedFields = {
+                assetSymbol,
+                edsId: this.contractsConfig.edsId,
+                accountAddress: this.currentAccountAddress,
+                amountE9,
+                salt: this.generateSalt(),
+                signedAtMillis: this.getCurrentTimeMs(),
+            };
+            const signature = yield this.bfSigner.signWithdrawRequest(signedFields);
+            yield this.tradeApi.postWithdraw({
+                signedFields,
+                signature,
+            });
+            console.log('Withdraw request sent:', signedFields);
+        });
+    }
+    authorizeAccount(accountAddress, alias) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.contractsConfig) {
+                throw new Error('Missing contractsConfig');
+            }
+            const signedFields = {
+                accountAddress: this.currentAccountAddress,
+                idsId: this.contractsConfig.idsId,
+                authorizedAccountAddress: accountAddress,
+                salt: this.generateSalt(),
+                signedAtMillis: this.getCurrentTimeMs(),
+            };
+            const signature = yield this.bfSigner.signAccountAuthorizationRequest(signedFields, true);
+            yield this.tradeApi.putAuthorizeAccount({
+                signedFields,
+                signature,
+                alias,
+            });
+            console.log('Authorize account request sent:', signedFields);
+        });
+    }
+    deauthorizeAccount(accountAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.contractsConfig) {
+                throw new Error('Missing contractsConfig');
+            }
+            const signedFields = {
+                accountAddress: this.currentAccountAddress,
+                idsId: this.contractsConfig.idsId,
+                authorizedAccountAddress: accountAddress,
+                salt: this.generateSalt(),
+                signedAtMillis: this.getCurrentTimeMs(),
+            };
+            const signature = yield this.bfSigner.signAccountAuthorizationRequest(signedFields, false);
+            yield this.tradeApi.putDeauthorizeAccount({
+                signedFields,
+                signature,
+            });
+            console.log('Deauthorize account request sent:', signedFields);
+        });
+    }
+    adjustIsolatedMargin(symbol, amountE9, add) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.contractsConfig) {
+                throw new Error('Missing contractsConfig');
+            }
+            const signedFields = {
+                symbol,
+                idsId: this.contractsConfig.idsId,
+                accountAddress: this.currentAccountAddress,
+                operation: add
+                    ? api_1.AdjustMarginOperation.Add
+                    : api_1.AdjustMarginOperation.Subtract,
+                quantityE9: amountE9,
+                salt: this.generateSalt(),
+                signedAtMillis: this.getCurrentTimeMs(),
+            };
+            const signature = yield this.bfSigner.signAdjustIsolatedMarginRequest(signedFields);
+            yield this.tradeApi.putAdjustIsolatedMargin({
+                signedFields,
+                signature,
+            });
+            console.log('Adjust isolated margin request sent:', signedFields);
+        });
+    }
+    getAccountPreferences() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.accountDataApi.getAccountPreferences();
+        });
+    }
+    updateAccountPreferences(updateAccountPreferenceRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.accountDataApi.putAccountPreferences(updateAccountPreferenceRequest);
+        });
+    }
+    deposit(amountE9, accountAddress, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const assetSymbol = 'USDC';
+            const txb = new library_sui_1.TransactionBlock();
+            const assetType = (_b = (_a = this.assets) === null || _a === void 0 ? void 0 : _a.find((x) => x.symbol === assetSymbol)) === null || _b === void 0 ? void 0 : _b.assetType;
+            if (!assetType) {
+                throw new Error('Missing USDC asset type');
+            }
+            const [splitCoin, mergedCoin] = yield library_sui_1.CoinUtils.createCoinWithBalance(this.suiClient, txb, amountE9, assetType, this.currentAccountAddress || this.bfSigner.getAddress());
+            //build the tx
+            (_c = this.txBuilder) === null || _c === void 0 ? void 0 : _c.depositToAssetBank(assetSymbol, accountAddress ||
+                this.currentAccountAddress ||
+                this.bfSigner.getAddress(), amountE9, splitCoin, {
+                txBlock: txb
+            });
+            //add the transfer objects to the tx
+            if (mergedCoin) {
+                txb.transferObjects([mergedCoin], this.currentAccountAddress || this.bfSigner.getAddress());
+            }
+            if (splitCoin) {
+                txb.transferObjects([splitCoin], this.currentAccountAddress || this.bfSigner.getAddress());
+            }
+            if (args && args.sponsored) {
+                // build the gasless tx payload bytes
+                const gaslessTxPayloadBytes = yield this.buildGaslessTxPayloadBytes(txb);
+                try {
+                    const request = {
+                        txBytes: gaslessTxPayloadBytes,
+                    };
+                    // sponsor gas for the transaction
+                    const sponsorTxApiResponse = yield this.accountDataApi.sponsorTx(request);
+                    const txBytes = (0, bcs_1.fromBase64)(sponsorTxApiResponse.data.txBytes);
+                    // sign the transaction with user's wallet
+                    const userSignedTx = yield this.bfSigner.signTx(txBytes);
+                    // execute the transaction with both user's signature and sponsor's signature
+                    const response = yield this.bfSigner.executeSponsoredTx(userSignedTx.bytes, userSignedTx.signature, sponsorTxApiResponse.data.signature, this.suiClient);
+                    return response;
+                }
+                catch (error) {
+                    if (args === null || args === void 0 ? void 0 : args.fallbackToExecuteTx) {
+                        return this.bfSigner.executeTx(txb, this.suiClient);
+                    }
+                    throw error;
+                }
+            }
+            else {
+                return this.bfSigner.executeTx(txb, this.suiClient);
+            }
+        });
+    }
+    refreshToken() {
+        return __awaiter(this, arguments, void 0, function* (force = false) {
+            if (!this.isConnected)
+                return;
+            // If already refreshing, wait for that operation to complete
+            if (this.isRefreshing) {
+                if (this.refreshPromise) {
+                    yield this.refreshPromise;
+                }
+                return;
+            }
+            // Check if token needs refreshing
+            if (!this.isAccessTokenExpired() && !force) {
+                return;
+            }
+            this.isRefreshing = true;
+            this.refreshPromise = this.performTokenRefresh();
+            try {
+                yield this.refreshPromise;
+            }
+            finally {
+                this.isRefreshing = false;
+                this.refreshPromise = null;
+            }
+        });
+    }
+    performTokenRefresh() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const maxRetries = 5;
+            let retryCount = 0;
+            let consecutiveNetworkErrors = 0;
+            while (retryCount < maxRetries) {
+                try {
+                    console.log(`Refreshing token (attempt ${retryCount + 1}/${maxRetries})`);
+                    // Check if refresh token is still valid
+                    if (!this.isRefreshTokenValid()) {
+                        console.log('Refresh token is expired or invalid, triggering logout');
+                        this.logout();
+                        return;
+                    }
+                    yield this.loginAndUpdateToken();
+                    console.log('Token refreshed successfully');
+                    consecutiveNetworkErrors = 0; // Reset network error counter on success
+                    return;
+                }
+                catch (error) {
+                    retryCount++;
+                    console.error(`Error refreshing token (attempt ${retryCount}):`, error);
+                    // Check if this is a network error that we should retry
+                    const isNetworkError = error instanceof Error &&
+                        (error.message.includes('Network Error') ||
+                            error.message.includes('ERR_NETWORK') ||
+                            error.message.includes('ECONNREFUSED') ||
+                            error.message.includes('timeout') ||
+                            error.message.includes('ERR_NETWORK_IO_SUSPENDED'));
+                    // Check if we're currently offline (browser environment only)
+                    const isOffline = typeof navigator !== 'undefined' &&
+                        'onLine' in navigator &&
+                        !navigator.onLine;
+                    if (isNetworkError) {
+                        consecutiveNetworkErrors++;
+                    }
+                    // If we're offline, don't count this as a "real" error - just wait for network to come back
+                    if (isOffline) {
+                        console.log('User is offline, will retry when network comes back online');
+                        return;
+                    }
+                    // If it's not a network error and login failed (tokenResponse is null), logout immediately
+                    if (!isNetworkError && !this.tokenResponse) {
+                        console.error('Login failed permanently, triggering logout');
+                        this.logout();
+                        return;
+                    }
+                    // If we've had too many consecutive network errors, pause refresh attempts temporarily
+                    if (consecutiveNetworkErrors >= 10) {
+                        // Clear any scheduled refresh
+                        if (this.updateTokenTimeout) {
+                            clearTimeout(this.updateTokenTimeout);
+                            this.updateTokenTimeout = null;
+                        }
+                        setTimeout(() => {
+                            console.log('Resuming token refresh attempts');
+                            this.scheduleTokenRefresh(); // Reschedule refresh when resuming
+                        }, 300000); // 5 minutes
+                        return;
+                    }
+                    if (retryCount >= maxRetries && !isOffline) {
+                        if (isNetworkError) {
+                            console.warn('Max retries reached due to network errors, will retry later');
+                            return; // Don't logout for network issues, just wait for next interval
+                        }
+                        else {
+                            console.error('Max retries reached, triggering logout');
+                            this.logout();
+                            return;
+                        }
+                    }
+                    // Exponential backoff: wait 2^retryCount seconds, but cap at 30 seconds for network errors
+                    const baseDelay = isNetworkError ? 5000 : 2000; // Start with 5s for network errors, 2s for others
+                    const delayMs = Math.min(baseDelay * Math.pow(2, retryCount - 1), 30000);
+                    console.log(`Retrying in ${delayMs}ms...`);
+                    yield new Promise((resolve) => setTimeout(resolve, delayMs));
+                }
+            }
+        });
+    }
+    createAccountDataStreamListener(handler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                if (!this.tokenResponse) {
+                    throw new Error('Missing tokenResponse');
+                }
+                const ws = new ws_1.WebSocket(this.configs[Services.AccountWebsocket].basePath, {
+                    headers: {
+                        Authorization: `Bearer ${this.tokenResponse.accessToken}`,
+                    },
+                });
+                ws.onmessage = (event) => __awaiter(this, void 0, void 0, function* () {
+                    yield handler(JSON.parse(event.data));
+                });
+                ws.on('open', () => {
+                    resolve(ws);
+                });
+            });
+        });
+    }
+    createMarketDataStreamListener(handler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                const ws = new ws_1.WebSocket(this.configs[Services.MarketWebsocket].basePath);
+                ws.onmessage = (event) => __awaiter(this, void 0, void 0, function* () {
+                    yield handler(JSON.parse(event.data));
+                });
+                ws.on('open', () => {
+                    resolve(ws);
+                });
+            });
+        });
+    }
+    logout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            console.log('Logging out');
+            if (this.updateTokenTimeout) {
+                clearTimeout(this.updateTokenTimeout);
+                this.updateTokenTimeout = null;
+            }
+            this.tokenResponse = null;
+            this.tokenSetAtSeconds = null;
+            this.isConnected = false;
+            (_a = this.onLogout) === null || _a === void 0 ? void 0 : _a.call(this);
+        });
+    }
+    dispose() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('Disposing SDK resources');
+            if (this.updateTokenTimeout) {
+                clearTimeout(this.updateTokenTimeout);
+                this.updateTokenTimeout = null;
+            }
+            // Clean up visibility change listener
+            if (this.visibilityChangeHandler && typeof document !== 'undefined') {
+                document.removeEventListener('visibilitychange', this.visibilityChangeHandler);
+                this.visibilityChangeHandler = undefined;
+            }
+            // Clean up network change listeners
+            if (typeof window !== 'undefined') {
+                if (this.onlineHandler) {
+                    window.removeEventListener('online', this.onlineHandler);
+                    this.onlineHandler = undefined;
+                }
+                if (this.offlineHandler) {
+                    window.removeEventListener('offline', this.offlineHandler);
+                    this.offlineHandler = undefined;
+                }
+            }
+            this.isConnected = false;
+        });
+    }
+}
+exports.BluefinProSdk = BluefinProSdk;
+BluefinProSdk.TOKEN_REFRESH_THRESHOLD_PERCENTAGE = 0.8;
+//# sourceMappingURL=sdk.js.map