lynx-client 0.0.1-beta.9 → 0.0.3

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradingFloorLensService = void 0;
+const TradingFloorLens__factory_1 = require("../../typechain/factories/contracts/Peripheral/Lens/TradingFloorLens__factory");
+const ethersTypes_1 = require("../../utils/ethersTypes");
+const ITradingFloorLensService_1 = require("./ITradingFloorLensService");
+// Helper function to convert position data to proper types
+function convertPositionData(pos) {
+    const baseStruct = (0, ethersTypes_1.ethersStructResponseToObject)(pos, ITradingFloorLensService_1.EMPTY_COMPLETE_POSITION_DATA);
+    return {
+        ...baseStruct,
+        pairId: Number(baseStruct.pairId),
+        positionIndex: Number(baseStruct.positionIndex),
+        phase: Number(baseStruct.phase),
+        inPhaseSince: Number(baseStruct.inPhaseSince),
+        leverage: Number(baseStruct.leverage),
+        openPrice: Number(baseStruct.openPrice),
+        spreadReductionF: Number(baseStruct.spreadReductionF),
+        minPrice: Number(baseStruct.minPrice),
+        maxPrice: Number(baseStruct.maxPrice),
+        tpLastUpdated: Number(baseStruct.tpLastUpdated),
+        slLastUpdated: Number(baseStruct.slLastUpdated),
+        tp: Number(baseStruct.tp),
+        sl: Number(baseStruct.sl),
+        pendingUpdateOrderType: Number(baseStruct.pendingUpdateOrderType),
+        pendingUpdateOrderTimestamp: Number(baseStruct.pendingUpdateOrderTimestamp),
+        liquidationPrice: Number(baseStruct.liquidationPrice),
+    };
+}
+function convertLiquidationInfo(pos) {
+    const baseStruct = (0, ethersTypes_1.ethersStructResponseToObject)(pos, ITradingFloorLensService_1.EMPTY_POSITION_LIQUIDATION_INFO);
+    return {
+        ...baseStruct,
+        phase: Number(baseStruct.phase),
+        liquidationPrice: Number(baseStruct.liquidationPrice),
+    };
+}
+class TradingFloorLensService {
+    constructor(signerOrProvider, contractAddress) {
+        this.contract = TradingFloorLens__factory_1.TradingFloorLens__factory.connect(contractAddress, signerOrProvider);
+    }
+    async generatePositionHashId(settlementAsset, trader, pairId, index) {
+        return await this.contract.generatePositionHashId(settlementAsset, trader, BigInt(pairId), BigInt(index));
+    }
+    async getAllPositionsDataForAllTraders(params) {
+        const contractParams = {
+            tradingFloor: params.tradingFloor,
+            traderStartIndex: BigInt(params.traderStartIndex),
+            positionsLimit: BigInt(params.positionsLimit),
+        };
+        const result = await this.contract.getAllPositionsDataForAllTraders.staticCall(contractParams);
+        const baseResult = (0, ethersTypes_1.ethersStructResponseToObject)(result, ITradingFloorLensService_1.EMPTY_POSITIONS_RESULT);
+        // Convert positions and filter out empty ones
+        const convertedPositions = result.positions
+            .filter((pos) => pos.collateral > 0n)
+            .map((pos) => convertPositionData(pos));
+        return {
+            ...baseResult,
+            positions: convertedPositions,
+            positionsCount: Number(baseResult.positionsCount),
+            traderLastIndex: Number(baseResult.traderLastIndex),
+        };
+    }
+    async getAllPositionsLiquidationInfo(params, phases) {
+        const contractParams = {
+            tradingFloor: params.tradingFloor,
+            traderStartIndex: BigInt(params.traderStartIndex),
+            positionStartIndex: BigInt(params.positionStartIndex),
+            positionsLimit: BigInt(params.positionsLimit),
+        };
+        let result;
+        if (phases !== undefined) {
+            result = await this.contract["getAllPositionsLiquidationInfo((address,uint256,uint16,uint256),uint8[])"].staticCall(contractParams, phases.map((p) => BigInt(p)));
+        }
+        else {
+            result =
+                await this.contract["getAllPositionsLiquidationInfo((address,uint256,uint16,uint256))"].staticCall(contractParams);
+        }
+        const baseResult = (0, ethersTypes_1.ethersStructResponseToObject)(result, ITradingFloorLensService_1.EMPTY_LIQUIDATION_RESULT);
+        const convertedPositions = result.positionsLiquidationInfo.map((pos) => convertLiquidationInfo(pos));
+        return {
+            ...baseResult,
+            positionsLiquidationInfo: convertedPositions,
+            positionsCount: Number(baseResult.positionsCount),
+            traderLastIndex: Number(baseResult.traderLastIndex),
+            positionLastIndex: Number(baseResult.positionLastIndex),
+        };
+    }
+    async getCompletePositionData(tradingFloor, positionId) {
+        const result = await this.contract.getCompletePositionData.staticCall(tradingFloor, positionId);
+        return convertPositionData(result);
+    }
+    async getPositionsDataForTrader(tradingFloor, trader) {
+        const result = await this.contract.getPositionsDataForTrader.staticCall(tradingFloor, trader);
+        // Convert and filter out empty positions (collateral = 0)
+        return result
+            .filter((pos) => pos.collateral > 0n)
+            .map((pos) => convertPositionData(pos));
+    }
+    async getTradingFloorTradeParams(tradingFloor) {
+        const result = await this.contract.getTradingFloorTradeParams.staticCall(tradingFloor);
+        // Result is a tuple/array-like object, extract the named properties
+        return {
+            tradingFloor: result.tradingFloor,
+            maxTradesPerTrader: Number(result.maxTradesPerTrader),
+            maxSlF: Number(result.maxSlF),
+            maxSanityProfitF: Number(result.maxSanityProfitF),
+        };
+    }
+}
+exports.TradingFloorLensService = TradingFloorLensService;

package/dist/cjs/lib/contractsIntegration/TradingFloorLensService/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("./ITradingFloorLensService"), exports);
+__exportStar(require("./TradingFloorLensService"), exports);

package/dist/cjs/lib/contractsIntegration/TradingFloorService/ITradingFloorService.js

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

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

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradingFloorService = void 0;
+const TradingFloorV1__factory_1 = require("../../typechain/factories/contracts/Lynx/TradingFloor/TradingFloorV1__factory");
+class TradingFloorService {
+    constructor(address, signerOrProvider) {
+        this.signerOrProvider = signerOrProvider;
+        this.tradingFloorContract = TradingFloorV1__factory_1.TradingFloorV1__factory.connect(address, signerOrProvider);
+    }
+    // Read-only Functions - Position Information
+    async generatePositionHashId(settlementAsset, trader, pairId, index) {
+        return this.tradingFloorContract.generatePositionHashId(settlementAsset, trader, pairId, index);
+    }
+    async getPositionPortalInfo(positionId) {
+        const result = await this.tradingFloorContract.getPositionPortalInfo(positionId);
+        return {
+            phase: result[0],
+            timestamp: result[1],
+            trader: result[2],
+        };
+    }
+    async getPositionRegistrationParams(positionId) {
+        const result = await this.tradingFloorContract.getPositionRegistrationParams(positionId);
+        return {
+            collateral: result.collateral,
+            leverage: result.leverage,
+            long: result.long,
+            openPrice: result.openPrice,
+            tp: result.tp,
+        };
+    }
+    async getPositionTriggerInfo(positionId) {
+        const result = await this.tradingFloorContract.getPositionTriggerInfo(positionId);
+        return {
+            phase: result.positionPhase,
+            timestamp: result.timestamp,
+            pairId: result.pairId,
+            long: result.long,
+            spreadReductionF: result.spreadReductionF,
+        };
+    }
+    async positionIdentifiersById(positionId) {
+        const result = await this.tradingFloorContract.positionIdentifiersById(positionId);
+        return {
+            settlementAsset: result.settlementAsset,
+            pairId: result.pairId,
+            index: result.index,
+            trader: result.trader,
+        };
+    }
+    async positionLimitsInfoById(positionId) {
+        const result = await this.tradingFloorContract.positionLimitsInfoById(positionId);
+        return {
+            tpLastUpdated: result.tpLastUpdated,
+            slLastUpdated: result.slLastUpdated,
+            tp: result.tp,
+            sl: result.sl,
+        };
+    }
+    async positionsById(positionId) {
+        const result = await this.tradingFloorContract.positionsById(positionId);
+        return {
+            collateral: result.collateral,
+            phase: result.phase,
+            inPhaseSince: result.inPhaseSince,
+            leverage: result.leverage,
+            long: result.long,
+            openPrice: result.openPrice,
+            spreadReductionF: result.spreadReductionF,
+        };
+    }
+    async triggerPricesById(positionId) {
+        const result = await this.tradingFloorContract.triggerPricesById(positionId);
+        return {
+            minPrice: result.minPrice,
+            maxPrice: result.maxPrice,
+            tpByFraction: result.tpByFraction,
+            slByFraction: result.slByFraction,
+        };
+    }
+    async initialCollateralByPositionId(positionId) {
+        return this.tradingFloorContract.initialCollateralByPositionId(positionId);
+    }
+    // Read-only Functions - Settlement & Pool Information
+    async isSettlementAssetSupported(settlementAsset) {
+        return this.tradingFloorContract.isSettlementAssetSupported(settlementAsset);
+    }
+    async lexPoolForAsset(asset) {
+        return this.tradingFloorContract.lexPoolForAsset(asset);
+    }
+    async poolAccountantForAsset(asset) {
+        return this.tradingFloorContract.poolAccountantForAsset(asset);
+    }
+    // Read-only Functions - Trading Pair Information
+    async deprecated_pairTraders(asset, pairId, index) {
+        return this.tradingFloorContract.deprecated_pairTraders(asset, pairId, index);
+    }
+    async deprecated_pairTradersArray(asset, pairIndex) {
+        return this.tradingFloorContract.deprecated_pairTradersArray(asset, pairIndex);
+    }
+    async deprecated_pairTradersInfo(asset, trader, pairId) {
+        const result = await this.tradingFloorContract.deprecated_pairTradersInfo(asset, trader, pairId);
+        return {
+            positionsCounter: result.deprecated_positionsCounter,
+            positionInArray: result.positionInArray,
+        };
+    }
+    async pausedPairs(pairId) {
+        return this.tradingFloorContract.pausedPairs(pairId);
+    }
+    // Read-only Functions - Global Trader Tracking (v1.01)
+    async traders(index) {
+        return this.tradingFloorContract.traders(index);
+    }
+    async tradersAmount() {
+        return this.tradingFloorContract.tradersAmount();
+    }
+    async tradersIndex(trader) {
+        return this.tradingFloorContract.tradersIndex(trader);
+    }
+    async getActivePositionsAmountForTrader(trader) {
+        return this.tradingFloorContract.getActivePositionsAmountForTrader(trader);
+    }
+    async activePositionIdsByTrader(trader, index) {
+        return this.tradingFloorContract.activePositionIdsByTrader(trader, index);
+    }
+    async positionIdToActivePositionIndex(trader, positionId) {
+        return this.tradingFloorContract.positionIdToActivePositionIndex(trader, positionId);
+    }
+    // Read-only Functions - Trading Parameters
+    async maxSanityProfitF() {
+        return this.tradingFloorContract.maxSanityProfitF();
+    }
+    async maxSlF() {
+        return this.tradingFloorContract.maxSlF();
+    }
+    async maxTradesPerTrader() {
+        return this.tradingFloorContract.maxTradesPerTrader();
+    }
+    // Read-only Functions - Fee Information
+    async feesMap(asset, feeType) {
+        return this.tradingFloorContract.feesMap(asset, feeType);
+    }
+    // Read-only Functions - Admin & Implementation Info
+    async admin() {
+        return this.tradingFloorContract.admin();
+    }
+    async pendingAdmin() {
+        return this.tradingFloorContract.pendingAdmin();
+    }
+    async implementation() {
+        return this.tradingFloorContract.implementation();
+    }
+    async pendingImplementation() {
+        return this.tradingFloorContract.pendingImplementation();
+    }
+    async registry() {
+        return this.tradingFloorContract.registry();
+    }
+    // Constants
+    async ACCURACY_IMPROVEMENT_SCALE() {
+        return this.tradingFloorContract.ACCURACY_IMPROVEMENT_SCALE();
+    }
+    async FRACTION_SCALE() {
+        return this.tradingFloorContract.FRACTION_SCALE();
+    }
+    async LEVERAGE_SCALE() {
+        return this.tradingFloorContract.LEVERAGE_SCALE();
+    }
+    async MAX_FEE_FRACTION_FOR_CANCEL() {
+        return this.tradingFloorContract.MAX_FEE_FRACTION_FOR_CANCEL();
+    }
+    async PRECISION() {
+        return this.tradingFloorContract.PRECISION();
+    }
+}
+exports.TradingFloorService = TradingFloorService;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradingFloorService = void 0;
+var TradingFloorService_1 = require("./TradingFloorService");
+Object.defineProperty(exports, "TradingFloorService", { enumerable: true, get: function () { return TradingFloorService_1.TradingFloorService; } });

package/dist/cjs/lib/contractsIntegration/TriggersAndPortalLensService/ITriggersAndPortalLensService.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_COMPLETE_TRIGGER_CONFIGURATIONS = exports.EMPTY_COMPLETE_TRADERS_PORTAL_CONFIGURATIONS = exports.EMPTY_PAIR_CONFIGS_IN_TRIGGERS = void 0;
+exports.EMPTY_PAIR_CONFIGS_IN_TRIGGERS = {
+    pairId: 0,
+    maxConfidenceFraction: 0,
+    spreadFraction: 0,
+};
+exports.EMPTY_COMPLETE_TRADERS_PORTAL_CONFIGURATIONS = {
+    limitOrdersTimelock: 0,
+    marketOrdersTimeout: 0,
+    isLimitingMarketClosePriceRange: false,
+    nativeFeeForPositionOpenRequest: 0n,
+    nativeFeeForMarketCloseRequest: 0n,
+    nativeFeeForSingleFieldUpdateRequest: 0n,
+    nativeFeeForDoubleFieldUpdateRequest: 0n,
+    minLiveTimeForMarketClose: 0,
+};
+exports.EMPTY_COMPLETE_TRIGGER_CONFIGURATIONS = {
+    minTriggerPeriodForMarketOrders: 0,
+    maxTriggerPeriodForMarketOrders: 0,
+    marketOrdersTimeout: 0,
+    marketOrderTightTimeRange: 0,
+    minTriggerPeriodForLimitOrders: 0,
+    triggerPriceFreshnessTimeRange: 0,
+    marketOrderCancelFeeFraction: 0,
+    openPositionCancellationFeeFraction: 0,
+    maxTriggersPerBlock: 0,
+    permissionedTriggerAccounts: [],
+};

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriggersAndPortalLensService = void 0;
+const TriggersAndPortalLens__factory_1 = require("../../typechain/factories/contracts/Peripheral/Lens/TriggersAndPortalLens__factory");
+const ethersTypes_1 = require("../../utils/ethersTypes");
+const ITriggersAndPortalLensService_1 = require("./ITriggersAndPortalLensService");
+class TriggersAndPortalLensService {
+    constructor(signerOrProvider, address) {
+        this.contract = TriggersAndPortalLens__factory_1.TriggersAndPortalLens__factory.connect(address, signerOrProvider);
+    }
+    async getPairConfigsInTriggers(triggers, pairId) {
+        const result = await this.contract.getPairConfigsInTriggers(triggers, BigInt(pairId));
+        const baseStruct = (0, ethersTypes_1.ethersStructResponseToObject)(result, ITriggersAndPortalLensService_1.EMPTY_PAIR_CONFIGS_IN_TRIGGERS);
+        return {
+            ...baseStruct,
+            pairId: Number(baseStruct.pairId),
+            maxConfidenceFraction: Number(baseStruct.maxConfidenceFraction),
+            spreadFraction: Number(baseStruct.spreadFraction),
+        };
+    }
+    async getPairsConfigsInTriggers(triggers, pairIds) {
+        const result = await this.contract.getPairsConfigsInTriggers(triggers, pairIds.map(id => BigInt(id)));
+        const baseArray = (0, ethersTypes_1.ethersStructResponseToArray)(result, ITriggersAndPortalLensService_1.EMPTY_PAIR_CONFIGS_IN_TRIGGERS);
+        return baseArray.map(item => ({
+            ...item,
+            pairId: Number(item.pairId),
+            maxConfidenceFraction: Number(item.maxConfidenceFraction),
+            spreadFraction: Number(item.spreadFraction),
+        }));
+    }
+    async getTradersPortalConfigurations(tradersPortal) {
+        const result = await this.contract.getTradersPortalConfigurations(tradersPortal);
+        const baseStruct = (0, ethersTypes_1.ethersStructResponseToObject)(result, ITriggersAndPortalLensService_1.EMPTY_COMPLETE_TRADERS_PORTAL_CONFIGURATIONS);
+        return {
+            ...baseStruct,
+            limitOrdersTimelock: Number(baseStruct.limitOrdersTimelock),
+            marketOrdersTimeout: Number(baseStruct.marketOrdersTimeout),
+            minLiveTimeForMarketClose: Number(baseStruct.minLiveTimeForMarketClose),
+        };
+    }
+    async getTriggersConfigurations(triggers) {
+        const result = await this.contract.getTriggersConfigurations(triggers);
+        const baseStruct = (0, ethersTypes_1.ethersStructResponseToObject)(result, ITriggersAndPortalLensService_1.EMPTY_COMPLETE_TRIGGER_CONFIGURATIONS);
+        return {
+            ...baseStruct,
+            minTriggerPeriodForMarketOrders: Number(baseStruct.minTriggerPeriodForMarketOrders),
+            maxTriggerPeriodForMarketOrders: Number(baseStruct.maxTriggerPeriodForMarketOrders),
+            marketOrdersTimeout: Number(baseStruct.marketOrdersTimeout),
+            marketOrderTightTimeRange: Number(baseStruct.marketOrderTightTimeRange),
+            minTriggerPeriodForLimitOrders: Number(baseStruct.minTriggerPeriodForLimitOrders),
+            triggerPriceFreshnessTimeRange: Number(baseStruct.triggerPriceFreshnessTimeRange),
+            marketOrderCancelFeeFraction: Number(baseStruct.marketOrderCancelFeeFraction),
+            openPositionCancellationFeeFraction: Number(baseStruct.openPositionCancellationFeeFraction),
+            maxTriggersPerBlock: Number(baseStruct.maxTriggersPerBlock),
+        };
+    }
+}
+exports.TriggersAndPortalLensService = TriggersAndPortalLensService;

package/dist/cjs/lib/contractsIntegration/TriggersAndPortalLensService/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("./ITriggersAndPortalLensService"), exports);
+__exportStar(require("./TriggersAndPortalLensService"), exports);

package/dist/cjs/lib/contractsIntegration/TriggersService/ITriggersService.js

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

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

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriggersService = void 0;
+const TriggersV1__factory_1 = require("../../typechain/factories/contracts/Lynx/Triggers/TriggersV1__factory");
+class OpenTriggers {
+    constructor(triggersContract) {
+        this.triggersContract = triggersContract;
+    }
+    async market(positionId, pricePayload, nativeFee) {
+        return this.triggersContract.trigger_openTrade_market(positionId, pricePayload, { value: nativeFee });
+    }
+    async limit(positionId, pricePayload, nativeFee) {
+        return this.triggersContract.trigger_openTrade_limit(positionId, pricePayload, { value: nativeFee });
+    }
+}
+class CloseTriggers {
+    constructor(triggersContract) {
+        this.triggersContract = triggersContract;
+    }
+    async market(positionId, pricePayload, nativeFee) {
+        return this.triggersContract.trigger_closeTrade_market(positionId, pricePayload, { value: nativeFee });
+    }
+    async takeProfit(positionId, pricePayload, nativeFee) {
+        return this.triggersContract.trigger_closeTrade_TP(positionId, pricePayload, { value: nativeFee });
+    }
+    async stopLoss(positionId, pricePayload, nativeFee) {
+        return this.triggersContract.trigger_closeTrade_SL(positionId, pricePayload, { value: nativeFee });
+    }
+    async liquidation(positionId, pricePayload, nativeFee) {
+        return this.triggersContract.trigger_closeTrade_LIQ(positionId, pricePayload, { value: nativeFee });
+    }
+}
+class UpdateTriggers {
+    constructor(triggersContract) {
+        this.triggersContract = triggersContract;
+    }
+    async takeProfit(positionId, pricePayload, nativeFee) {
+        return this.triggersContract.trigger_update_TP(positionId, pricePayload, { value: nativeFee });
+    }
+    async stopLoss(positionId, pricePayload, nativeFee) {
+        return this.triggersContract.trigger_update_SL(positionId, pricePayload, { value: nativeFee });
+    }
+    async takeProfitAndStopLoss(positionId, pricePayload, nativeFee) {
+        return this.triggersContract.trigger_update_TP_and_SL(positionId, pricePayload, { value: nativeFee });
+    }
+}
+class TimeoutTriggers {
+    constructor(triggersContract) {
+        this.triggersContract = triggersContract;
+    }
+    async marketOpen(positionId) {
+        return this.triggersContract.trigger_timeout_marketOpen(positionId);
+    }
+    async marketClose(positionId) {
+        return this.triggersContract.trigger_timeout_marketClose(positionId);
+    }
+    async updatePosition(positionId) {
+        return this.triggersContract.trigger_timeout_updatePosition(positionId);
+    }
+}
+class ContractInfo {
+    constructor(triggersContract) {
+        this.triggersContract = triggersContract;
+    }
+    async admin() {
+        return this.triggersContract.admin();
+    }
+    async pendingAdmin() {
+        return this.triggersContract.pendingAdmin();
+    }
+    async orderBook() {
+        return this.triggersContract.orderBook();
+    }
+    async tradingFloor() {
+        return this.triggersContract.tradingFloor();
+    }
+    async priceValidator() {
+        return this.triggersContract.priceValidator();
+    }
+}
+class Status {
+    constructor(triggersContract) {
+        this.triggersContract = triggersContract;
+    }
+    async isDone() {
+        return this.triggersContract.isDone();
+    }
+    async isPaused() {
+        return this.triggersContract.isPaused();
+    }
+}
+class Configuration {
+    constructor(triggersContract) {
+        this.triggersContract = triggersContract;
+    }
+    async marketOrderCancelFeeFraction() {
+        return this.triggersContract.marketOrderCancelFeeFraction();
+    }
+    async marketOrderTightTimeRange() {
+        return this.triggersContract.marketOrderTightTimeRange();
+    }
+    async marketOrdersTimeout() {
+        return this.triggersContract.marketOrdersTimeout();
+    }
+    async maxTriggerPeriodForMarketOrders() {
+        return this.triggersContract.maxTriggerPeriodForMarketOrders();
+    }
+    async minTriggerPeriodForLimitOrders() {
+        return this.triggersContract.minTriggerPeriodForLimitOrders();
+    }
+    async minTriggerPeriodForMarketOrders() {
+        return this.triggersContract.minTriggerPeriodForMarketOrders();
+    }
+    async openPositionCancellationFeeFraction() {
+        return this.triggersContract.openPositionCancellationFeeFraction();
+    }
+    async triggerPriceFreshnessTimeRange() {
+        return this.triggersContract.triggerPriceFreshnessTimeRange();
+    }
+    async maxTriggersPerBlock() {
+        return this.triggersContract.maxTriggersPerBlock();
+    }
+    async triggersPerBlock(blockNumber) {
+        return this.triggersContract.triggersPerBlock(blockNumber);
+    }
+}
+class PairConfiguration {
+    constructor(triggersContract) {
+        this.triggersContract = triggersContract;
+    }
+    async maxConfidenceFractionForPair(pairId) {
+        return this.triggersContract.maxConfidenceFractionForPair(pairId);
+    }
+    async spreadFractionForPair(pairId) {
+        return this.triggersContract.spreadFractionForPair(pairId);
+    }
+}
+class Permissions {
+    constructor(triggersContract) {
+        this.triggersContract = triggersContract;
+    }
+    async isAllowedToTrigger(account) {
+        return this.triggersContract.isAllowedToTrigger(account);
+    }
+    async getAllTriggerPermissionedAccounts() {
+        return this.triggersContract.getAllTriggerPermissionedAccounts();
+    }
+}
+class Constants {
+    constructor(triggersContract) {
+        this.triggersContract = triggersContract;
+    }
+    async ACCURACY_IMPROVEMENT_SCALE() {
+        return this.triggersContract.ACCURACY_IMPROVEMENT_SCALE();
+    }
+    async FRACTION_SCALE() {
+        return this.triggersContract.FRACTION_SCALE();
+    }
+    async LEVERAGE_SCALE() {
+        return this.triggersContract.LEVERAGE_SCALE();
+    }
+    async MAX_ALLOWED_CONFIDENCE_FRACTION() {
+        return this.triggersContract.MAX_ALLOWED_CONFIDENCE_FRACTION();
+    }
+    async MAX_ALLOWED_SPREAD_FRACTION() {
+        return this.triggersContract.MAX_ALLOWED_SPREAD_FRACTION();
+    }
+    async PRECISION() {
+        return this.triggersContract.PRECISION();
+    }
+}
+class TriggersService {
+    constructor(address, signerOrProvider) {
+        this.signerOrProvider = signerOrProvider;
+        this.triggersContract = TriggersV1__factory_1.TriggersV1__factory.connect(address, signerOrProvider);
+        this.openTriggers = new OpenTriggers(this.triggersContract);
+        this.closeTriggers = new CloseTriggers(this.triggersContract);
+        this.updateTriggers = new UpdateTriggers(this.triggersContract);
+        this.timeoutTriggers = new TimeoutTriggers(this.triggersContract);
+        this.contractInfo = new ContractInfo(this.triggersContract);
+        this.status = new Status(this.triggersContract);
+        this.configuration = new Configuration(this.triggersContract);
+        this.pairConfiguration = new PairConfiguration(this.triggersContract);
+        this.permissions = new Permissions(this.triggersContract);
+        this.constants = new Constants(this.triggersContract);
+    }
+}
+exports.TriggersService = TriggersService;