lynx-client 0.0.32 → 0.0.33

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

@@ -6,17 +6,17 @@ class IntentsVerifierLensService {
     constructor(signerOrProvider, address) {
         this.contract = IntentsVerifierLens__factory_1.IntentsVerifierLens__factory.connect(address, signerOrProvider);
     }
-    async getRequestBuildingInfoForChipsIntentsVerifier() {
-        return await this.contract.getRequestBuildingInfoForChipsIntentsVerifier();
+    async getRequestBuildingInfoForChipsIntentsVerifier(callOptions) {
+        return await this.contract.getRequestBuildingInfoForChipsIntentsVerifier({ ...callOptions });
     }
-    async getRequestBuildingInfoForLiquidityIntentsVerifier() {
-        return await this.contract.getRequestBuildingInfoForLiquidityIntentsVerifier();
+    async getRequestBuildingInfoForLiquidityIntentsVerifier(callOptions) {
+        return await this.contract.getRequestBuildingInfoForLiquidityIntentsVerifier({ ...callOptions });
     }
-    async getRequestBuildingInfoForTradeIntentsVerifier() {
-        return await this.contract.getRequestBuildingInfoForTradeIntentsVerifier();
+    async getRequestBuildingInfoForTradeIntentsVerifier(callOptions) {
+        return await this.contract.getRequestBuildingInfoForTradeIntentsVerifier({ ...callOptions });
     }
-    async registry() {
-        return await this.contract.registry();
+    async registry(callOptions) {
+        return await this.contract.registry({ ...callOptions });
     }
     getContract() {
         return this.contract;

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

@@ -8,8 +8,8 @@ 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);
+    async getAllFeeConfigurationsInLex(lexPool, callOptions) {
+        const result = await this.contract.getAllFeeConfigurationsInLex(lexPool, { ...callOptions });
         // 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 => ({
@@ -20,8 +20,8 @@ class LexLensService {
             performanceFeeF: Number(item.performanceFeeF),
         }));
     }
-    async getAllGroupConfigurationsInLex(lexPool) {
-        const result = await this.contract.getAllGroupConfigurationsInLex(lexPool);
+    async getAllGroupConfigurationsInLex(lexPool, callOptions) {
+        const result = await this.contract.getAllGroupConfigurationsInLex(lexPool, { ...callOptions });
         const baseArray = (0, ethersTypes_1.ethersStructResponseToArray)(result, ILexLensService_1.EMPTY_GROUP_CONFIGS_LENS);
         return baseArray.map(item => ({
             ...item,
@@ -29,19 +29,19 @@ class LexLensService {
             maxBorrowF: Number(item.maxBorrowF),
         }));
     }
-    async getAllGroupStateInLex(lexPool) {
-        const result = await this.contract.getAllGroupStateInLex(lexPool);
+    async getAllGroupStateInLex(lexPool, callOptions) {
+        const result = await this.contract.getAllGroupStateInLex(lexPool, { ...callOptions });
         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 getAllPairAndGroupAndFeeConfigurationsInLex(lexPool, callOptions) {
+        return await this.contract.getAllPairAndGroupAndFeeConfigurationsInLex(lexPool, { ...callOptions });
     }
-    async getAllPairConfigurationsInLex(lexPool) {
-        const result = await this.contract.getAllPairConfigurationsInLex(lexPool);
+    async getAllPairConfigurationsInLex(lexPool, callOptions) {
+        const result = await this.contract.getAllPairConfigurationsInLex(lexPool, { ...callOptions });
         const baseArray = (0, ethersTypes_1.ethersStructResponseToArray)(result, ILexLensService_1.EMPTY_PAIR_CONFIGS_LENS);
         return baseArray.map(item => ({
             ...item,
@@ -50,16 +50,16 @@ class LexLensService {
             feeId: Number(item.feeId),
         }));
     }
-    async getAllPairStateInLex(lexPool) {
-        const result = await this.contract.getAllPairStateInLex(lexPool);
+    async getAllPairStateInLex(lexPool, callOptions) {
+        const result = await this.contract.getAllPairStateInLex(lexPool, { ...callOptions });
         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);
+    async getCompleteConfigsForLex(pool, callOptions) {
+        const result = await this.contract.getCompleteConfigsForLex(pool, { ...callOptions });
         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,
@@ -92,12 +92,12 @@ class LexLensService {
             })),
         };
     }
-    async getCompleteConfigsForLexes(pools) {
-        const results = await this.contract.getCompleteConfigsForLexes(pools);
+    async getCompleteConfigsForLexes(pools, callOptions) {
+        const results = await this.contract.getCompleteConfigsForLexes(pools, { ...callOptions });
         return results.map(result => this.convertCompleteConfigsResult(result));
     }
-    async getCompleteStateForLex(pool) {
-        const result = await this.contract.getCompleteStateForLex(pool);
+    async getCompleteStateForLex(pool, callOptions) {
+        const result = await this.contract.getCompleteStateForLex(pool, { ...callOptions });
         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,
@@ -122,8 +122,8 @@ class LexLensService {
             })),
         };
     }
-    async getCompleteStateForLexes(pools) {
-        const results = await this.contract.getCompleteStateForLexes(pools);
+    async getCompleteStateForLexes(pools, callOptions) {
+        const results = await this.contract.getCompleteStateForLexes(pools, { ...callOptions });
         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,
@@ -150,80 +150,80 @@ class LexLensService {
             };
         });
     }
-    async getLExPoolForPoolAccountant(accountant) {
-        return await this.contract.getLExPoolForPoolAccountant(accountant);
+    async getLExPoolForPoolAccountant(accountant, callOptions) {
+        return await this.contract.getLExPoolForPoolAccountant(accountant, { ...callOptions });
     }
-    async getLexPairState(lexPool, pairId) {
-        const result = await this.contract.getLexPairState(lexPool, BigInt(pairId));
+    async getLexPairState(lexPool, pairId, callOptions) {
+        const result = await this.contract.getLexPairState(lexPool, BigInt(pairId), { ...callOptions });
         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);
+    async getLexPoolConfigs(lexPool, callOptions) {
+        const result = await this.contract.getLexPoolConfigs(lexPool, { ...callOptions });
         return (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_LEX_POOL_LENS_CONFIGS);
     }
-    async getLexPoolParams(lexPool) {
-        const result = await this.contract.getLexPoolParams(lexPool);
+    async getLexPoolParams(lexPool, callOptions) {
+        const result = await this.contract.getLexPoolParams(lexPool, { ...callOptions });
         return (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_LEX_POOL_LENS_PARAMS);
     }
-    async getLexPoolState(lexPool) {
-        const result = await this.contract.getLexPoolState(lexPool);
+    async getLexPoolState(lexPool, callOptions) {
+        const result = await this.contract.getLexPoolState(lexPool, { ...callOptions });
         return (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_LEX_POOL_LENS_STATE, {
             collateralLimitsNonCat: ILexLensService_1.EMPTY_COLLATERAL_LIMITS_FOR_ASSET,
             collateralLimitsCat: ILexLensService_1.EMPTY_COLLATERAL_LIMITS_FOR_ASSET,
         });
     }
-    async getLexPoolSupplierState(lexPool, supplier) {
-        const result = await this.contract.getLexPoolSupplierState(lexPool, supplier);
+    async getLexPoolSupplierState(lexPool, supplier, callOptions) {
+        const result = await this.contract.getLexPoolSupplierState(lexPool, supplier, { ...callOptions });
         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);
+    async getLexPoolsStateAll(lexPools, callOptions) {
+        const results = await this.contract.getLexPoolsStateAll(lexPools, { ...callOptions });
         return (0, ethersTypes_1.ethersStructResponseToArray)(results, ILexLensService_1.EMPTY_LEX_POOL_LENS_STATE, {
             collateralLimitsNonCat: ILexLensService_1.EMPTY_COLLATERAL_LIMITS_FOR_ASSET,
             collateralLimitsCat: ILexLensService_1.EMPTY_COLLATERAL_LIMITS_FOR_ASSET,
         });
     }
-    async getPoolAccountantConfigurationsByPool(lexPool) {
-        const result = await this.contract.getPoolAccountantConfigurationsByPool(lexPool);
+    async getPoolAccountantConfigurationsByPool(lexPool, callOptions) {
+        const result = await this.contract.getPoolAccountantConfigurationsByPool(lexPool, { ...callOptions });
         return (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_POOL_ACCOUNTANT_CONFIGURATIONS_LENS);
     }
-    async getPoolAccountantConfigurationsByPoolAll(lexPools) {
-        const results = await this.contract.getPoolAccountantConfigurationsByPoolAll(lexPools);
+    async getPoolAccountantConfigurationsByPoolAll(lexPools, callOptions) {
+        const results = await this.contract.getPoolAccountantConfigurationsByPoolAll(lexPools, { ...callOptions });
         return (0, ethersTypes_1.ethersStructResponseToArray)(results, ILexLensService_1.EMPTY_POOL_ACCOUNTANT_CONFIGURATIONS_LENS);
     }
-    async getPoolAccountantForLexPool(lexPool) {
-        return await this.contract.getPoolAccountantForLexPool(lexPool);
+    async getPoolAccountantForLexPool(lexPool, callOptions) {
+        return await this.contract.getPoolAccountantForLexPool(lexPool, { ...callOptions });
     }
-    async getPoolAccountantStateByPool(lexPool) {
-        const result = await this.contract.getPoolAccountantStateByPool(lexPool);
+    async getPoolAccountantStateByPool(lexPool, callOptions) {
+        const result = await this.contract.getPoolAccountantStateByPool(lexPool, { ...callOptions });
         return (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_POOL_ACCOUNTANT_STATE_LENS);
     }
-    async getPoolAccountantStateByPoolAll(lexPools) {
-        const results = await this.contract.getPoolAccountantStateByPoolAll(lexPools);
+    async getPoolAccountantStateByPoolAll(lexPools, callOptions) {
+        const results = await this.contract.getPoolAccountantStateByPoolAll(lexPools, { ...callOptions });
         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);
+    async getSupplierCurrentStateAll(lexPools, supplier, callOptions) {
+        const results = await this.contract.getSupplierCurrentStateAll(lexPools, supplier, { ...callOptions });
         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) {
+    async tradesValuesMultiplePairs(accountant, pairsTrades, callOptions) {
         // @ts-ignore
-        const results = await this.contract.tradesValuesMultiplePairs.staticCall(accountant, pairsTrades);
+        const results = await this.contract.tradesValuesMultiplePairs.staticCall(accountant, pairsTrades, { ...callOptions });
         return results.map(pairResults => (0, ethersTypes_1.ethersStructResponseToArray)(pairResults, ILexLensService_1.EMPTY_SINGLE_POSITION_OUTPUT));
     }
-    async tradesValuesSinglePair(accountant, pairParams) {
+    async tradesValuesSinglePair(accountant, pairParams, callOptions) {
         // @ts-ignore
-        const results = await this.contract.tradesValuesSinglePair.staticCall(accountant, pairParams);
+        const results = await this.contract.tradesValuesSinglePair.staticCall(accountant, pairParams, { ...callOptions });
         return (0, ethersTypes_1.ethersStructResponseToArray)(results, ILexLensService_1.EMPTY_SINGLE_POSITION_OUTPUT);
     }
     // Helper methods

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

@@ -6,46 +6,46 @@ class LexPoolV1FunctionsGroup_Initialization {
     constructor(contract) {
         this.contract = contract;
     }
-    async _become(proxy) {
-        return this.contract._become(proxy);
+    async _become(proxy, transactionOptions) {
+        return this.contract._become(proxy, { ...transactionOptions });
     }
-    async initialize(underlying, tradingFloor, epochDuration) {
-        return this.contract.initialize(underlying, tradingFloor, epochDuration);
+    async initialize(underlying, tradingFloor, epochDuration, transactionOptions) {
+        return this.contract.initialize(underlying, tradingFloor, epochDuration, { ...transactionOptions });
     }
 }
 class LexPoolV1FunctionsGroup_AdminConfiguration {
     constructor(contract) {
         this.contract = contract;
     }
-    async setPoolAccountant(poolAccountant) {
-        return this.contract.setPoolAccountant(poolAccountant);
+    async setPoolAccountant(poolAccountant, transactionOptions) {
+        return this.contract.setPoolAccountant(poolAccountant, { ...transactionOptions });
     }
-    async setPnlRole(pnl) {
-        return this.contract.setPnlRole(pnl);
+    async setPnlRole(pnl, transactionOptions) {
+        return this.contract.setPnlRole(pnl, { ...transactionOptions });
     }
-    async setMaxExtraWithdrawalAmountF(maxExtra) {
-        return this.contract.setMaxExtraWithdrawalAmountF(maxExtra);
+    async setMaxExtraWithdrawalAmountF(maxExtra, transactionOptions) {
+        return this.contract.setMaxExtraWithdrawalAmountF(maxExtra, { ...transactionOptions });
     }
-    async setEpochsDelayDeposit(delay) {
-        return this.contract.setEpochsDelayDeposit(delay);
+    async setEpochsDelayDeposit(delay, transactionOptions) {
+        return this.contract.setEpochsDelayDeposit(delay, { ...transactionOptions });
     }
-    async setEpochsDelayRedeem(delay) {
-        return this.contract.setEpochsDelayRedeem(delay);
+    async setEpochsDelayRedeem(delay, transactionOptions) {
+        return this.contract.setEpochsDelayRedeem(delay, { ...transactionOptions });
     }
-    async setEpochDuration(duration) {
-        return this.contract.setEpochDuration(duration);
+    async setEpochDuration(duration, transactionOptions) {
+        return this.contract.setEpochDuration(duration, { ...transactionOptions });
     }
-    async setMinDepositAmount(amount) {
-        return this.contract.setMinDepositAmount(amount);
+    async setMinDepositAmount(amount, transactionOptions) {
+        return this.contract.setMinDepositAmount(amount, { ...transactionOptions });
     }
-    async toggleImmediateDepositAllowed() {
-        return this.contract.toggleImmediateDepositAllowed();
+    async toggleImmediateDepositAllowed(transactionOptions) {
+        return this.contract.toggleImmediateDepositAllowed({ ...transactionOptions });
     }
-    async reduceReserves(to) {
-        return this.contract.reduceReserves(to);
+    async reduceReserves(to, transactionOptions) {
+        return this.contract.reduceReserves(to, { ...transactionOptions });
     }
-    async reduceReserves_static(to) {
-        const result = await this.contract.reduceReserves.staticCall(to);
+    async reduceReserves_static(to, callOptions) {
+        const result = await this.contract.reduceReserves.staticCall(to, { ...callOptions });
         return {
             interestShare: result[0],
             totalFundingShare: result[1],
@@ -56,36 +56,36 @@ class LexPoolV1FunctionsGroup_UserDeposits {
     constructor(contract) {
         this.contract = contract;
     }
-    async immediateDeposit(depositAmount, domain, referralCode) {
-        return this.contract.immediateDeposit(depositAmount, domain, referralCode);
+    async immediateDeposit(depositAmount, domain, referralCode, transactionOptions) {
+        return this.contract.immediateDeposit(depositAmount, domain, referralCode, { ...transactionOptions });
     }
-    async requestDeposit(amount, minAmountOut, domain, referralCode) {
-        return this.contract.requestDeposit(amount, minAmountOut, domain, referralCode);
+    async requestDeposit(amount, minAmountOut, domain, referralCode, transactionOptions) {
+        return this.contract.requestDeposit(amount, minAmountOut, domain, referralCode, { ...transactionOptions });
     }
-    async requestDepositViaIntent(user, amount, minAmountOut, domain, referralCode) {
-        return this.contract.requestDepositViaIntent(user, amount, minAmountOut, domain, referralCode);
+    async requestDepositViaIntent(user, amount, minAmountOut, domain, referralCode, transactionOptions) {
+        return this.contract.requestDepositViaIntent(user, amount, minAmountOut, domain, referralCode, { ...transactionOptions });
     }
 }
 class LexPoolV1FunctionsGroup_UserRedeems {
     constructor(contract) {
         this.contract = contract;
     }
-    async requestRedeem(amount, minAmountOut) {
-        return this.contract.requestRedeem(amount, minAmountOut);
+    async requestRedeem(amount, minAmountOut, transactionOptions) {
+        return this.contract.requestRedeem(amount, minAmountOut, { ...transactionOptions });
     }
-    async requestRedeemViaIntent(user, amount, minAmountOut) {
-        return this.contract.requestRedeemViaIntent(user, amount, minAmountOut);
+    async requestRedeemViaIntent(user, amount, minAmountOut, transactionOptions) {
+        return this.contract.requestRedeemViaIntent(user, amount, minAmountOut, { ...transactionOptions });
     }
 }
 class LexPoolV1FunctionsGroup_Processing {
     constructor(contract) {
         this.contract = contract;
     }
-    async processDeposit(users) {
-        return this.contract.processDeposit(users);
+    async processDeposit(users, transactionOptions) {
+        return this.contract.processDeposit(users, { ...transactionOptions });
     }
-    async processDeposit_static(users) {
-        const result = await this.contract.processDeposit.staticCall(users);
+    async processDeposit_static(users, callOptions) {
+        const result = await this.contract.processDeposit.staticCall(users, { ...callOptions });
         return {
             amountDeposited: result[0],
             amountCanceled: result[1],
@@ -93,11 +93,11 @@ class LexPoolV1FunctionsGroup_Processing {
             counterCanceled: result[3],
         };
     }
-    async processRedeems(users) {
-        return this.contract.processRedeems(users);
+    async processRedeems(users, transactionOptions) {
+        return this.contract.processRedeems(users, { ...transactionOptions });
     }
-    async processRedeems_static(users) {
-        const result = await this.contract.processRedeems.staticCall(users);
+    async processRedeems_static(users, callOptions) {
+        const result = await this.contract.processRedeems.staticCall(users, { ...callOptions });
         return {
             amountRedeemed: result[0],
             amountCanceled: result[1],
@@ -105,30 +105,30 @@ class LexPoolV1FunctionsGroup_Processing {
             counterCanceled: result[3],
         };
     }
-    async cancelDeposits(users, epochs) {
-        return this.contract.cancelDeposits(users, epochs);
+    async cancelDeposits(users, epochs, transactionOptions) {
+        return this.contract.cancelDeposits(users, epochs, { ...transactionOptions });
     }
-    async cancelRedeems(users, epochs) {
-        return this.contract.cancelRedeems(users, epochs);
+    async cancelRedeems(users, epochs, transactionOptions) {
+        return this.contract.cancelRedeems(users, epochs, { ...transactionOptions });
     }
 }
 class LexPoolV1FunctionsGroup_EpochManagement {
     constructor(contract) {
         this.contract = contract;
     }
-    async nextEpoch(totalUnrealizedPricePnL) {
-        return this.contract.nextEpoch(totalUnrealizedPricePnL);
+    async nextEpoch(totalUnrealizedPricePnL, transactionOptions) {
+        return this.contract.nextEpoch(totalUnrealizedPricePnL, { ...transactionOptions });
     }
-    async nextEpoch_static(totalUnrealizedPricePnL) {
-        return this.contract.nextEpoch.staticCall(totalUnrealizedPricePnL);
+    async nextEpoch_static(totalUnrealizedPricePnL, callOptions) {
+        return this.contract.nextEpoch.staticCall(totalUnrealizedPricePnL, { ...callOptions });
     }
 }
 class LexPoolV1FunctionsGroup_TradingFloorInteraction {
     constructor(contract) {
         this.contract = contract;
     }
-    async sendAssetToTrader(to, amount) {
-        return this.contract.sendAssetToTrader(to, amount);
+    async sendAssetToTrader(to, amount, transactionOptions) {
+        return this.contract.sendAssetToTrader(to, amount, { ...transactionOptions });
     }
 }
 class LexPoolV1Service {
@@ -154,48 +154,48 @@ class LexPoolV1Service {
     }
     createViewFunctionsGroup() {
         return {
-            calcNextEpochStartMin: () => this.lexPoolContract.calcNextEpochStartMin(),
-            currentBalanceInternal: () => this.lexPoolContract.currentBalanceInternal(),
-            underlyingBalanceForExchangeRate: () => this.lexPoolContract.underlyingBalanceForExchangeRate(),
-            virtualBalanceForUtilization: (extraAmount, unrealizedFunding) => this.lexPoolContract["virtualBalanceForUtilization(uint256,int256)"](extraAmount, unrealizedFunding),
-            virtualBalanceForUtilizationCurrent: () => this.lexPoolContract["virtualBalanceForUtilization()"](),
-            currentVirtualUtilization: (totalBorrows, interestShare, unrealizedFunding) => this.lexPoolContract["currentVirtualUtilization(uint256,uint256,int256)"](totalBorrows, interestShare, unrealizedFunding),
-            currentVirtualUtilizationSimple: () => this.lexPoolContract["currentVirtualUtilization()"](),
-            isUtilizationForLPsValid: () => this.lexPoolContract.isUtilizationForLPsValid(),
-            underlyingAmountToOwnAmount: (underlyingAmount) => this.lexPoolContract.underlyingAmountToOwnAmount(underlyingAmount),
-            getDepositorsCount: (epoch) => this.lexPoolContract.getDepositorsCount(epoch),
-            getRedeemersCount: (epoch) => this.lexPoolContract.getRedeemersCount(epoch),
-            getDepositors: (epoch, indexFrom, count) => this.lexPoolContract.getDepositors(epoch, indexFrom, count),
-            getRedeemers: (epoch, indexFrom, count) => this.lexPoolContract.getRedeemers(epoch, indexFrom, count),
+            calcNextEpochStartMin: (callOptions) => this.lexPoolContract.calcNextEpochStartMin({ ...callOptions }),
+            currentBalanceInternal: (callOptions) => this.lexPoolContract.currentBalanceInternal({ ...callOptions }),
+            underlyingBalanceForExchangeRate: (callOptions) => this.lexPoolContract.underlyingBalanceForExchangeRate({ ...callOptions }),
+            virtualBalanceForUtilization: (extraAmount, unrealizedFunding, callOptions) => this.lexPoolContract["virtualBalanceForUtilization(uint256,int256)"](extraAmount, unrealizedFunding, { ...callOptions }),
+            virtualBalanceForUtilizationCurrent: (callOptions) => this.lexPoolContract["virtualBalanceForUtilization()"]({ ...callOptions }),
+            currentVirtualUtilization: (totalBorrows, interestShare, unrealizedFunding, callOptions) => this.lexPoolContract["currentVirtualUtilization(uint256,uint256,int256)"](totalBorrows, interestShare, unrealizedFunding, { ...callOptions }),
+            currentVirtualUtilizationSimple: (callOptions) => this.lexPoolContract["currentVirtualUtilization()"]({ ...callOptions }),
+            isUtilizationForLPsValid: (callOptions) => this.lexPoolContract.isUtilizationForLPsValid({ ...callOptions }),
+            underlyingAmountToOwnAmount: (underlyingAmount, callOptions) => this.lexPoolContract.underlyingAmountToOwnAmount(underlyingAmount, { ...callOptions }),
+            getDepositorsCount: (epoch, callOptions) => this.lexPoolContract.getDepositorsCount(epoch, { ...callOptions }),
+            getRedeemersCount: (epoch, callOptions) => this.lexPoolContract.getRedeemersCount(epoch, { ...callOptions }),
+            getDepositors: (epoch, indexFrom, count, callOptions) => this.lexPoolContract.getDepositors(epoch, indexFrom, count, { ...callOptions }),
+            getRedeemers: (epoch, indexFrom, count, callOptions) => this.lexPoolContract.getRedeemers(epoch, indexFrom, count, { ...callOptions }),
         };
     }
     createStateVariablesGroup() {
         return {
             // Configuration
-            underlyingDecimals: () => this.lexPoolContract.underlyingDecimals(),
-            epochDuration: () => this.lexPoolContract.epochDuration(),
-            epochsDelayDeposit: () => this.lexPoolContract.epochsDelayDeposit(),
-            epochsDelayRedeem: () => this.lexPoolContract.epochsDelayRedeem(),
-            minDepositAmount: () => this.lexPoolContract.minDepositAmount(),
-            maxExtraWithdrawalAmountF: () => this.lexPoolContract.maxExtraWithdrawalAmountF(),
-            immediateDepositAllowed: () => this.lexPoolContract.immediateDepositAllowed(),
+            underlyingDecimals: (callOptions) => this.lexPoolContract.underlyingDecimals({ ...callOptions }),
+            epochDuration: (callOptions) => this.lexPoolContract.epochDuration({ ...callOptions }),
+            epochsDelayDeposit: (callOptions) => this.lexPoolContract.epochsDelayDeposit({ ...callOptions }),
+            epochsDelayRedeem: (callOptions) => this.lexPoolContract.epochsDelayRedeem({ ...callOptions }),
+            minDepositAmount: (callOptions) => this.lexPoolContract.minDepositAmount({ ...callOptions }),
+            maxExtraWithdrawalAmountF: (callOptions) => this.lexPoolContract.maxExtraWithdrawalAmountF({ ...callOptions }),
+            immediateDepositAllowed: (callOptions) => this.lexPoolContract.immediateDepositAllowed({ ...callOptions }),
             // Epoch state
-            currentEpoch: () => this.lexPoolContract.currentEpoch(),
-            nextEpochStartMin: () => this.lexPoolContract.nextEpochStartMin(),
-            currentExchangeRate: () => this.lexPoolContract.currentExchangeRate(),
+            currentEpoch: (callOptions) => this.lexPoolContract.currentEpoch({ ...callOptions }),
+            nextEpochStartMin: (callOptions) => this.lexPoolContract.nextEpochStartMin({ ...callOptions }),
+            currentExchangeRate: (callOptions) => this.lexPoolContract.currentExchangeRate({ ...callOptions }),
             // Pending amounts
-            pendingDepositAmount: () => this.lexPoolContract.pendingDepositAmount(),
-            pendingWithdrawalAmount: () => this.lexPoolContract.pendingWithdrawalAmount(),
+            pendingDepositAmount: (callOptions) => this.lexPoolContract.pendingDepositAmount({ ...callOptions }),
+            pendingWithdrawalAmount: (callOptions) => this.lexPoolContract.pendingWithdrawalAmount({ ...callOptions }),
             // Pending user requests (mappings)
-            pendingDeposits: async (epoch, user) => {
-                const result = await this.lexPoolContract.pendingDeposits(epoch, user);
+            pendingDeposits: async (epoch, user, callOptions) => {
+                const result = await this.lexPoolContract.pendingDeposits(epoch, user, { ...callOptions });
                 return {
                     amount: result[0],
                     minAmountOut: result[1],
                 };
             },
-            pendingRedeems: async (epoch, user) => {
-                const result = await this.lexPoolContract.pendingRedeems(epoch, user);
+            pendingRedeems: async (epoch, user, callOptions) => {
+                const result = await this.lexPoolContract.pendingRedeems(epoch, user, { ...callOptions });
                 return {
                     amount: result[0],
                     minAmountOut: result[1],
@@ -203,40 +203,40 @@ class LexPoolV1Service {
                 };
             },
             // Contract references
-            poolAccountant: () => this.lexPoolContract.poolAccountant(),
-            pnlRole: () => this.lexPoolContract.pnlRole(),
-            underlying: () => this.lexPoolContract.underlying(),
-            registry: () => this.lexPoolContract.registry(),
-            tradingFloor: () => this.lexPoolContract.tradingFloor(),
+            poolAccountant: (callOptions) => this.lexPoolContract.poolAccountant({ ...callOptions }),
+            pnlRole: (callOptions) => this.lexPoolContract.pnlRole({ ...callOptions }),
+            underlying: (callOptions) => this.lexPoolContract.underlying({ ...callOptions }),
+            registry: (callOptions) => this.lexPoolContract.registry({ ...callOptions }),
+            tradingFloor: (callOptions) => this.lexPoolContract.tradingFloor({ ...callOptions }),
         };
     }
     createERC20Group() {
         return {
-            name: () => this.lexPoolContract.name(),
-            symbol: () => this.lexPoolContract.symbol(),
-            decimals: () => this.lexPoolContract.decimals(),
-            totalSupply: () => this.lexPoolContract.totalSupply(),
-            balanceOf: (account) => this.lexPoolContract.balanceOf(account),
-            allowance: (owner, spender) => this.lexPoolContract.allowance(owner, spender),
-            transfer: (to, amount) => this.lexPoolContract.transfer(to, amount),
-            transferFrom: (from, to, amount) => this.lexPoolContract.transferFrom(from, to, amount),
-            approve: (spender, amount) => this.lexPoolContract.approve(spender, amount),
+            name: (callOptions) => this.lexPoolContract.name({ ...callOptions }),
+            symbol: (callOptions) => this.lexPoolContract.symbol({ ...callOptions }),
+            decimals: (callOptions) => this.lexPoolContract.decimals({ ...callOptions }),
+            totalSupply: (callOptions) => this.lexPoolContract.totalSupply({ ...callOptions }),
+            balanceOf: (account, callOptions) => this.lexPoolContract.balanceOf(account, { ...callOptions }),
+            allowance: (owner, spender, callOptions) => this.lexPoolContract.allowance(owner, spender, { ...callOptions }),
+            transfer: (to, amount, transactionOptions) => this.lexPoolContract.transfer(to, amount, { ...transactionOptions }),
+            transferFrom: (from, to, amount, transactionOptions) => this.lexPoolContract.transferFrom(from, to, amount, { ...transactionOptions }),
+            approve: (spender, amount, transactionOptions) => this.lexPoolContract.approve(spender, amount, { ...transactionOptions }),
         };
     }
     createConstantsGroup() {
         return {
-            SELF_UNIT_SCALE: () => this.lexPoolContract.SELF_UNIT_SCALE(),
-            PRECISION: () => this.lexPoolContract.PRECISION(),
-            FRACTION_SCALE: () => this.lexPoolContract.FRACTION_SCALE(),
-            LEVERAGE_SCALE: () => this.lexPoolContract.LEVERAGE_SCALE(),
+            SELF_UNIT_SCALE: (callOptions) => this.lexPoolContract.SELF_UNIT_SCALE({ ...callOptions }),
+            PRECISION: (callOptions) => this.lexPoolContract.PRECISION({ ...callOptions }),
+            FRACTION_SCALE: (callOptions) => this.lexPoolContract.FRACTION_SCALE({ ...callOptions }),
+            LEVERAGE_SCALE: (callOptions) => this.lexPoolContract.LEVERAGE_SCALE({ ...callOptions }),
         };
     }
     createContractInfoGroup() {
         return {
-            admin: () => this.lexPoolContract.admin(),
-            pendingAdmin: () => this.lexPoolContract.pendingAdmin(),
-            implementation: () => this.lexPoolContract.implementation(),
-            pendingImplementation: () => this.lexPoolContract.pendingImplementation(),
+            admin: (callOptions) => this.lexPoolContract.admin({ ...callOptions }),
+            pendingAdmin: (callOptions) => this.lexPoolContract.pendingAdmin({ ...callOptions }),
+            implementation: (callOptions) => this.lexPoolContract.implementation({ ...callOptions }),
+            pendingImplementation: (callOptions) => this.lexPoolContract.pendingImplementation({ ...callOptions }),
         };
     }
 }