lynx-client 0.0.32 → 0.0.33

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

@@ -6,19 +6,19 @@ class PositionQueries {
     constructor(tradingFloorContract) {
         this.tradingFloorContract = tradingFloorContract;
     }
-    async generatePositionHashId(settlementAsset, trader, pairId, index) {
-        return this.tradingFloorContract.generatePositionHashId(settlementAsset, trader, pairId, index);
+    async generatePositionHashId(settlementAsset, trader, pairId, index, callOptions) {
+        return this.tradingFloorContract.generatePositionHashId(settlementAsset, trader, pairId, index, { ...callOptions });
     }
-    async getPositionPortalInfo(positionId) {
-        const result = await this.tradingFloorContract.getPositionPortalInfo(positionId);
+    async getPositionPortalInfo(positionId, callOptions) {
+        const result = await this.tradingFloorContract.getPositionPortalInfo(positionId, { ...callOptions });
         return {
             phase: result[0],
             timestamp: result[1],
             trader: result[2],
         };
     }
-    async getPositionRegistrationParams(positionId) {
-        const result = await this.tradingFloorContract.getPositionRegistrationParams(positionId);
+    async getPositionRegistrationParams(positionId, callOptions) {
+        const result = await this.tradingFloorContract.getPositionRegistrationParams(positionId, { ...callOptions });
         return {
             collateral: result.collateral,
             leverage: result.leverage,
@@ -27,8 +27,8 @@ class PositionQueries {
             tp: result.tp,
         };
     }
-    async getPositionTriggerInfo(positionId) {
-        const result = await this.tradingFloorContract.getPositionTriggerInfo(positionId);
+    async getPositionTriggerInfo(positionId, callOptions) {
+        const result = await this.tradingFloorContract.getPositionTriggerInfo(positionId, { ...callOptions });
         return {
             phase: result.positionPhase,
             timestamp: result.timestamp,
@@ -37,8 +37,8 @@ class PositionQueries {
             spreadReductionF: result.spreadReductionF,
         };
     }
-    async positionIdentifiersById(positionId) {
-        const result = await this.tradingFloorContract.positionIdentifiersById(positionId);
+    async positionIdentifiersById(positionId, callOptions) {
+        const result = await this.tradingFloorContract.positionIdentifiersById(positionId, { ...callOptions });
         return {
             settlementAsset: result.settlementAsset,
             pairId: result.pairId,
@@ -46,8 +46,8 @@ class PositionQueries {
             trader: result.trader,
         };
     }
-    async positionLimitsInfoById(positionId) {
-        const result = await this.tradingFloorContract.positionLimitsInfoById(positionId);
+    async positionLimitsInfoById(positionId, callOptions) {
+        const result = await this.tradingFloorContract.positionLimitsInfoById(positionId, { ...callOptions });
         return {
             tpLastUpdated: result.tpLastUpdated,
             slLastUpdated: result.slLastUpdated,
@@ -55,8 +55,8 @@ class PositionQueries {
             sl: result.sl,
         };
     }
-    async positionsById(positionId) {
-        const result = await this.tradingFloorContract.positionsById(positionId);
+    async positionsById(positionId, callOptions) {
+        const result = await this.tradingFloorContract.positionsById(positionId, { ...callOptions });
         return {
             collateral: result.collateral,
             phase: result.phase,
@@ -67,8 +67,8 @@ class PositionQueries {
             spreadReductionF: result.spreadReductionF,
         };
     }
-    async triggerPricesById(positionId) {
-        const result = await this.tradingFloorContract.triggerPricesById(positionId);
+    async triggerPricesById(positionId, callOptions) {
+        const result = await this.tradingFloorContract.triggerPricesById(positionId, { ...callOptions });
         return {
             minPrice: result.minPrice,
             maxPrice: result.maxPrice,
@@ -76,164 +76,164 @@ class PositionQueries {
             slByFraction: result.slByFraction,
         };
     }
-    async initialCollateralByPositionId(positionId) {
-        return this.tradingFloorContract.initialCollateralByPositionId(positionId);
+    async initialCollateralByPositionId(positionId, callOptions) {
+        return this.tradingFloorContract.initialCollateralByPositionId(positionId, { ...callOptions });
     }
 }
 class SettlementAndPool {
     constructor(tradingFloorContract) {
         this.tradingFloorContract = tradingFloorContract;
     }
-    async isSettlementAssetSupported(settlementAsset) {
-        return this.tradingFloorContract.isSettlementAssetSupported(settlementAsset);
+    async isSettlementAssetSupported(settlementAsset, callOptions) {
+        return this.tradingFloorContract.isSettlementAssetSupported(settlementAsset, { ...callOptions });
     }
-    async lexPoolForAsset(asset) {
-        return this.tradingFloorContract.lexPoolForAsset(asset);
+    async lexPoolForAsset(asset, callOptions) {
+        return this.tradingFloorContract.lexPoolForAsset(asset, { ...callOptions });
     }
-    async poolAccountantForAsset(asset) {
-        return this.tradingFloorContract.poolAccountantForAsset(asset);
+    async poolAccountantForAsset(asset, callOptions) {
+        return this.tradingFloorContract.poolAccountantForAsset(asset, { ...callOptions });
     }
 }
 class Deprecated {
     constructor(tradingFloorContract) {
         this.tradingFloorContract = tradingFloorContract;
     }
-    async deprecated_pairTraders(asset, pairId, index) {
-        return this.tradingFloorContract.deprecated_pairTraders(asset, pairId, index);
+    async deprecated_pairTraders(asset, pairId, index, callOptions) {
+        return this.tradingFloorContract.deprecated_pairTraders(asset, pairId, index, { ...callOptions });
     }
-    async deprecated_pairTradersArray(asset, pairIndex) {
-        return this.tradingFloorContract.deprecated_pairTradersArray(asset, pairIndex);
+    async deprecated_pairTradersArray(asset, pairIndex, callOptions) {
+        return this.tradingFloorContract.deprecated_pairTradersArray(asset, pairIndex, { ...callOptions });
     }
-    async deprecated_pairTradersInfo(asset, trader, pairId) {
-        const result = await this.tradingFloorContract.deprecated_pairTradersInfo(asset, trader, pairId);
+    async deprecated_pairTradersInfo(asset, trader, pairId, callOptions) {
+        const result = await this.tradingFloorContract.deprecated_pairTradersInfo(asset, trader, pairId, { ...callOptions });
         return {
             positionsCounter: result.deprecated_positionsCounter,
             positionInArray: result.positionInArray,
         };
     }
-    async pausedPairs(pairId) {
-        return this.tradingFloorContract.pausedPairs(pairId);
+    async pausedPairs(pairId, callOptions) {
+        return this.tradingFloorContract.pausedPairs(pairId, { ...callOptions });
     }
 }
 class TraderTracking {
     constructor(tradingFloorContract) {
         this.tradingFloorContract = tradingFloorContract;
     }
-    async traders(index) {
-        return this.tradingFloorContract.traders(index);
+    async traders(index, callOptions) {
+        return this.tradingFloorContract.traders(index, { ...callOptions });
     }
-    async tradersAmount() {
-        return this.tradingFloorContract.tradersAmount();
+    async tradersAmount(callOptions) {
+        return this.tradingFloorContract.tradersAmount({ ...callOptions });
     }
-    async tradersIndex(trader) {
-        return this.tradingFloorContract.tradersIndex(trader);
+    async tradersIndex(trader, callOptions) {
+        return this.tradingFloorContract.tradersIndex(trader, { ...callOptions });
     }
-    async getActivePositionsAmountForTrader(trader) {
-        return this.tradingFloorContract.getActivePositionsAmountForTrader(trader);
+    async getActivePositionsAmountForTrader(trader, callOptions) {
+        return this.tradingFloorContract.getActivePositionsAmountForTrader(trader, { ...callOptions });
     }
-    async activePositionIdsByTrader(trader, index) {
-        return this.tradingFloorContract.activePositionIdsByTrader(trader, index);
+    async activePositionIdsByTrader(trader, index, callOptions) {
+        return this.tradingFloorContract.activePositionIdsByTrader(trader, index, { ...callOptions });
     }
-    async positionIdToActivePositionIndex(trader, positionId) {
-        return this.tradingFloorContract.positionIdToActivePositionIndex(trader, positionId);
+    async positionIdToActivePositionIndex(trader, positionId, callOptions) {
+        return this.tradingFloorContract.positionIdToActivePositionIndex(trader, positionId, { ...callOptions });
     }
-    async getActivePositionIdsForTrader(trader) {
-        return this.tradingFloorContract.getActivePositionIdsForTrader(trader);
+    async getActivePositionIdsForTrader(trader, callOptions) {
+        return this.tradingFloorContract.getActivePositionIdsForTrader(trader, { ...callOptions });
     }
-    async getNextPositionIndexForTrader(trader) {
-        return this.tradingFloorContract.getNextPositionIndexForTrader(trader);
+    async getNextPositionIndexForTrader(trader, callOptions) {
+        return this.tradingFloorContract.getNextPositionIndexForTrader(trader, { ...callOptions });
     }
-    async pairTradersLastUsedPositionIndex(trader) {
-        return this.tradingFloorContract.pairTradersLastUsedPositionIndex(trader);
+    async pairTradersLastUsedPositionIndex(trader, callOptions) {
+        return this.tradingFloorContract.pairTradersLastUsedPositionIndex(trader, { ...callOptions });
     }
 }
 class TradingParameters {
     constructor(tradingFloorContract) {
         this.tradingFloorContract = tradingFloorContract;
     }
-    async maxSanityProfitF() {
-        return this.tradingFloorContract.maxSanityProfitF();
+    async maxSanityProfitF(callOptions) {
+        return this.tradingFloorContract.maxSanityProfitF({ ...callOptions });
     }
-    async maxSlF() {
-        return this.tradingFloorContract.maxSlF();
+    async maxSlF(callOptions) {
+        return this.tradingFloorContract.maxSlF({ ...callOptions });
     }
-    async maxTradesPerTrader() {
-        return this.tradingFloorContract.maxTradesPerTrader();
+    async maxTradesPerTrader(callOptions) {
+        return this.tradingFloorContract.maxTradesPerTrader({ ...callOptions });
     }
 }
 class Fees {
     constructor(tradingFloorContract) {
         this.tradingFloorContract = tradingFloorContract;
     }
-    async feesMap(asset, feeType) {
-        return this.tradingFloorContract.feesMap(asset, feeType);
+    async feesMap(asset, feeType, callOptions) {
+        return this.tradingFloorContract.feesMap(asset, feeType, { ...callOptions });
     }
 }
 class ContractReferences {
     constructor(tradingFloorContract) {
         this.tradingFloorContract = tradingFloorContract;
     }
-    async registry() {
-        return this.tradingFloorContract.registry();
+    async registry(callOptions) {
+        return this.tradingFloorContract.registry({ ...callOptions });
     }
 }
 class PendableAdmin {
     constructor(tradingFloorContract) {
         this.tradingFloorContract = tradingFloorContract;
     }
-    async admin() {
-        return this.tradingFloorContract.admin();
+    async admin(callOptions) {
+        return this.tradingFloorContract.admin({ ...callOptions });
     }
-    async pendingAdmin() {
-        return this.tradingFloorContract.pendingAdmin();
+    async pendingAdmin(callOptions) {
+        return this.tradingFloorContract.pendingAdmin({ ...callOptions });
     }
 }
 class PendableImplementation {
     constructor(tradingFloorContract) {
         this.tradingFloorContract = tradingFloorContract;
     }
-    async implementation() {
-        return this.tradingFloorContract.implementation();
+    async implementation(callOptions) {
+        return this.tradingFloorContract.implementation({ ...callOptions });
     }
-    async pendingImplementation() {
-        return this.tradingFloorContract.pendingImplementation();
+    async pendingImplementation(callOptions) {
+        return this.tradingFloorContract.pendingImplementation({ ...callOptions });
     }
 }
 class LynxVersionedContract {
     constructor(tradingFloorContract) {
         this.tradingFloorContract = tradingFloorContract;
     }
-    async getContractName() {
-        return this.tradingFloorContract.getContractName();
+    async getContractName(callOptions) {
+        return this.tradingFloorContract.getContractName({ ...callOptions });
     }
-    async getContractVersion() {
-        return this.tradingFloorContract.getContractVersion();
+    async getContractVersion(callOptions) {
+        return this.tradingFloorContract.getContractVersion({ ...callOptions });
     }
-    async CONTRACT_NAME() {
-        return this.tradingFloorContract.CONTRACT_NAME();
+    async CONTRACT_NAME(callOptions) {
+        return this.tradingFloorContract.CONTRACT_NAME({ ...callOptions });
     }
-    async CONTRACT_VERSION() {
-        return this.tradingFloorContract.CONTRACT_VERSION();
+    async CONTRACT_VERSION(callOptions) {
+        return this.tradingFloorContract.CONTRACT_VERSION({ ...callOptions });
     }
 }
 class Constants {
     constructor(tradingFloorContract) {
         this.tradingFloorContract = tradingFloorContract;
     }
-    async ACCURACY_IMPROVEMENT_SCALE() {
-        return this.tradingFloorContract.ACCURACY_IMPROVEMENT_SCALE();
+    async ACCURACY_IMPROVEMENT_SCALE(callOptions) {
+        return this.tradingFloorContract.ACCURACY_IMPROVEMENT_SCALE({ ...callOptions });
     }
-    async FRACTION_SCALE() {
-        return this.tradingFloorContract.FRACTION_SCALE();
+    async FRACTION_SCALE(callOptions) {
+        return this.tradingFloorContract.FRACTION_SCALE({ ...callOptions });
     }
-    async LEVERAGE_SCALE() {
-        return this.tradingFloorContract.LEVERAGE_SCALE();
+    async LEVERAGE_SCALE(callOptions) {
+        return this.tradingFloorContract.LEVERAGE_SCALE({ ...callOptions });
     }
-    async MAX_FEE_FRACTION_FOR_CANCEL() {
-        return this.tradingFloorContract.MAX_FEE_FRACTION_FOR_CANCEL();
+    async MAX_FEE_FRACTION_FOR_CANCEL(callOptions) {
+        return this.tradingFloorContract.MAX_FEE_FRACTION_FOR_CANCEL({ ...callOptions });
     }
-    async PRECISION() {
-        return this.tradingFloorContract.PRECISION();
+    async PRECISION(callOptions) {
+        return this.tradingFloorContract.PRECISION({ ...callOptions });
     }
 }
 class TradingFloorService {

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

@@ -8,8 +8,8 @@ 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));
+    async getPairConfigsInTriggers(triggers, pairId, callOptions) {
+        const result = await this.contract.getPairConfigsInTriggers(triggers, BigInt(pairId), { ...callOptions });
         const baseStruct = (0, ethersTypes_1.ethersStructResponseToObject)(result, ITriggersAndPortalLensService_1.EMPTY_PAIR_CONFIGS_IN_TRIGGERS);
         return {
             ...baseStruct,
@@ -18,8 +18,8 @@ class TriggersAndPortalLensService {
             spreadFraction: Number(baseStruct.spreadFraction),
         };
     }
-    async getPairsConfigsInTriggers(triggers, pairIds) {
-        const result = await this.contract.getPairsConfigsInTriggers(triggers, pairIds.map(id => BigInt(id)));
+    async getPairsConfigsInTriggers(triggers, pairIds, callOptions) {
+        const result = await this.contract.getPairsConfigsInTriggers(triggers, pairIds.map(id => BigInt(id)), { ...callOptions });
         const baseArray = (0, ethersTypes_1.ethersStructResponseToArray)(result, ITriggersAndPortalLensService_1.EMPTY_PAIR_CONFIGS_IN_TRIGGERS);
         return baseArray.map(item => ({
             ...item,
@@ -28,8 +28,8 @@ class TriggersAndPortalLensService {
             spreadFraction: Number(item.spreadFraction),
         }));
     }
-    async getTradersPortalConfigurations(tradersPortal) {
-        const result = await this.contract.getTradersPortalConfigurations(tradersPortal);
+    async getTradersPortalConfigurations(tradersPortal, callOptions) {
+        const result = await this.contract.getTradersPortalConfigurations(tradersPortal, { ...callOptions });
         const baseStruct = (0, ethersTypes_1.ethersStructResponseToObject)(result, ITriggersAndPortalLensService_1.EMPTY_COMPLETE_TRADERS_PORTAL_CONFIGURATIONS);
         return {
             ...baseStruct,
@@ -38,8 +38,8 @@ class TriggersAndPortalLensService {
             minLiveTimeForMarketClose: Number(baseStruct.minLiveTimeForMarketClose),
         };
     }
-    async getTriggersConfigurations(triggers) {
-        const result = await this.contract.getTriggersConfigurations(triggers);
+    async getTriggersConfigurations(triggers, callOptions) {
+        const result = await this.contract.getTriggersConfigurations(triggers, { ...callOptions });
         const baseStruct = (0, ethersTypes_1.ethersStructResponseToObject)(result, ITriggersAndPortalLensService_1.EMPTY_COMPLETE_TRIGGER_CONFIGURATIONS);
         return {
             ...baseStruct,

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

@@ -6,175 +6,175 @@ class OpenTriggers {
     constructor(triggersContract) {
         this.triggersContract = triggersContract;
     }
-    async market(positionId, pricePayload, nativeFee) {
-        return this.triggersContract.trigger_openTrade_market(positionId, pricePayload, { value: nativeFee });
+    async market(positionId, pricePayload, nativeFee, transactionOptions) {
+        return this.triggersContract.trigger_openTrade_market(positionId, pricePayload, { value: nativeFee, ...transactionOptions });
     }
-    async limit(positionId, pricePayload, nativeFee) {
-        return this.triggersContract.trigger_openTrade_limit(positionId, pricePayload, { value: nativeFee });
+    async limit(positionId, pricePayload, nativeFee, transactionOptions) {
+        return this.triggersContract.trigger_openTrade_limit(positionId, pricePayload, { value: nativeFee, ...transactionOptions });
     }
 }
 class CloseTriggers {
     constructor(triggersContract) {
         this.triggersContract = triggersContract;
     }
-    async market(positionId, pricePayload, nativeFee) {
-        return this.triggersContract.trigger_closeTrade_market(positionId, pricePayload, { value: nativeFee });
+    async market(positionId, pricePayload, nativeFee, transactionOptions) {
+        return this.triggersContract.trigger_closeTrade_market(positionId, pricePayload, { value: nativeFee, ...transactionOptions });
     }
-    async takeProfit(positionId, pricePayload, nativeFee) {
-        return this.triggersContract.trigger_closeTrade_TP(positionId, pricePayload, { value: nativeFee });
+    async takeProfit(positionId, pricePayload, nativeFee, transactionOptions) {
+        return this.triggersContract.trigger_closeTrade_TP(positionId, pricePayload, { value: nativeFee, ...transactionOptions });
     }
-    async stopLoss(positionId, pricePayload, nativeFee) {
-        return this.triggersContract.trigger_closeTrade_SL(positionId, pricePayload, { value: nativeFee });
+    async stopLoss(positionId, pricePayload, nativeFee, transactionOptions) {
+        return this.triggersContract.trigger_closeTrade_SL(positionId, pricePayload, { value: nativeFee, ...transactionOptions });
     }
-    async liquidation(positionId, pricePayload, nativeFee) {
-        return this.triggersContract.trigger_closeTrade_LIQ(positionId, pricePayload, { value: nativeFee });
+    async liquidation(positionId, pricePayload, nativeFee, transactionOptions) {
+        return this.triggersContract.trigger_closeTrade_LIQ(positionId, pricePayload, { value: nativeFee, ...transactionOptions });
     }
 }
 class UpdateTriggers {
     constructor(triggersContract) {
         this.triggersContract = triggersContract;
     }
-    async takeProfit(positionId, pricePayload, nativeFee) {
-        return this.triggersContract.trigger_update_TP(positionId, pricePayload, { value: nativeFee });
+    async takeProfit(positionId, pricePayload, nativeFee, transactionOptions) {
+        return this.triggersContract.trigger_update_TP(positionId, pricePayload, { value: nativeFee, ...transactionOptions });
     }
-    async stopLoss(positionId, pricePayload, nativeFee) {
-        return this.triggersContract.trigger_update_SL(positionId, pricePayload, { value: nativeFee });
+    async stopLoss(positionId, pricePayload, nativeFee, transactionOptions) {
+        return this.triggersContract.trigger_update_SL(positionId, pricePayload, { value: nativeFee, ...transactionOptions });
     }
-    async takeProfitAndStopLoss(positionId, pricePayload, nativeFee) {
-        return this.triggersContract.trigger_update_TP_and_SL(positionId, pricePayload, { value: nativeFee });
+    async takeProfitAndStopLoss(positionId, pricePayload, nativeFee, transactionOptions) {
+        return this.triggersContract.trigger_update_TP_and_SL(positionId, pricePayload, { value: nativeFee, ...transactionOptions });
     }
 }
 class TimeoutTriggers {
     constructor(triggersContract) {
         this.triggersContract = triggersContract;
     }
-    async marketOpen(positionId) {
-        return this.triggersContract.trigger_timeout_marketOpen(positionId);
+    async marketOpen(positionId, transactionOptions) {
+        return this.triggersContract.trigger_timeout_marketOpen(positionId, { ...transactionOptions });
     }
-    async marketClose(positionId) {
-        return this.triggersContract.trigger_timeout_marketClose(positionId);
+    async marketClose(positionId, transactionOptions) {
+        return this.triggersContract.trigger_timeout_marketClose(positionId, { ...transactionOptions });
     }
-    async updatePosition(positionId) {
-        return this.triggersContract.trigger_timeout_updatePosition(positionId);
+    async updatePosition(positionId, transactionOptions) {
+        return this.triggersContract.trigger_timeout_updatePosition(positionId, { ...transactionOptions });
     }
 }
 class ContractReferences {
     constructor(triggersContract) {
         this.triggersContract = triggersContract;
     }
-    async orderBook() {
-        return this.triggersContract.orderBook();
+    async orderBook(callOptions) {
+        return this.triggersContract.orderBook({ ...callOptions });
     }
-    async tradingFloor() {
-        return this.triggersContract.tradingFloor();
+    async tradingFloor(callOptions) {
+        return this.triggersContract.tradingFloor({ ...callOptions });
     }
-    async priceValidator() {
-        return this.triggersContract.priceValidator();
+    async priceValidator(callOptions) {
+        return this.triggersContract.priceValidator({ ...callOptions });
     }
 }
 class PendableAdmin {
     constructor(triggersContract) {
         this.triggersContract = triggersContract;
     }
-    async admin() {
-        return this.triggersContract.admin();
+    async admin(callOptions) {
+        return this.triggersContract.admin({ ...callOptions });
     }
-    async pendingAdmin() {
-        return this.triggersContract.pendingAdmin();
+    async pendingAdmin(callOptions) {
+        return this.triggersContract.pendingAdmin({ ...callOptions });
     }
 }
 class Status {
     constructor(triggersContract) {
         this.triggersContract = triggersContract;
     }
-    async isDone() {
-        return this.triggersContract.isDone();
+    async isDone(callOptions) {
+        return this.triggersContract.isDone({ ...callOptions });
     }
-    async isPaused() {
-        return this.triggersContract.isPaused();
+    async isPaused(callOptions) {
+        return this.triggersContract.isPaused({ ...callOptions });
     }
 }
 class Configuration {
     constructor(triggersContract) {
         this.triggersContract = triggersContract;
     }
-    async marketOrderCancelFeeFraction() {
-        return this.triggersContract.marketOrderCancelFeeFraction();
+    async marketOrderCancelFeeFraction(callOptions) {
+        return this.triggersContract.marketOrderCancelFeeFraction({ ...callOptions });
     }
-    async marketOrderTightTimeRange() {
-        return this.triggersContract.marketOrderTightTimeRange();
+    async marketOrderTightTimeRange(callOptions) {
+        return this.triggersContract.marketOrderTightTimeRange({ ...callOptions });
     }
-    async marketOrdersTimeout() {
-        return this.triggersContract.marketOrdersTimeout();
+    async marketOrdersTimeout(callOptions) {
+        return this.triggersContract.marketOrdersTimeout({ ...callOptions });
     }
-    async maxTriggerPeriodForMarketOrders() {
-        return this.triggersContract.maxTriggerPeriodForMarketOrders();
+    async maxTriggerPeriodForMarketOrders(callOptions) {
+        return this.triggersContract.maxTriggerPeriodForMarketOrders({ ...callOptions });
     }
-    async minTriggerPeriodForLimitOrders() {
-        return this.triggersContract.minTriggerPeriodForLimitOrders();
+    async minTriggerPeriodForLimitOrders(callOptions) {
+        return this.triggersContract.minTriggerPeriodForLimitOrders({ ...callOptions });
     }
-    async minTriggerPeriodForMarketOrders() {
-        return this.triggersContract.minTriggerPeriodForMarketOrders();
+    async minTriggerPeriodForMarketOrders(callOptions) {
+        return this.triggersContract.minTriggerPeriodForMarketOrders({ ...callOptions });
     }
-    async openPositionCancellationFeeFraction() {
-        return this.triggersContract.openPositionCancellationFeeFraction();
+    async openPositionCancellationFeeFraction(callOptions) {
+        return this.triggersContract.openPositionCancellationFeeFraction({ ...callOptions });
     }
-    async triggerPriceFreshnessTimeRange() {
-        return this.triggersContract.triggerPriceFreshnessTimeRange();
+    async triggerPriceFreshnessTimeRange(callOptions) {
+        return this.triggersContract.triggerPriceFreshnessTimeRange({ ...callOptions });
     }
-    async maxTriggersPerBlock() {
-        return this.triggersContract.maxTriggersPerBlock();
+    async maxTriggersPerBlock(callOptions) {
+        return this.triggersContract.maxTriggersPerBlock({ ...callOptions });
     }
-    async triggersPerBlock(blockNumber) {
-        return this.triggersContract.triggersPerBlock(blockNumber);
+    async triggersPerBlock(blockNumber, callOptions) {
+        return this.triggersContract.triggersPerBlock(blockNumber, { ...callOptions });
     }
-    async limitsMarginFraction() {
-        return this.triggersContract.limitsMarginFraction();
+    async limitsMarginFraction(callOptions) {
+        return this.triggersContract.limitsMarginFraction({ ...callOptions });
     }
 }
 class PairConfiguration {
     constructor(triggersContract) {
         this.triggersContract = triggersContract;
     }
-    async maxConfidenceFractionForPair(pairId) {
-        return this.triggersContract.maxConfidenceFractionForPair(pairId);
+    async maxConfidenceFractionForPair(pairId, callOptions) {
+        return this.triggersContract.maxConfidenceFractionForPair(pairId, { ...callOptions });
     }
-    async spreadFractionForPair(pairId) {
-        return this.triggersContract.spreadFractionForPair(pairId);
+    async spreadFractionForPair(pairId, callOptions) {
+        return this.triggersContract.spreadFractionForPair(pairId, { ...callOptions });
     }
 }
 class Permissions {
     constructor(triggersContract) {
         this.triggersContract = triggersContract;
     }
-    async isAllowedToTrigger(account) {
-        return this.triggersContract.isAllowedToTrigger(account);
+    async isAllowedToTrigger(account, callOptions) {
+        return this.triggersContract.isAllowedToTrigger(account, { ...callOptions });
     }
-    async getAllTriggerPermissionedAccounts() {
-        return this.triggersContract.getAllTriggerPermissionedAccounts();
+    async getAllTriggerPermissionedAccounts(callOptions) {
+        return this.triggersContract.getAllTriggerPermissionedAccounts({ ...callOptions });
     }
 }
 class Constants {
     constructor(triggersContract) {
         this.triggersContract = triggersContract;
     }
-    async ACCURACY_IMPROVEMENT_SCALE() {
-        return this.triggersContract.ACCURACY_IMPROVEMENT_SCALE();
+    async ACCURACY_IMPROVEMENT_SCALE(callOptions) {
+        return this.triggersContract.ACCURACY_IMPROVEMENT_SCALE({ ...callOptions });
     }
-    async FRACTION_SCALE() {
-        return this.triggersContract.FRACTION_SCALE();
+    async FRACTION_SCALE(callOptions) {
+        return this.triggersContract.FRACTION_SCALE({ ...callOptions });
     }
-    async LEVERAGE_SCALE() {
-        return this.triggersContract.LEVERAGE_SCALE();
+    async LEVERAGE_SCALE(callOptions) {
+        return this.triggersContract.LEVERAGE_SCALE({ ...callOptions });
     }
-    async MAX_ALLOWED_CONFIDENCE_FRACTION() {
-        return this.triggersContract.MAX_ALLOWED_CONFIDENCE_FRACTION();
+    async MAX_ALLOWED_CONFIDENCE_FRACTION(callOptions) {
+        return this.triggersContract.MAX_ALLOWED_CONFIDENCE_FRACTION({ ...callOptions });
     }
-    async MAX_ALLOWED_SPREAD_FRACTION() {
-        return this.triggersContract.MAX_ALLOWED_SPREAD_FRACTION();
+    async MAX_ALLOWED_SPREAD_FRACTION(callOptions) {
+        return this.triggersContract.MAX_ALLOWED_SPREAD_FRACTION({ ...callOptions });
     }
-    async PRECISION() {
-        return this.triggersContract.PRECISION();
+    async PRECISION(callOptions) {
+        return this.triggersContract.PRECISION({ ...callOptions });
     }
 }
 class TriggersService {