lynx-client 0.0.1-beta.9 → 0.0.3

package/dist/cjs/lib/contractsIntegration/LexLensService/LexLensService.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LexLensService = void 0;
+const LexLens__factory_1 = require("../../typechain/factories/contracts/Peripheral/Lens/LexLens__factory");
+const ethersTypes_1 = require("../../utils/ethersTypes");
+const ILexLensService_1 = require("./ILexLensService");
+class LexLensService {
+    constructor(signerOrProvider, contractAddress) {
+        this.contract = LexLens__factory_1.LexLens__factory.connect(contractAddress, signerOrProvider);
+    }
+    async getAllFeeConfigurationsInLex(lexPool) {
+        const result = await this.contract.getAllFeeConfigurationsInLex(lexPool);
+        // First convert array, then handle special number conversions
+        const baseArray = (0, ethersTypes_1.ethersStructResponseToArray)(result, ILexLensService_1.EMPTY_FEE_CONFIGS_LENS);
+        return baseArray.map(item => ({
+            ...item,
+            feeId: Number(item.feeId),
+            openFeeF: Number(item.openFeeF),
+            closeFeeF: Number(item.closeFeeF),
+            performanceFeeF: Number(item.performanceFeeF),
+        }));
+    }
+    async getAllGroupConfigurationsInLex(lexPool) {
+        const result = await this.contract.getAllGroupConfigurationsInLex(lexPool);
+        const baseArray = (0, ethersTypes_1.ethersStructResponseToArray)(result, ILexLensService_1.EMPTY_GROUP_CONFIGS_LENS);
+        return baseArray.map(item => ({
+            ...item,
+            groupId: Number(item.groupId),
+            maxBorrowF: Number(item.maxBorrowF),
+        }));
+    }
+    async getAllGroupStateInLex(lexPool) {
+        const result = await this.contract.getAllGroupStateInLex(lexPool);
+        const baseArray = (0, ethersTypes_1.ethersStructResponseToArray)(result, ILexLensService_1.EMPTY_LEX_GROUP_STATE_LENS);
+        return baseArray.map(item => ({
+            ...item,
+            groupId: Number(item.groupId),
+        }));
+    }
+    async getAllPairAndGroupAndFeeConfigurationsInLex(lexPool) {
+        return await this.contract.getAllPairAndGroupAndFeeConfigurationsInLex(lexPool);
+    }
+    async getAllPairConfigurationsInLex(lexPool) {
+        const result = await this.contract.getAllPairConfigurationsInLex(lexPool);
+        const baseArray = (0, ethersTypes_1.ethersStructResponseToArray)(result, ILexLensService_1.EMPTY_PAIR_CONFIGS_LENS);
+        return baseArray.map(item => ({
+            ...item,
+            pairId: Number(item.pairId),
+            groupId: Number(item.groupId),
+            feeId: Number(item.feeId),
+        }));
+    }
+    async getAllPairStateInLex(lexPool) {
+        const result = await this.contract.getAllPairStateInLex(lexPool);
+        const baseArray = (0, ethersTypes_1.ethersStructResponseToArray)(result, ILexLensService_1.EMPTY_LEX_PAIR_STATE_LENS);
+        return baseArray.map(item => ({
+            ...item,
+            pairId: Number(item.pairId),
+        }));
+    }
+    async getCompleteConfigsForLex(pool) {
+        const result = await this.contract.getCompleteConfigsForLex(pool);
+        const baseResult = (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_COMPLETE_LEX_CONFIGS, {
+            groupsConfigs: ILexLensService_1.EMPTY_GROUP_CONFIGS_LENS,
+            pairsConfigs: ILexLensService_1.EMPTY_PAIR_CONFIGS_LENS,
+            feesConfigs: ILexLensService_1.EMPTY_FEE_CONFIGS_LENS,
+        }, {
+            lexPoolParams: ILexLensService_1.EMPTY_LEX_POOL_LENS_PARAMS,
+            lexPoolConfigurations: ILexLensService_1.EMPTY_LEX_POOL_LENS_CONFIGS,
+            poolAccountantConfigurations: ILexLensService_1.EMPTY_POOL_ACCOUNTANT_CONFIGURATIONS_LENS,
+        });
+        // Apply number conversions
+        return {
+            ...baseResult,
+            groupsConfigs: baseResult.groupsConfigs.map(item => ({
+                ...item,
+                groupId: Number(item.groupId),
+                maxBorrowF: Number(item.maxBorrowF),
+            })),
+            pairsConfigs: baseResult.pairsConfigs.map(item => ({
+                ...item,
+                pairId: Number(item.pairId),
+                groupId: Number(item.groupId),
+                feeId: Number(item.feeId),
+            })),
+            feesConfigs: baseResult.feesConfigs.map(item => ({
+                ...item,
+                feeId: Number(item.feeId),
+                openFeeF: Number(item.openFeeF),
+                closeFeeF: Number(item.closeFeeF),
+                performanceFeeF: Number(item.performanceFeeF),
+            })),
+        };
+    }
+    async getCompleteConfigsForLexes(pools) {
+        const results = await this.contract.getCompleteConfigsForLexes(pools);
+        return results.map(result => this.convertCompleteConfigsResult(result));
+    }
+    async getCompleteStateForLex(pool) {
+        const result = await this.contract.getCompleteStateForLex(pool);
+        const baseResult = (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_COMPLETE_LEX_STATE, {
+            pairsStates: ILexLensService_1.EMPTY_LEX_PAIR_STATE_LENS,
+            groupsStates: ILexLensService_1.EMPTY_LEX_GROUP_STATE_LENS,
+        }, {
+            lexPoolState: ILexLensService_1.EMPTY_LEX_POOL_LENS_STATE,
+            poolAccountantState: ILexLensService_1.EMPTY_POOL_ACCOUNTANT_STATE_LENS,
+        });
+        // Apply number conversions
+        return {
+            ...baseResult,
+            pairsStates: baseResult.pairsStates.map(item => ({
+                ...item,
+                pairId: Number(item.pairId),
+            })),
+            groupsStates: baseResult.groupsStates.map(item => ({
+                ...item,
+                groupId: Number(item.groupId),
+            })),
+        };
+    }
+    async getCompleteStateForLexes(pools) {
+        const results = await this.contract.getCompleteStateForLexes(pools);
+        return results.map(result => {
+            const baseResult = (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_COMPLETE_LEX_STATE, {
+                pairsStates: ILexLensService_1.EMPTY_LEX_PAIR_STATE_LENS,
+                groupsStates: ILexLensService_1.EMPTY_LEX_GROUP_STATE_LENS,
+            }, {
+                lexPoolState: ILexLensService_1.EMPTY_LEX_POOL_LENS_STATE,
+                poolAccountantState: ILexLensService_1.EMPTY_POOL_ACCOUNTANT_STATE_LENS,
+            });
+            // Apply number conversions
+            return {
+                ...baseResult,
+                pairsStates: baseResult.pairsStates.map(item => ({
+                    ...item,
+                    pairId: Number(item.pairId),
+                })),
+                groupsStates: baseResult.groupsStates.map(item => ({
+                    ...item,
+                    groupId: Number(item.groupId),
+                })),
+            };
+        });
+    }
+    async getLExPoolForPoolAccountant(accountant) {
+        return await this.contract.getLExPoolForPoolAccountant(accountant);
+    }
+    async getLexPairState(lexPool, pairId) {
+        const result = await this.contract.getLexPairState(lexPool, BigInt(pairId));
+        const baseObj = (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_LEX_PAIR_STATE_LENS);
+        return {
+            ...baseObj,
+            pairId: Number(baseObj.pairId),
+        };
+    }
+    async getLexPoolConfigs(lexPool) {
+        const result = await this.contract.getLexPoolConfigs(lexPool);
+        return (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_LEX_POOL_LENS_CONFIGS);
+    }
+    async getLexPoolParams(lexPool) {
+        const result = await this.contract.getLexPoolParams(lexPool);
+        return (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_LEX_POOL_LENS_PARAMS);
+    }
+    async getLexPoolState(lexPool) {
+        const result = await this.contract.getLexPoolState(lexPool);
+        return (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_LEX_POOL_LENS_STATE);
+    }
+    async getLexPoolSupplierState(lexPool, supplier) {
+        const result = await this.contract.getLexPoolSupplierState(lexPool, supplier);
+        return (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_LEX_POOL_SUPPLIER_LENS_STATE, {
+            pendingEpochDeposits: ILexLensService_1.EMPTY_PENDING_EPOCH_DEPOSIT,
+            pendingEpochRedeems: ILexLensService_1.EMPTY_PENDING_EPOCH_REDEEM,
+        });
+    }
+    async getLexPoolsStateAll(lexPools) {
+        const results = await this.contract.getLexPoolsStateAll(lexPools);
+        return (0, ethersTypes_1.ethersStructResponseToArray)(results, ILexLensService_1.EMPTY_LEX_POOL_LENS_STATE);
+    }
+    async getPoolAccountantConfigurationsByPool(lexPool) {
+        const result = await this.contract.getPoolAccountantConfigurationsByPool(lexPool);
+        return (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_POOL_ACCOUNTANT_CONFIGURATIONS_LENS);
+    }
+    async getPoolAccountantConfigurationsByPoolAll(lexPools) {
+        const results = await this.contract.getPoolAccountantConfigurationsByPoolAll(lexPools);
+        return (0, ethersTypes_1.ethersStructResponseToArray)(results, ILexLensService_1.EMPTY_POOL_ACCOUNTANT_CONFIGURATIONS_LENS);
+    }
+    async getPoolAccountantForLexPool(lexPool) {
+        return await this.contract.getPoolAccountantForLexPool(lexPool);
+    }
+    async getPoolAccountantStateByPool(lexPool) {
+        const result = await this.contract.getPoolAccountantStateByPool(lexPool);
+        return (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_POOL_ACCOUNTANT_STATE_LENS);
+    }
+    async getPoolAccountantStateByPoolAll(lexPools) {
+        const results = await this.contract.getPoolAccountantStateByPoolAll(lexPools);
+        return (0, ethersTypes_1.ethersStructResponseToArray)(results, ILexLensService_1.EMPTY_POOL_ACCOUNTANT_STATE_LENS);
+    }
+    async getSupplierCurrentStateAll(lexPools, supplier) {
+        const results = await this.contract.getSupplierCurrentStateAll(lexPools, supplier);
+        return (0, ethersTypes_1.ethersStructResponseToArray)(results, ILexLensService_1.EMPTY_LEX_POOL_SUPPLIER_LENS_STATE, {
+            pendingEpochDeposits: ILexLensService_1.EMPTY_PENDING_EPOCH_DEPOSIT,
+            pendingEpochRedeems: ILexLensService_1.EMPTY_PENDING_EPOCH_REDEEM,
+        });
+    }
+    async tradesValuesMultiplePairs(accountant, pairsTrades) {
+        // @ts-ignore
+        const results = await this.contract.tradesValuesMultiplePairs.staticCall(accountant, pairsTrades);
+        return results.map(pairResults => (0, ethersTypes_1.ethersStructResponseToArray)(pairResults, ILexLensService_1.EMPTY_SINGLE_POSITION_OUTPUT));
+    }
+    async tradesValuesSinglePair(accountant, pairParams) {
+        // @ts-ignore
+        const results = await this.contract.tradesValuesSinglePair.staticCall(accountant, pairParams);
+        return (0, ethersTypes_1.ethersStructResponseToArray)(results, ILexLensService_1.EMPTY_SINGLE_POSITION_OUTPUT);
+    }
+    // Helper methods
+    convertCompleteConfigsResult(result) {
+        const baseResult = (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_COMPLETE_LEX_CONFIGS, {
+            groupsConfigs: ILexLensService_1.EMPTY_GROUP_CONFIGS_LENS,
+            pairsConfigs: ILexLensService_1.EMPTY_PAIR_CONFIGS_LENS,
+            feesConfigs: ILexLensService_1.EMPTY_FEE_CONFIGS_LENS,
+        }, {
+            lexPoolParams: ILexLensService_1.EMPTY_LEX_POOL_LENS_PARAMS,
+            lexPoolConfigurations: ILexLensService_1.EMPTY_LEX_POOL_LENS_CONFIGS,
+            poolAccountantConfigurations: ILexLensService_1.EMPTY_POOL_ACCOUNTANT_CONFIGURATIONS_LENS,
+        });
+        // Apply number conversions
+        return {
+            ...baseResult,
+            groupsConfigs: baseResult.groupsConfigs.map(item => ({
+                ...item,
+                groupId: Number(item.groupId),
+                maxBorrowF: Number(item.maxBorrowF),
+            })),
+            pairsConfigs: baseResult.pairsConfigs.map(item => ({
+                ...item,
+                pairId: Number(item.pairId),
+                groupId: Number(item.groupId),
+                feeId: Number(item.feeId),
+            })),
+            feesConfigs: baseResult.feesConfigs.map(item => ({
+                ...item,
+                feeId: Number(item.feeId),
+                openFeeF: Number(item.openFeeF),
+                closeFeeF: Number(item.closeFeeF),
+                performanceFeeF: Number(item.performanceFeeF),
+            })),
+        };
+    }
+}
+exports.LexLensService = LexLensService;

package/dist/cjs/lib/contractsIntegration/LexLensService/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ILexLensService"), exports);
+__exportStar(require("./LexLensService"), exports);

package/dist/cjs/lib/contractsIntegration/OrderBookService/IOrderBookService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/lib/contractsIntegration/OrderBookService/OrderBookService.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderBookService = void 0;
+const OrderBookV1__factory_1 = require("../../typechain/factories/contracts/Lynx/OrderBook/OrderBookV1__factory");
+class OrderManagement {
+    constructor(orderBookContract) {
+        this.orderBookContract = orderBookContract;
+    }
+    async getAllPendingUpdateOrderIds() {
+        return this.orderBookContract.getAllPendingUpdateOrderIds();
+    }
+    async allPendingUpdateOrderIds(index) {
+        return this.orderBookContract.allPendingUpdateOrderIds(index);
+    }
+    async pendingUpdateTradeFieldOrdersById(positionId) {
+        return this.orderBookContract.pendingUpdateTradeFieldOrdersById(positionId);
+    }
+    async readAndDeleteUpdatePositionOrder(positionId) {
+        return this.orderBookContract.readAndDeleteUpdatePositionOrder(positionId);
+    }
+    async storeUpdatePositionDoubleFieldOrder(positionId, orderType, fieldValueA, fieldValueB) {
+        return this.orderBookContract.storeUpdatePositionDoubleFieldOrder(positionId, orderType, fieldValueA, fieldValueB);
+    }
+    async storeUpdatePositionSingleFieldOrder(positionId, orderType, fieldValue) {
+        return this.orderBookContract.storeUpdatePositionSingleFieldOrder(positionId, orderType, fieldValue);
+    }
+    async updateOrderIdPositionInList(positionId) {
+        return this.orderBookContract.updateOrderIdPositionInList(positionId);
+    }
+}
+class ContractInfo {
+    constructor(orderBookContract) {
+        this.orderBookContract = orderBookContract;
+    }
+    async registry() {
+        return this.orderBookContract.registry();
+    }
+    async tradingFloor() {
+        return this.orderBookContract.tradingFloor();
+    }
+    async admin() {
+        return this.orderBookContract.admin();
+    }
+    async pendingAdmin() {
+        return this.orderBookContract.pendingAdmin();
+    }
+    async implementation() {
+        return this.orderBookContract.implementation();
+    }
+    async pendingImplementation() {
+        return this.orderBookContract.pendingImplementation();
+    }
+}
+class Administration {
+    constructor(orderBookContract) {
+        this.orderBookContract = orderBookContract;
+    }
+    async setTradingFloor(tradingFloor) {
+        return this.orderBookContract.setTradingFloor(tradingFloor);
+    }
+    async _become(orderBookProxy) {
+        return this.orderBookContract._become(orderBookProxy);
+    }
+}
+class Constants {
+    constructor(orderBookContract) {
+        this.orderBookContract = orderBookContract;
+    }
+    async ACCURACY_IMPROVEMENT_SCALE() {
+        return this.orderBookContract.ACCURACY_IMPROVEMENT_SCALE();
+    }
+    async FRACTION_SCALE() {
+        return this.orderBookContract.FRACTION_SCALE();
+    }
+    async LEVERAGE_SCALE() {
+        return this.orderBookContract.LEVERAGE_SCALE();
+    }
+    async PRECISION() {
+        return this.orderBookContract.PRECISION();
+    }
+}
+class OrderBookService {
+    constructor(address, signerOrProvider) {
+        this.signerOrProvider = signerOrProvider;
+        this.orderBookContract = OrderBookV1__factory_1.OrderBookV1__factory.connect(address, signerOrProvider);
+        this.orderManagement = new OrderManagement(this.orderBookContract);
+        this.contractInfo = new ContractInfo(this.orderBookContract);
+        this.administration = new Administration(this.orderBookContract);
+        this.constants = new Constants(this.orderBookContract);
+    }
+}
+exports.OrderBookService = OrderBookService;

package/dist/cjs/lib/contractsIntegration/TradersPortalService/ITradersPortalService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/lib/contractsIntegration/TradersPortalService/TradersPortalServiceService.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradersPortalServiceService = void 0;
+const contractEnums_1 = require("../../constants/contractEnums");
+const TradersPortalV1__factory_1 = require("../../typechain/factories/contracts/Lynx/TradersPortal/TradersPortalV1__factory");
+class TraderRequests {
+    constructor(tradingContract) {
+        this.tradingContract = tradingContract;
+    }
+    async openNewPosition(tradeRequestIdentifier, tradeRequestParams, orderType, referrerDomain, referrerCode, runCapTests, nativeFee, staticCall = false) {
+        if (staticCall) {
+            // @ts-ignore
+            return this.tradingContract.traderRequest_openNewPosition.staticCall(tradeRequestIdentifier, tradeRequestParams, orderType, referrerDomain, referrerCode, runCapTests, {
+                value: nativeFee,
+            });
+        }
+        else {
+            return this.tradingContract.traderRequest_openNewPosition(tradeRequestIdentifier, tradeRequestParams, orderType, referrerDomain, referrerCode, runCapTests, {
+                value: nativeFee,
+            });
+        }
+    }
+    async setExistingPositionToMarketClose(positionId, minPrice, maxPrice, nativeFee) {
+        return this.tradingContract.traderRequest_marketClosePosition(positionId, minPrice, maxPrice, {
+            value: nativeFee,
+        });
+    }
+    async updatePositionSingleField(positionId, orderType, fieldValue, nativeFee) {
+        return this.tradingContract.traderRequest_updatePositionSingleField(positionId, orderType, fieldValue, {
+            value: nativeFee,
+        });
+    }
+    async updatePositionDoubleFieldTpAndSl(positionId, tpValue, slValue, nativeFee) {
+        return this.tradingContract.traderRequest_updatePositionDoubleField(positionId, contractEnums_1.UpdatePositionFieldOrderTypeEnums.UPDATE_TP_AND_SL, tpValue, slValue, {
+            value: nativeFee,
+        });
+    }
+}
+class DirectActions {
+    constructor(tradingContract) {
+        this.tradingContract = tradingContract;
+    }
+    async timeoutOpenMarket(positionId) {
+        return this.tradingContract.directAction_timeout_openMarket(positionId);
+    }
+    async timeoutCloseMarket(positionId) {
+        return this.tradingContract.directAction_timeout_closeMarket(positionId);
+    }
+    async cancelPendingPositionLimit(positionId) {
+        return this.tradingContract.directAction_cancelPendingPosition_limit(positionId);
+    }
+    async cancelPendingUpdatePositionField(positionId) {
+        return this.tradingContract.directAction_timeout_updateTradeField(positionId);
+    }
+    async updatePendingPositionLimit(positionId, minPrice, maxPrice, tp, sl) {
+        return this.tradingContract.directAction_updatePendingPosition_limit(positionId, minPrice, maxPrice, tp, sl);
+    }
+}
+class ContractInfo {
+    constructor(tradingContract) {
+        this.tradingContract = tradingContract;
+    }
+    async getContractName() {
+        return this.tradingContract.getContractName();
+    }
+    async getContractVersion() {
+        return this.tradingContract.getContractVersion();
+    }
+    async getOrderBook() {
+        return this.tradingContract.getOrderBook();
+    }
+    async getTradeIntentsVerifier() {
+        return this.tradingContract.getTradeIntentsVerifier();
+    }
+    async registry() {
+        return this.tradingContract.registry();
+    }
+    async tradingFloor() {
+        return this.tradingContract.tradingFloor();
+    }
+    async admin() {
+        return this.tradingContract.admin();
+    }
+    async pendingAdmin() {
+        return this.tradingContract.pendingAdmin();
+    }
+}
+class Status {
+    constructor(tradingContract) {
+        this.tradingContract = tradingContract;
+    }
+    async isDone() {
+        return this.tradingContract.isDone();
+    }
+    async isLimitingMarketClosePriceRange() {
+        return this.tradingContract.isLimitingMarketClosePriceRange();
+    }
+    async isPaused() {
+        return this.tradingContract.isPaused();
+    }
+}
+class Settings {
+    constructor(tradingContract) {
+        this.tradingContract = tradingContract;
+    }
+    async limitOrdersTimelock() {
+        return this.tradingContract.limitOrdersTimelock();
+    }
+    async marketOrdersTimeout() {
+        return this.tradingContract.marketOrdersTimeout();
+    }
+    async minLiveTimeForMarketClose() {
+        return this.tradingContract.minLiveTimeForMarketClose();
+    }
+    async actionFees(actionType) {
+        return this.tradingContract.actionFees(actionType);
+    }
+}
+class Constants {
+    constructor(tradingContract) {
+        this.tradingContract = tradingContract;
+    }
+    async ACCURACY_IMPROVEMENT_SCALE() {
+        return this.tradingContract.ACCURACY_IMPROVEMENT_SCALE();
+    }
+    async CONTRACT_NAME() {
+        return this.tradingContract.CONTRACT_NAME();
+    }
+    async CONTRACT_VERSION() {
+        return this.tradingContract.CONTRACT_VERSION();
+    }
+    async FRACTION_SCALE() {
+        return this.tradingContract.FRACTION_SCALE();
+    }
+    async LEVERAGE_SCALE() {
+        return this.tradingContract.LEVERAGE_SCALE();
+    }
+    async NATIVE_UNDERLYING_ADDRESS() {
+        return this.tradingContract.NATIVE_UNDERLYING_ADDRESS();
+    }
+    async PRECISION() {
+        return this.tradingContract.PRECISION();
+    }
+}
+class TradersPortalServiceService {
+    constructor(address, signerOrProvider) {
+        this.signerOrProvider = signerOrProvider;
+        this.tradingContract = TradersPortalV1__factory_1.TradersPortalV1__factory.connect(address, signerOrProvider);
+        this.traderRequests = new TraderRequests(this.tradingContract);
+        this.directActions = new DirectActions(this.tradingContract);
+        this.contractInfo = new ContractInfo(this.tradingContract);
+        this.status = new Status(this.tradingContract);
+        this.settings = new Settings(this.tradingContract);
+        this.constants = new Constants(this.tradingContract);
+    }
+}
+exports.TradersPortalServiceService = TradersPortalServiceService;

package/dist/cjs/lib/contractsIntegration/TradersPortalService/TradersPortalUtils.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPositionRequestIdentifier = buildPositionRequestIdentifier;
+exports.buildPositionRequestParams = buildPositionRequestParams;
+const leverageCalculationsUtils_1 = require("../../lynxSystem/leverageCalculationsUtils");
+const chipsCalculationsUtils_1 = require("../../lynxSystem/chipsCalculationsUtils");
+const lynxScalesUtils_1 = require("../../lynxSystem/lynxScalesUtils");
+/**
+ * Builds a position request identifier struct from human-readable values
+ * @param params Human-readable position request identifier parameters
+ * @returns TPositionRequestIdentifierStruct ready for contract interaction
+ */
+function buildPositionRequestIdentifier(params) {
+    return {
+        trader: params.trader,
+        pairId: BigInt(params.pairId),
+        settlementAsset: params.settlementAsset,
+    };
+}
+/**
+ * Builds a position request params struct from human-readable values
+ * @param params Human-readable position request parameters
+ * @returns TPositionRequestParamsStruct ready for contract interaction
+ * @throws Error if both price-based and fraction-based TP/SL are provided
+ */
+function buildPositionRequestParams(params) {
+    // Validate that only one type of TP is provided
+    if (params.takeProfit && params.takeProfitByFraction) {
+        throw new Error("Cannot specify both takeProfit and takeProfitByFraction. Please use only one.");
+    }
+    // Validate that only one type of SL is provided
+    if (params.stopLoss && params.stopLossByFraction) {
+        throw new Error("Cannot specify both stopLoss and stopLossByFraction. Please use only one.");
+    }
+    // Convert collateral from human-readable to chips (18 decimals)
+    const collateralBn = (0, chipsCalculationsUtils_1.floatToChipsBn)(params.collateral);
+    // Convert leverage from human-readable (e.g., 65) to scaled (65 * 100 = 6500)
+    const leverageBn = BigInt((0, leverageCalculationsUtils_1.floatUnitsToScaledLeverage)(params.leverage));
+    // Convert prices from human-readable to scaled (8 decimals)
+    const minPriceBn = (0, lynxScalesUtils_1.floatToPriceBn)(params.minPrice);
+    const maxPriceBn = (0, lynxScalesUtils_1.floatToPriceBn)(params.maxPrice);
+    // Convert optional take profit and stop loss prices
+    const tpBn = params.takeProfit ? (0, lynxScalesUtils_1.floatToPriceBn)(params.takeProfit) : 0n;
+    const slBn = params.stopLoss ? (0, lynxScalesUtils_1.floatToPriceBn)(params.stopLoss) : 0n;
+    // Convert optional fractions (e.g., 0.05 for 5%) to scaled (5 decimals: 0.05 * 100000 = 5000)
+    const tpByFractionBn = params.takeProfitByFraction
+        ? (0, lynxScalesUtils_1.floatToFractionBn)(params.takeProfitByFraction)
+        : 0n;
+    const slByFractionBn = params.stopLossByFraction
+        ? (0, lynxScalesUtils_1.floatToFractionBn)(params.stopLossByFraction)
+        : 0n;
+    return {
+        long: params.isLong,
+        collateral: collateralBn,
+        leverage: leverageBn,
+        minPrice: minPriceBn,
+        maxPrice: maxPriceBn,
+        tp: tpBn,
+        sl: slBn,
+        tpByFraction: tpByFractionBn,
+        slByFraction: slByFractionBn,
+    };
+}

package/dist/cjs/lib/contractsIntegration/TradersPortalService/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ITradersPortalService"), exports);
+__exportStar(require("./TradersPortalServiceService"), exports);
+__exportStar(require("./TradersPortalUtils"), exports);

package/dist/cjs/lib/contractsIntegration/TradingFloorLensService/ITradingFloorLensService.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_TRADE_PARAMS = exports.EMPTY_LIQUIDATION_RESULT = exports.EMPTY_POSITION_LIQUIDATION_INFO = exports.EMPTY_POSITIONS_RESULT = exports.EMPTY_COMPLETE_POSITION_DATA = void 0;
+// Empty struct constants for ethersStructResponseToObject
+exports.EMPTY_COMPLETE_POSITION_DATA = {
+    id: "",
+    settlementAsset: "",
+    trader: "",
+    pairId: 0,
+    positionIndex: 0,
+    collateral: 0n,
+    phase: 0,
+    inPhaseSince: 0,
+    leverage: 0,
+    long: false,
+    openPrice: 0,
+    spreadReductionF: 0,
+    minPrice: 0,
+    maxPrice: 0,
+    tpLastUpdated: 0,
+    slLastUpdated: 0,
+    tp: 0,
+    sl: 0,
+    pendingUpdateOrderType: 0,
+    pendingUpdateOrderTimestamp: 0,
+    pendingUpdateOrderFieldAValue: 0n,
+    pendingUpdateOrderFieldBValue: 0n,
+    funding: 0n,
+    borrowInterest: 0n,
+    liquidationPrice: 0,
+};
+exports.EMPTY_POSITIONS_RESULT = {
+    positions: [],
+    positionsCount: 0,
+    traderLastIndex: 0,
+    done: false,
+};
+exports.EMPTY_POSITION_LIQUIDATION_INFO = {
+    id: "",
+    phase: 0,
+    funding: 0n,
+    borrowInterest: 0n,
+    liquidationPrice: 0,
+};
+exports.EMPTY_LIQUIDATION_RESULT = {
+    positionsLiquidationInfo: [],
+    positionsCount: 0,
+    traderLastIndex: 0,
+    positionLastIndex: 0,
+    done: false,
+};
+exports.EMPTY_TRADE_PARAMS = {
+    tradingFloor: "",
+    maxTradesPerTrader: 0,
+    maxSlF: 0,
+    maxSanityProfitF: 0,
+};