lynx-client 0.0.32 → 0.0.34

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

@@ -13,10 +13,11 @@ class TraderRequests {
             ...transactionOptions,
         });
     }
-    async openNewPosition_static(tradeRequestIdentifier, tradeRequestParams, orderType, referrerDomain, referrerCode, runCapTests, nativeFee) {
+    async openNewPosition_static(tradeRequestIdentifier, tradeRequestParams, orderType, referrerDomain, referrerCode, runCapTests, nativeFee, callOptions) {
         // @ts-ignore
         return this.tradingContract.traderRequest_openNewPosition.staticCall(tradeRequestIdentifier, tradeRequestParams, orderType, referrerDomain, referrerCode, runCapTests, {
             value: nativeFee,
+            ...callOptions,
         });
     }
     async setExistingPositionToMarketClose(positionId, minPrice, maxPrice, nativeFee, transactionOptions) {
@@ -42,17 +43,17 @@ class DirectActions {
     constructor(tradingContract) {
         this.tradingContract = tradingContract;
     }
-    async timeoutOpenMarket(positionId) {
-        return this.tradingContract.directAction_timeout_openMarket(positionId);
+    async timeoutOpenMarket(positionId, transactionOptions) {
+        return this.tradingContract.directAction_timeout_openMarket(positionId, { ...transactionOptions });
     }
-    async timeoutCloseMarket(positionId) {
-        return this.tradingContract.directAction_timeout_closeMarket(positionId);
+    async timeoutCloseMarket(positionId, transactionOptions) {
+        return this.tradingContract.directAction_timeout_closeMarket(positionId, { ...transactionOptions });
     }
-    async cancelPendingPositionLimit(positionId) {
-        return this.tradingContract.directAction_cancelPendingPosition_limit(positionId);
+    async cancelPendingPositionLimit(positionId, transactionOptions) {
+        return this.tradingContract.directAction_cancelPendingPosition_limit(positionId, { ...transactionOptions });
     }
-    async cancelPendingUpdatePositionField(positionId) {
-        return this.tradingContract.directAction_timeout_updateTradeField(positionId);
+    async cancelPendingUpdatePositionField(positionId, transactionOptions) {
+        return this.tradingContract.directAction_timeout_updateTradeField(positionId, { ...transactionOptions });
     }
     async updatePendingPositionLimit(positionId, minPrice, maxPrice, tp, sl, transactionOptions) {
         return this.tradingContract.directAction_updatePendingPosition_limit(positionId, minPrice, maxPrice, tp, sl, {
@@ -64,119 +65,119 @@ class ContractReferences {
     constructor(tradingContract) {
         this.tradingContract = tradingContract;
     }
-    async getOrderBook() {
-        return this.tradingContract.getOrderBook();
+    async getOrderBook(callOptions) {
+        return this.tradingContract.getOrderBook({ ...callOptions });
     }
-    async getTradeIntentsVerifier() {
-        return this.tradingContract.getTradeIntentsVerifier();
+    async getTradeIntentsVerifier(callOptions) {
+        return this.tradingContract.getTradeIntentsVerifier({ ...callOptions });
     }
-    async registry() {
-        return this.tradingContract.registry();
+    async registry(callOptions) {
+        return this.tradingContract.registry({ ...callOptions });
     }
-    async tradingFloor() {
-        return this.tradingContract.tradingFloor();
+    async tradingFloor(callOptions) {
+        return this.tradingContract.tradingFloor({ ...callOptions });
     }
-    async getOnBehalfTrading() {
-        return this.tradingContract.getOnBehalfTrading();
+    async getOnBehalfTrading(callOptions) {
+        return this.tradingContract.getOnBehalfTrading({ ...callOptions });
     }
-    async getFeatureFlagger() {
-        return this.tradingContract.getFeatureFlagger();
+    async getFeatureFlagger(callOptions) {
+        return this.tradingContract.getFeatureFlagger({ ...callOptions });
     }
 }
 class PendableAdmin {
     constructor(tradingContract) {
         this.tradingContract = tradingContract;
     }
-    async admin() {
-        return this.tradingContract.admin();
+    async admin(callOptions) {
+        return this.tradingContract.admin({ ...callOptions });
     }
-    async pendingAdmin() {
-        return this.tradingContract.pendingAdmin();
+    async pendingAdmin(callOptions) {
+        return this.tradingContract.pendingAdmin({ ...callOptions });
     }
 }
 class LynxVersionedContract {
     constructor(tradingContract) {
         this.tradingContract = tradingContract;
     }
-    async getContractName() {
-        return this.tradingContract.getContractName();
+    async getContractName(callOptions) {
+        return this.tradingContract.getContractName({ ...callOptions });
     }
-    async getContractVersion() {
-        return this.tradingContract.getContractVersion();
+    async getContractVersion(callOptions) {
+        return this.tradingContract.getContractVersion({ ...callOptions });
     }
-    async CONTRACT_NAME() {
-        return this.tradingContract.CONTRACT_NAME();
+    async CONTRACT_NAME(callOptions) {
+        return this.tradingContract.CONTRACT_NAME({ ...callOptions });
     }
-    async CONTRACT_VERSION() {
-        return this.tradingContract.CONTRACT_VERSION();
+    async CONTRACT_VERSION(callOptions) {
+        return this.tradingContract.CONTRACT_VERSION({ ...callOptions });
     }
 }
 class Status {
     constructor(tradingContract) {
         this.tradingContract = tradingContract;
     }
-    async isDone() {
-        return this.tradingContract.isDone();
+    async isDone(callOptions) {
+        return this.tradingContract.isDone({ ...callOptions });
     }
-    async isLimitingMarketClosePriceRange() {
-        return this.tradingContract.isLimitingMarketClosePriceRange();
+    async isLimitingMarketClosePriceRange(callOptions) {
+        return this.tradingContract.isLimitingMarketClosePriceRange({ ...callOptions });
     }
-    async isPaused() {
-        return this.tradingContract.isPaused();
+    async isPaused(callOptions) {
+        return this.tradingContract.isPaused({ ...callOptions });
     }
 }
 class Settings {
     constructor(tradingContract) {
         this.tradingContract = tradingContract;
     }
-    async limitOrdersTimelock() {
-        return this.tradingContract.limitOrdersTimelock();
+    async limitOrdersTimelock(callOptions) {
+        return this.tradingContract.limitOrdersTimelock({ ...callOptions });
     }
-    async marketOrdersTimeout() {
-        return this.tradingContract.marketOrdersTimeout();
+    async marketOrdersTimeout(callOptions) {
+        return this.tradingContract.marketOrdersTimeout({ ...callOptions });
     }
-    async minLiveTimeForMarketClose() {
-        return this.tradingContract.minLiveTimeForMarketClose();
+    async minLiveTimeForMarketClose(callOptions) {
+        return this.tradingContract.minLiveTimeForMarketClose({ ...callOptions });
     }
-    async actionFees(actionType) {
-        return this.tradingContract.actionFees(actionType);
+    async actionFees(actionType, callOptions) {
+        return this.tradingContract.actionFees(actionType, { ...callOptions });
     }
-    async limitsMarginFraction() {
-        return this.tradingContract.limitsMarginFraction();
+    async limitsMarginFraction(callOptions) {
+        return this.tradingContract.limitsMarginFraction({ ...callOptions });
     }
-    async setLimitsMarginFraction(limitsMarginFraction) {
-        return this.tradingContract.setLimitsMarginFraction(limitsMarginFraction);
+    async setLimitsMarginFraction(limitsMarginFraction, transactionOptions) {
+        return this.tradingContract.setLimitsMarginFraction(limitsMarginFraction, { ...transactionOptions });
     }
 }
 class Constants {
     constructor(tradingContract) {
         this.tradingContract = tradingContract;
     }
-    async ACCURACY_IMPROVEMENT_SCALE() {
-        return this.tradingContract.ACCURACY_IMPROVEMENT_SCALE();
+    async ACCURACY_IMPROVEMENT_SCALE(callOptions) {
+        return this.tradingContract.ACCURACY_IMPROVEMENT_SCALE({ ...callOptions });
     }
-    async FRACTION_SCALE() {
-        return this.tradingContract.FRACTION_SCALE();
+    async FRACTION_SCALE(callOptions) {
+        return this.tradingContract.FRACTION_SCALE({ ...callOptions });
     }
-    async LEVERAGE_SCALE() {
-        return this.tradingContract.LEVERAGE_SCALE();
+    async LEVERAGE_SCALE(callOptions) {
+        return this.tradingContract.LEVERAGE_SCALE({ ...callOptions });
     }
-    async NATIVE_UNDERLYING_ADDRESS() {
-        return this.tradingContract.NATIVE_UNDERLYING_ADDRESS();
+    async NATIVE_UNDERLYING_ADDRESS(callOptions) {
+        return this.tradingContract.NATIVE_UNDERLYING_ADDRESS({ ...callOptions });
     }
-    async PRECISION() {
-        return this.tradingContract.PRECISION();
+    async PRECISION(callOptions) {
+        return this.tradingContract.PRECISION({ ...callOptions });
     }
 }
 class OnBehalf {
     constructor(tradingContract) {
         this.tradingContract = tradingContract;
     }
-    async onBehalfEnabled() {
-        return this.tradingContract.onBehalfEnabled();
+    async onBehalfEnabled(callOptions) {
+        return this.tradingContract.onBehalfEnabled({ ...callOptions });
     }
-    async setOnBehalfEnabled(enabled) {
-        return this.tradingContract.setOnBehalfEnabled(enabled);
+    async setOnBehalfEnabled(enabled, transactionOptions) {
+        return this.tradingContract.setOnBehalfEnabled(enabled, { ...transactionOptions });
     }
 }
 class TradersPortalServiceService {

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

@@ -39,17 +39,17 @@ 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 generatePositionHashId(settlementAsset, trader, pairId, index, callOptions) {
+        return await this.contract.generatePositionHashId(settlementAsset, trader, BigInt(pairId), BigInt(index), { ...callOptions });
     }
-    async getAllPositionsDataForAllTraders(params) {
+    async getAllPositionsDataForAllTraders(params, callOptions) {
         const contractParams = {
             tradingFloor: params.tradingFloor,
             traderStartIndex: BigInt(params.traderStartIndex),
             positionStartIndex: BigInt(params.positionStartIndex),
             positionsLimit: BigInt(params.positionsLimit),
         };
-        const result = await this.contract.getAllPositionsDataForAllTraders.staticCall(contractParams);
+        const result = await this.contract.getAllPositionsDataForAllTraders.staticCall(contractParams, { ...callOptions });
         const baseResult = (0, ethersTypes_1.ethersStructResponseToObject)(result, ITradingFloorLensService_1.EMPTY_POSITIONS_RESULT);
         // Convert positions and filter out empty ones
         const convertedPositions = result.positions
@@ -63,7 +63,7 @@ class TradingFloorLensService {
             positionLastIndex: Number(baseResult.positionLastIndex),
         };
     }
-    async getAllPositionsLiquidationInfo(params, phases) {
+    async getAllPositionsLiquidationInfo(params, phases, callOptions) {
         const contractParams = {
             tradingFloor: params.tradingFloor,
             traderStartIndex: BigInt(params.traderStartIndex),
@@ -72,11 +72,11 @@ class TradingFloorLensService {
         };
         let result;
         if (phases !== undefined) {
-            result = await this.contract["getAllPositionsLiquidationInfo((address,uint256,uint16,uint256),uint8[])"].staticCall(contractParams, phases.map((p) => BigInt(p)));
+            result = await this.contract["getAllPositionsLiquidationInfo((address,uint256,uint16,uint256),uint8[])"].staticCall(contractParams, phases.map((p) => BigInt(p)), { ...callOptions });
         }
         else {
             result =
-                await this.contract["getAllPositionsLiquidationInfo((address,uint256,uint16,uint256))"].staticCall(contractParams);
+                await this.contract["getAllPositionsLiquidationInfo((address,uint256,uint16,uint256))"].staticCall(contractParams, { ...callOptions });
         }
         const baseResult = (0, ethersTypes_1.ethersStructResponseToObject)(result, ITradingFloorLensService_1.EMPTY_LIQUIDATION_RESULT);
         const convertedPositions = result.positionsLiquidationInfo.map((pos) => convertLiquidationInfo(pos));
@@ -88,19 +88,19 @@ class TradingFloorLensService {
             positionLastIndex: Number(baseResult.positionLastIndex),
         };
     }
-    async getCompletePositionData(tradingFloor, positionId) {
-        const result = await this.contract.getCompletePositionData.staticCall(tradingFloor, positionId);
+    async getCompletePositionData(tradingFloor, positionId, callOptions) {
+        const result = await this.contract.getCompletePositionData.staticCall(tradingFloor, positionId, { ...callOptions });
         return convertPositionData(result);
     }
-    async getPositionsDataForTrader(tradingFloor, trader) {
-        const result = await this.contract.getPositionsDataForTrader.staticCall(tradingFloor, trader);
+    async getPositionsDataForTrader(tradingFloor, trader, callOptions) {
+        const result = await this.contract.getPositionsDataForTrader.staticCall(tradingFloor, trader, { ...callOptions });
         // 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);
+    async getTradingFloorTradeParams(tradingFloor, callOptions) {
+        const result = await this.contract.getTradingFloorTradeParams.staticCall(tradingFloor, { ...callOptions });
         // Result is a tuple/array-like object, extract the named properties
         return {
             tradingFloor: result.tradingFloor,

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/ITriggersAndPortalLensService.js

@@ -1,10 +1,11 @@
 "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_TRADERS_PORTAL_PER_PAIR_PARAMETERS = exports.EMPTY_ON_BEHALF_TRADING_CONFIGURATIONS = exports.EMPTY_ON_BEHALF_TRADING_TOKEN_CONFIG = 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,
+    slBufferFraction: 0,
 };
 exports.EMPTY_COMPLETE_TRADERS_PORTAL_CONFIGURATIONS = {
     contractAddress: "",
@@ -16,11 +17,17 @@ exports.EMPTY_COMPLETE_TRADERS_PORTAL_CONFIGURATIONS = {
     nativeFeeForSingleFieldUpdateRequest: 0n,
     nativeFeeForDoubleFieldUpdateRequest: 0n,
     minLiveTimeForMarketClose: 0,
+    minTimeBeforeFirstLimitUpdate: 0,
+    minTimeBetweenLimitUpdates: 0,
+    limitsMarginFraction: 0,
+    onBehalfEnabled: false,
 };
 exports.EMPTY_COMPLETE_TRIGGER_CONFIGURATIONS = {
     contractAddress: "",
     minTriggerPeriodForMarketOrders: 0,
     maxTriggerPeriodForMarketOrders: 0,
+    minTriggerPeriodForMarketOrdersCat: 0,
+    maxTriggerPeriodForMarketOrdersCat: 0,
     marketOrdersTimeout: 0,
     marketOrderTightTimeRange: 0,
     minTriggerPeriodForLimitOrders: 0,
@@ -28,5 +35,22 @@ exports.EMPTY_COMPLETE_TRIGGER_CONFIGURATIONS = {
     marketOrderCancelFeeFraction: 0,
     openPositionCancellationFeeFraction: 0,
     maxTriggersPerBlock: 0,
+    defaultSlBufferFraction: 0,
     permissionedTriggerAccounts: [],
 };
+exports.EMPTY_ON_BEHALF_TRADING_TOKEN_CONFIG = {
+    token: "",
+    maxPermissionAmount: 0n,
+};
+exports.EMPTY_ON_BEHALF_TRADING_CONFIGURATIONS = {
+    contractAddress: "",
+    isPaused: false,
+    maxPermissionDuration: 0,
+};
+exports.EMPTY_TRADERS_PORTAL_PER_PAIR_PARAMETERS = {
+    pairId: 0,
+    minTimeBeforeFirstLimitUpdate: 0,
+    minTimeBetweenLimitUpdates: 0,
+    minLiveTimeForMarketClose: 0,
+    limitsMarginFraction: 0,
+};