lynx-client 0.0.32 → 0.0.34

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

@@ -8,38 +8,38 @@ class PoolAccountantV1FunctionsGroup_TradeUtilities {
     constructor(contract) {
         this.contract = contract;
     }
-    async adjustClosePrice(closePrice, tp, long) {
-        return this.contract.adjustClosePrice(closePrice, tp, long);
+    async adjustClosePrice(closePrice, tp, long, callOptions) {
+        return this.contract.adjustClosePrice(closePrice, tp, long, { ...callOptions });
     }
-    async generatePositionHashId(settlementAsset, trader, pairId, index) {
-        return this.contract.generatePositionHashId(settlementAsset, trader, pairId, index);
+    async generatePositionHashId(settlementAsset, trader, pairId, index, callOptions) {
+        return this.contract.generatePositionHashId(settlementAsset, trader, pairId, index, { ...callOptions });
     }
 }
 class PoolAccountantV1FunctionsGroup_FeeCalculations {
     constructor(contract) {
         this.contract = contract;
     }
-    async calcClosingFee(pairId, collateral, leverage) {
-        return this.contract.calcClosingFee(pairId, collateral, leverage);
+    async calcClosingFee(pairId, collateral, leverage, callOptions) {
+        return this.contract.calcClosingFee(pairId, collateral, leverage, { ...callOptions });
     }
-    async calcPerformanceFee(pairId, collateral, profitPrecision) {
-        return this.contract.calcPerformanceFee(pairId, collateral, profitPrecision);
+    async calcPerformanceFee(pairId, collateral, profitPrecision, callOptions) {
+        return this.contract.calcPerformanceFee(pairId, collateral, profitPrecision, { ...callOptions });
     }
-    async calcTradeDynamicFees(positionId, pairId, long, collateral, leverage, openPrice, tp) {
-        const result = await this.contract.calcTradeDynamicFees.staticCall(positionId, pairId, long, collateral, leverage, openPrice, tp);
+    async calcTradeDynamicFees(positionId, pairId, long, collateral, leverage, openPrice, tp, callOptions) {
+        const result = await this.contract.calcTradeDynamicFees.staticCall(positionId, pairId, long, collateral, leverage, openPrice, tp, { ...callOptions });
         return {
             interest: result.interest,
             funding: result.funding,
         };
     }
-    async calcBorrowAmount(collateral, leverage, long, openPrice, tp) {
-        return this.contract.calcBorrowAmount(collateral, leverage, long, openPrice, tp);
+    async calcBorrowAmount(collateral, leverage, long, openPrice, tp, callOptions) {
+        return this.contract.calcBorrowAmount(collateral, leverage, long, openPrice, tp, { ...callOptions });
     }
-    async calcAbsoluteSkew(openInterestLong, openInterestShort, additionIsLong, additionOpenInterest) {
-        return this.contract.calcAbsoluteSkew(openInterestLong, openInterestShort, additionIsLong, additionOpenInterest);
+    async calcAbsoluteSkew(openInterestLong, openInterestShort, additionIsLong, additionOpenInterest, callOptions) {
+        return this.contract.calcAbsoluteSkew(openInterestLong, openInterestShort, additionIsLong, additionOpenInterest, { ...callOptions });
     }
-    async calcAccrueFundingValues(pairId) {
-        const result = await this.contract.calcAccrueFundingValues(pairId);
+    async calcAccrueFundingValues(pairId, callOptions) {
+        const result = await this.contract.calcAccrueFundingValues(pairId, { ...callOptions });
         return {
             freshened: result.freshened,
             valueLong: result.valueLong,
@@ -73,73 +73,73 @@ class PoolAccountantV1Service {
     }
     createVerificationGroup() {
         return {
-            verifyLeveragedPosition: async (pairIndex, collateral, leverage) => {
-                const result = await this.poolAccountantContract.verifyLeveragedPosition(pairIndex, collateral, leverage);
+            verifyLeveragedPosition: async (pairIndex, collateral, leverage, callOptions) => {
+                const result = await this.poolAccountantContract.verifyLeveragedPosition(pairIndex, collateral, leverage, { ...callOptions });
                 return result;
             },
-            verifyOpenFee: async (pairIndex, leveragedPosition) => {
-                const result = await this.poolAccountantContract.verifyOpenFee(pairIndex, leveragedPosition);
+            verifyOpenFee: async (pairIndex, leveragedPosition, callOptions) => {
+                const result = await this.poolAccountantContract.verifyOpenFee(pairIndex, leveragedPosition, { ...callOptions });
                 return {
                     openFee: result[0],
                     lexPartFee: result[1],
                 };
             },
-            verifyPerformanceFee: (pairIndex, collateral) => this.poolAccountantContract.verifyPerformanceFee(pairIndex, collateral),
-            verifyMaxPercentProfit: (openPrice, targetPrice, leverage, long) => this.poolAccountantContract.verifyMaxPercentProfit(openPrice, targetPrice, leverage, long),
-            verifyUtilizationForTraders: (totalBorrows, totalReserves, unrealizedFunding) => this.poolAccountantContract.verifyUtilizationForTraders(totalBorrows, totalReserves, unrealizedFunding),
+            verifyPerformanceFee: (pairIndex, collateral, callOptions) => this.poolAccountantContract.verifyPerformanceFee(pairIndex, collateral, { ...callOptions }),
+            verifyMaxPercentProfit: (openPrice, targetPrice, leverage, long, callOptions) => this.poolAccountantContract.verifyMaxPercentProfit(openPrice, targetPrice, leverage, long, { ...callOptions }),
+            verifyUtilizationForTraders: (totalBorrows, totalReserves, unrealizedFunding, callOptions) => this.poolAccountantContract.verifyUtilizationForTraders(totalBorrows, totalReserves, unrealizedFunding, { ...callOptions }),
         };
     }
     createFundingGroup() {
         return {
-            accrueFunding: async (pairId) => {
-                const tx = await this.poolAccountantContract.accrueFunding(pairId);
+            accrueFunding: async (pairId, transactionOptions) => {
+                const tx = await this.poolAccountantContract.accrueFunding(pairId, { ...transactionOptions });
                 const receipt = await tx.wait();
                 // Return transaction receipt - developers can parse events if needed
                 return receipt;
             },
-            accrueFunding_static: async (pairId) => {
-                const result = await this.poolAccountantContract.accrueFunding.staticCall(pairId);
+            accrueFunding_static: async (pairId, callOptions) => {
+                const result = await this.poolAccountantContract.accrueFunding.staticCall(pairId, { ...callOptions });
                 return {
                     valueLong: result[0],
                     valueShort: result[1],
                     protocolFundingShare: result[2],
                 };
             },
-            calcAccrueFundingValues: (pairId) => this.poolAccountantContract
-                .calcAccrueFundingValues(pairId)
+            calcAccrueFundingValues: (pairId, callOptions) => this.poolAccountantContract
+                .calcAccrueFundingValues(pairId, { ...callOptions })
                 .then((r) => ({
                 freshened: r.freshened,
                 valueLong: r.valueLong,
                 valueShort: r.valueShort,
                 protocolFundingShare: r.protocolFundingShare,
             })),
-            fundingIndicesCalculation: (oiLong, oiShort, fundingRate, timeDiff) => this.poolAccountantContract
-                .fundingIndicesCalculation(oiLong, oiShort, fundingRate, timeDiff)
+            fundingIndicesCalculation: (oiLong, oiShort, fundingRate, timeDiff, callOptions) => this.poolAccountantContract
+                .fundingIndicesCalculation(oiLong, oiShort, fundingRate, timeDiff, { ...callOptions })
                 .then((r) => ({
                 indexLongChange: r.indexLongChange,
                 indexShortChange: r.indexShortChange,
                 protocolFundingShare: r.protocolFundingShare,
             })),
-            getTradeFunding: async (positionId, pairId, long, collateral, leverage) => {
-                const tx = await this.poolAccountantContract.getTradeFunding(positionId, pairId, long, collateral, leverage);
+            getTradeFunding: async (positionId, pairId, long, collateral, leverage, transactionOptions) => {
+                const tx = await this.poolAccountantContract.getTradeFunding(positionId, pairId, long, collateral, leverage, { ...transactionOptions });
                 const receipt = await tx.wait();
                 return receipt;
             },
-            getTradeFunding_static: (positionId, pairId, long, collateral, leverage) => this.poolAccountantContract.getTradeFunding.staticCall(positionId, pairId, long, collateral, leverage),
-            getTradeFundingPure: (accFundingPerOi, endAccFundingPerOi, collateral, leverage) => this.poolAccountantContract.getTradeFundingPure(accFundingPerOi, endAccFundingPerOi, collateral, leverage),
-            getTradeInitialAccFundingPerOi: (positionId) => this.poolAccountantContract.getTradeInitialAccFundingPerOi(positionId),
-            getAccFundingLong: (pairIndex) => this.poolAccountantContract.getAccFundingLong(pairIndex),
-            getAccFundingShort: (pairIndex) => this.poolAccountantContract.getAccFundingShort(pairIndex),
-            getAccFundingUpdateBlock: (pairIndex) => this.poolAccountantContract.getAccFundingUpdateBlock(pairIndex),
+            getTradeFunding_static: (positionId, pairId, long, collateral, leverage, callOptions) => this.poolAccountantContract.getTradeFunding.staticCall(positionId, pairId, long, collateral, leverage, { ...callOptions }),
+            getTradeFundingPure: (accFundingPerOi, endAccFundingPerOi, collateral, leverage, callOptions) => this.poolAccountantContract.getTradeFundingPure(accFundingPerOi, endAccFundingPerOi, collateral, leverage, { ...callOptions }),
+            getTradeInitialAccFundingPerOi: (positionId, callOptions) => this.poolAccountantContract.getTradeInitialAccFundingPerOi(positionId, { ...callOptions }),
+            getAccFundingLong: (pairIndex, callOptions) => this.poolAccountantContract.getAccFundingLong(pairIndex, { ...callOptions }),
+            getAccFundingShort: (pairIndex, callOptions) => this.poolAccountantContract.getAccFundingShort(pairIndex, { ...callOptions }),
+            getAccFundingUpdateBlock: (pairIndex, callOptions) => this.poolAccountantContract.getAccFundingUpdateBlock(pairIndex, { ...callOptions }),
         };
     }
     createInterestGroup() {
         return {
-            getTradeInterest: (positionId, borrowAmount) => this.poolAccountantContract.getTradeInterest.staticCall(positionId, borrowAmount),
-            getTradeInterestPure: (tradeAccInterest, borrowsAndInterestShare, borrowIndex, accBorrowIndex) => this.poolAccountantContract.getTradeInterestPure(tradeAccInterest, borrowsAndInterestShare, borrowIndex, accBorrowIndex),
-            getTradeInitialAccBorrowIndex: (positionId) => this.poolAccountantContract.getTradeInitialAccBorrowIndex(positionId),
-            accrueInterest: async (availableCash) => {
-                const result = await this.poolAccountantContract["accrueInterest(uint256)"].staticCall(availableCash);
+            getTradeInterest: (positionId, borrowAmount, callOptions) => this.poolAccountantContract.getTradeInterest.staticCall(positionId, borrowAmount, { ...callOptions }),
+            getTradeInterestPure: (tradeAccInterest, borrowsAndInterestShare, borrowIndex, accBorrowIndex, callOptions) => this.poolAccountantContract.getTradeInterestPure(tradeAccInterest, borrowsAndInterestShare, borrowIndex, accBorrowIndex, { ...callOptions }),
+            getTradeInitialAccBorrowIndex: (positionId, callOptions) => this.poolAccountantContract.getTradeInitialAccBorrowIndex(positionId, { ...callOptions }),
+            accrueInterest: async (availableCash, callOptions) => {
+                const result = await this.poolAccountantContract["accrueInterest(uint256)"].staticCall(availableCash, { ...callOptions });
                 return {
                     totalInterestNew: result[0],
                     interestShareNew: result[1],
@@ -150,14 +150,14 @@ class PoolAccountantV1Service {
     }
     createLiquidationGroup() {
         return {
-            getTradeLiquidationPrice: (positionId, pairId, openPrice, tp, long, collateral, leverage) => this.poolAccountantContract.getTradeLiquidationPrice.staticCall(positionId, pairId, openPrice, tp, long, collateral, leverage),
-            getTradeLiquidationPriceView: (openPrice, long, collateral, leverage, interest, funding, closingFee) => this.poolAccountantContract.getTradeLiquidationPriceView(openPrice, long, collateral, leverage, interest, funding, closingFee),
+            getTradeLiquidationPrice: (positionId, pairId, openPrice, tp, long, collateral, leverage, callOptions) => this.poolAccountantContract.getTradeLiquidationPrice.staticCall(positionId, pairId, openPrice, tp, long, collateral, leverage, { ...callOptions }),
+            getTradeLiquidationPriceView: (openPrice, long, collateral, leverage, interest, funding, closingFee, callOptions) => this.poolAccountantContract.getTradeLiquidationPriceView(openPrice, long, collateral, leverage, interest, funding, closingFee, { ...callOptions }),
         };
     }
     createTradeValuesGroup() {
         return {
-            getTradeValueView: (collateral, profitPrecision, interest, funding, closingFee, liquidation) => this.poolAccountantContract.getTradeValueView(collateral, profitPrecision, interest, funding, closingFee, liquidation),
-            getTradeClosingValues: async (positionId, pairId, collateral, leverage, long, openPrice, tp, closePrice, isLiquidation) => {
+            getTradeValueView: (collateral, profitPrecision, interest, funding, closingFee, liquidation, callOptions) => this.poolAccountantContract.getTradeValueView(collateral, profitPrecision, interest, funding, closingFee, liquidation, { ...callOptions }),
+            getTradeClosingValues: async (positionId, pairId, collateral, leverage, long, openPrice, tp, closePrice, isLiquidation, callOptions) => {
                 const params = {
                     collateral,
                     leverage,
@@ -165,7 +165,7 @@ class PoolAccountantV1Service {
                     openPrice,
                     tp,
                 };
-                const result = await this.poolAccountantContract.getTradeClosingValues.staticCall(positionId, pairId, params, closePrice, isLiquidation);
+                const result = await this.poolAccountantContract.getTradeClosingValues.staticCall(positionId, pairId, params, closePrice, isLiquidation, { ...callOptions });
                 return {
                     tradeValue: result[0],
                     safeClosingFee: result[1],
@@ -178,43 +178,43 @@ class PoolAccountantV1Service {
     }
     createPairManagementGroup() {
         return {
-            pairTotalOpenInterest: (pairIndex) => this.poolAccountantContract.pairTotalOpenInterest(pairIndex),
-            calcAbsoluteSkew: (openInterestLong, openInterestShort, additionIsLong, additionOpenInterest) => this.poolAccountantContract.calcAbsoluteSkew(openInterestLong, openInterestShort, additionIsLong, additionOpenInterest),
-            pricePnL: (pairId, price) => this.poolAccountantContract.pricePnL(pairId, price),
-            pairBorrows: (pairIndex) => this.poolAccountantContract.pairBorrows(pairIndex),
-            pairMaxBorrow: (pairIndex) => this.poolAccountantContract.pairMaxBorrow(pairIndex),
-            pairMinOpenFee: (pairIndex) => this.poolAccountantContract.pairMinOpenFee(pairIndex),
-            pairOpenFeeF: (pairIndex) => this.poolAccountantContract.pairOpenFeeF(pairIndex),
-            pairCloseFeeF: (pairIndex) => this.poolAccountantContract.pairCloseFeeF(pairIndex),
-            pairPerformanceFeeF: (pairIndex) => this.poolAccountantContract.pairPerformanceFeeF(pairIndex),
-            pairTotalRatioOiToP: (pairIndex) => this.poolAccountantContract.pairTotalRatioOiToP(pairIndex),
-            groupBorrows: (groupIndex) => this.poolAccountantContract.groupBorrows(groupIndex),
-            groupMaxBorrow: (groupIndex) => this.poolAccountantContract.groupMaxBorrow(groupIndex),
+            pairTotalOpenInterest: (pairIndex, callOptions) => this.poolAccountantContract.pairTotalOpenInterest(pairIndex, { ...callOptions }),
+            calcAbsoluteSkew: (openInterestLong, openInterestShort, additionIsLong, additionOpenInterest, callOptions) => this.poolAccountantContract.calcAbsoluteSkew(openInterestLong, openInterestShort, additionIsLong, additionOpenInterest, { ...callOptions }),
+            pricePnL: (pairId, price, callOptions) => this.poolAccountantContract.pricePnL(pairId, price, { ...callOptions }),
+            pairBorrows: (pairIndex, callOptions) => this.poolAccountantContract.pairBorrows(pairIndex, { ...callOptions }),
+            pairMaxBorrow: (pairIndex, callOptions) => this.poolAccountantContract.pairMaxBorrow(pairIndex, { ...callOptions }),
+            pairMinOpenFee: (pairIndex, callOptions) => this.poolAccountantContract.pairMinOpenFee(pairIndex, { ...callOptions }),
+            pairOpenFeeF: (pairIndex, callOptions) => this.poolAccountantContract.pairOpenFeeF(pairIndex, { ...callOptions }),
+            pairCloseFeeF: (pairIndex, callOptions) => this.poolAccountantContract.pairCloseFeeF(pairIndex, { ...callOptions }),
+            pairPerformanceFeeF: (pairIndex, callOptions) => this.poolAccountantContract.pairPerformanceFeeF(pairIndex, { ...callOptions }),
+            pairTotalRatioOiToP: (pairIndex, callOptions) => this.poolAccountantContract.pairTotalRatioOiToP(pairIndex, { ...callOptions }),
+            groupBorrows: (groupIndex, callOptions) => this.poolAccountantContract.groupBorrows(groupIndex, { ...callOptions }),
+            groupMaxBorrow: (groupIndex, callOptions) => this.poolAccountantContract.groupMaxBorrow(groupIndex, { ...callOptions }),
         };
     }
     createAdminConfigurationGroup() {
         return {
-            setTradeIncentivizer: (incentivizer) => this.poolAccountantContract.setTradeIncentivizer(incentivizer),
-            setMaxGainF: (maxGainF) => this.poolAccountantContract.setMaxGainF(maxGainF),
-            setFrm: (frm) => this.poolAccountantContract.setFrm(frm),
-            setMinOpenFee: (min) => this.poolAccountantContract.setMinOpenFee(min),
-            setLexPartF: (partF) => this.poolAccountantContract.setLexPartF(partF),
-            setFundingRateMax: (maxValue) => this.poolAccountantContract.setFundingRateMax(maxValue),
-            setLiquidationThresholdF: (threshold) => this.poolAccountantContract.setLiquidationThresholdF(threshold),
-            setLiquidationFeeF: (fee) => this.poolAccountantContract.setLiquidationFeeF(fee),
-            setIrm: (irm) => this.poolAccountantContract.setIrm(irm),
-            setIrmHard: (irm) => this.poolAccountantContract.setIrmHard(irm),
-            setInterestShareFactor: (factor) => this.poolAccountantContract.setInterestShareFactor(factor),
-            setFundingShareFactor: (factor) => this.poolAccountantContract.setFundingShareFactor(factor),
-            setBorrowRateMax: (rate) => this.poolAccountantContract.setBorrowRateMax(rate),
-            setMaxTotalBorrows: (maxBorrows) => this.poolAccountantContract.setMaxTotalBorrows(maxBorrows),
-            setMaxVirtualUtilization: (maxUtilization) => this.poolAccountantContract.setMaxVirtualUtilization(maxUtilization),
+            setTradeIncentivizer: (incentivizer, transactionOptions) => this.poolAccountantContract.setTradeIncentivizer(incentivizer, { ...transactionOptions }),
+            setMaxGainF: (maxGainF, transactionOptions) => this.poolAccountantContract.setMaxGainF(maxGainF, { ...transactionOptions }),
+            setFrm: (frm, transactionOptions) => this.poolAccountantContract.setFrm(frm, { ...transactionOptions }),
+            setMinOpenFee: (min, transactionOptions) => this.poolAccountantContract.setMinOpenFee(min, { ...transactionOptions }),
+            setLexPartF: (partF, transactionOptions) => this.poolAccountantContract.setLexPartF(partF, { ...transactionOptions }),
+            setFundingRateMax: (maxValue, transactionOptions) => this.poolAccountantContract.setFundingRateMax(maxValue, { ...transactionOptions }),
+            setLiquidationThresholdF: (threshold, transactionOptions) => this.poolAccountantContract.setLiquidationThresholdF(threshold, { ...transactionOptions }),
+            setLiquidationFeeF: (fee, transactionOptions) => this.poolAccountantContract.setLiquidationFeeF(fee, { ...transactionOptions }),
+            setIrm: (irm, transactionOptions) => this.poolAccountantContract.setIrm(irm, { ...transactionOptions }),
+            setIrmHard: (irm, transactionOptions) => this.poolAccountantContract.setIrmHard(irm, { ...transactionOptions }),
+            setInterestShareFactor: (factor, transactionOptions) => this.poolAccountantContract.setInterestShareFactor(factor, { ...transactionOptions }),
+            setFundingShareFactor: (factor, transactionOptions) => this.poolAccountantContract.setFundingShareFactor(factor, { ...transactionOptions }),
+            setBorrowRateMax: (rate, transactionOptions) => this.poolAccountantContract.setBorrowRateMax(rate, { ...transactionOptions }),
+            setMaxTotalBorrows: (maxBorrows, transactionOptions) => this.poolAccountantContract.setMaxTotalBorrows(maxBorrows, { ...transactionOptions }),
+            setMaxVirtualUtilization: (maxUtilization, transactionOptions) => this.poolAccountantContract.setMaxVirtualUtilization(maxUtilization, { ...transactionOptions }),
         };
     }
     createPoolInteractionGroup() {
         return {
-            readAndZeroReserves: async () => {
-                const result = await this.poolAccountantContract.readAndZeroReserves.staticCall();
+            readAndZeroReserves: async (callOptions) => {
+                const result = await this.poolAccountantContract.readAndZeroReserves.staticCall({ ...callOptions });
                 return {
                     accumulatedInterestShare: result[0],
                     accFundingShare: result[1],
@@ -225,52 +225,52 @@ class PoolAccountantV1Service {
     createStateVariablesGroup() {
         return {
             // Interest and borrowing state
-            borrowIndex: () => this.poolAccountantContract.borrowIndex(),
-            borrowRateMax: () => this.poolAccountantContract.borrowRateMax(),
-            totalBorrows: () => this.poolAccountantContract.totalBorrows(),
-            totalInterest: () => this.poolAccountantContract.totalInterest(),
-            interestShare: () => this.poolAccountantContract.interestShare(),
-            interestShareFactor: () => this.poolAccountantContract.interestShareFactor(),
+            borrowIndex: (callOptions) => this.poolAccountantContract.borrowIndex({ ...callOptions }),
+            borrowRateMax: (callOptions) => this.poolAccountantContract.borrowRateMax({ ...callOptions }),
+            totalBorrows: (callOptions) => this.poolAccountantContract.totalBorrows({ ...callOptions }),
+            totalInterest: (callOptions) => this.poolAccountantContract.totalInterest({ ...callOptions }),
+            interestShare: (callOptions) => this.poolAccountantContract.interestShare({ ...callOptions }),
+            interestShareFactor: (callOptions) => this.poolAccountantContract.interestShareFactor({ ...callOptions }),
             // Funding state
-            fundingRateMax: () => this.poolAccountantContract.fundingRateMax(),
-            fundingShare: () => this.poolAccountantContract.fundingShare(),
-            fundingShareFactor: () => this.poolAccountantContract.fundingShareFactor(),
-            unrealizedFunding: () => this.poolAccountantContract.unrealizedFunding(),
-            realizedFundingSurplusDeficit: () => this.poolAccountantContract.realizedFundingSurplusDeficit(),
+            fundingRateMax: (callOptions) => this.poolAccountantContract.fundingRateMax({ ...callOptions }),
+            fundingShare: (callOptions) => this.poolAccountantContract.fundingShare({ ...callOptions }),
+            fundingShareFactor: (callOptions) => this.poolAccountantContract.fundingShareFactor({ ...callOptions }),
+            unrealizedFunding: (callOptions) => this.poolAccountantContract.unrealizedFunding({ ...callOptions }),
+            realizedFundingSurplusDeficit: (callOptions) => this.poolAccountantContract.realizedFundingSurplusDeficit({ ...callOptions }),
             // Configuration
-            maxGainF: () => this.poolAccountantContract.maxGainF(),
-            liquidationFeeF: () => this.poolAccountantContract.liquidationFeeF(),
-            liquidationThresholdF: () => this.poolAccountantContract.liquidationThresholdF(),
-            maxTotalBorrows: () => this.poolAccountantContract.maxTotalBorrows(),
-            maxVirtualUtilization: () => this.poolAccountantContract.maxVirtualUtilization(),
-            minOpenFee: () => this.poolAccountantContract.minOpenFee(),
-            lexPartF: () => this.poolAccountantContract.lexPartF(),
+            maxGainF: (callOptions) => this.poolAccountantContract.maxGainF({ ...callOptions }),
+            liquidationFeeF: (callOptions) => this.poolAccountantContract.liquidationFeeF({ ...callOptions }),
+            liquidationThresholdF: (callOptions) => this.poolAccountantContract.liquidationThresholdF({ ...callOptions }),
+            maxTotalBorrows: (callOptions) => this.poolAccountantContract.maxTotalBorrows({ ...callOptions }),
+            maxVirtualUtilization: (callOptions) => this.poolAccountantContract.maxVirtualUtilization({ ...callOptions }),
+            minOpenFee: (callOptions) => this.poolAccountantContract.minOpenFee({ ...callOptions }),
+            lexPartF: (callOptions) => this.poolAccountantContract.lexPartF({ ...callOptions }),
             // Contract references
-            lexPool: () => this.poolAccountantContract.lexPool(),
-            tradingFloor: () => this.poolAccountantContract.tradingFloor(),
-            tradeIncentivizer: () => this.poolAccountantContract.tradeIncentivizer(),
-            frm: () => this.poolAccountantContract.frm(),
-            irm: () => this.poolAccountantContract.irm(),
-            underlying: () => this.poolAccountantContract.underlying(),
+            lexPool: (callOptions) => this.poolAccountantContract.lexPool({ ...callOptions }),
+            tradingFloor: (callOptions) => this.poolAccountantContract.tradingFloor({ ...callOptions }),
+            tradeIncentivizer: (callOptions) => this.poolAccountantContract.tradeIncentivizer({ ...callOptions }),
+            frm: (callOptions) => this.poolAccountantContract.frm({ ...callOptions }),
+            irm: (callOptions) => this.poolAccountantContract.irm({ ...callOptions }),
+            underlying: (callOptions) => this.poolAccountantContract.underlying({ ...callOptions }),
             // Timestamps
-            accrualBlockTimestamp: () => this.poolAccountantContract.accrualBlockTimestamp(),
+            accrualBlockTimestamp: (callOptions) => this.poolAccountantContract.accrualBlockTimestamp({ ...callOptions }),
         };
     }
     createContractInfoGroup() {
         return {
-            admin: () => this.poolAccountantContract.admin(),
-            pendingAdmin: () => this.poolAccountantContract.pendingAdmin(),
-            implementation: () => this.poolAccountantContract.implementation(),
-            pendingImplementation: () => this.poolAccountantContract.pendingImplementation(),
-            registry: () => this.poolAccountantContract.registry(),
+            admin: (callOptions) => this.poolAccountantContract.admin({ ...callOptions }),
+            pendingAdmin: (callOptions) => this.poolAccountantContract.pendingAdmin({ ...callOptions }),
+            implementation: (callOptions) => this.poolAccountantContract.implementation({ ...callOptions }),
+            pendingImplementation: (callOptions) => this.poolAccountantContract.pendingImplementation({ ...callOptions }),
+            registry: (callOptions) => this.poolAccountantContract.registry({ ...callOptions }),
         };
     }
     createConstantsGroup() {
         return {
-            ACCURACY_IMPROVEMENT_SCALE: () => this.poolAccountantContract.ACCURACY_IMPROVEMENT_SCALE(),
-            FRACTION_SCALE: () => this.poolAccountantContract.FRACTION_SCALE(),
-            LEVERAGE_SCALE: () => this.poolAccountantContract.LEVERAGE_SCALE(),
-            PRECISION: () => this.poolAccountantContract.PRECISION(),
+            ACCURACY_IMPROVEMENT_SCALE: (callOptions) => this.poolAccountantContract.ACCURACY_IMPROVEMENT_SCALE({ ...callOptions }),
+            FRACTION_SCALE: (callOptions) => this.poolAccountantContract.FRACTION_SCALE({ ...callOptions }),
+            LEVERAGE_SCALE: (callOptions) => this.poolAccountantContract.LEVERAGE_SCALE({ ...callOptions }),
+            PRECISION: (callOptions) => this.poolAccountantContract.PRECISION({ ...callOptions }),
         };
     }
 }

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

@@ -56,14 +56,14 @@ class RateModelLensService {
     constructor(signerOrProvider, contractAddress) {
         this.contract = RateModelLens__factory_1.RateModelLens__factory.connect(contractAddress, signerOrProvider);
     }
-    async getAccountantForLexPool(lexPool) {
-        return await this.contract.getAccountantForLexPool(lexPool);
+    async getAccountantForLexPool(lexPool, callOptions) {
+        return await this.contract.getAccountantForLexPool(lexPool, { ...callOptions });
     }
-    async getLexPoolForAccountant(accountant) {
-        return await this.contract.getLexPoolForAccountant(accountant);
+    async getLexPoolForAccountant(accountant, callOptions) {
+        return await this.contract.getLexPoolForAccountant(accountant, { ...callOptions });
     }
-    async getCompleteRateModelsInfo(lexPools) {
-        const result = await this.contract.getCompleteRateModelsInfo(lexPools);
+    async getCompleteRateModelsInfo(lexPools, callOptions) {
+        const result = await this.contract.getCompleteRateModelsInfo(lexPools, { ...callOptions });
         // Convert funding rate model groups (raw)
         const fundingRateModelGroupsRaw = (0, ethersTypes_1.ethersStructResponseToArray)(result.fundingRateModelGroups, IRateModelLensService_1.EMPTY_FUNDING_RATE_MODEL_GROUP_RAW, {
             accountantConfigs: IRateModelLensService_1.EMPTY_FRM_ACCOUNTANT_CONFIG_RAW,
@@ -100,8 +100,8 @@ class RateModelLensService {
             interestRateModelGroups,
         };
     }
-    async getFundingRateModelGroups(lexPools) {
-        const result = await this.contract.getFundingRateModelGroups(lexPools);
+    async getFundingRateModelGroups(lexPools, callOptions) {
+        const result = await this.contract.getFundingRateModelGroups(lexPools, { ...callOptions });
         // Convert array of groups with nested arrays (raw)
         const rawGroups = (0, ethersTypes_1.ethersStructResponseToArray)(result, IRateModelLensService_1.EMPTY_FUNDING_RATE_MODEL_GROUP_RAW, {
             accountantConfigs: IRateModelLensService_1.EMPTY_FRM_ACCOUNTANT_CONFIG_RAW,
@@ -121,8 +121,8 @@ class RateModelLensService {
             pairSpecificParams: group.pairSpecificParams.map(convertPairSpecificParams),
         }));
     }
-    async getInterestRateModelGroups(lexPools) {
-        const result = await this.contract.getInterestRateModelGroups(lexPools);
+    async getInterestRateModelGroups(lexPools, callOptions) {
+        const result = await this.contract.getInterestRateModelGroups(lexPools, { ...callOptions });
         // Convert to raw first
         const rawGroups = (0, ethersTypes_1.ethersStructResponseToArray)(result, IRateModelLensService_1.EMPTY_INTEREST_RATE_MODEL_GROUP_RAW, {}, {
             baseRateParams: IRateModelLensService_1.EMPTY_IRM_BASE_RATE_PARAMS_RAW,

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

@@ -7,93 +7,93 @@ class TradeIntentsVerifierService {
         this.contract = TradeIntentsVerifierV1__factory_1.TradeIntentsVerifierV1__factory.connect(address, signerOrProvider);
         this.isSigner = 'sendTransaction' in signerOrProvider;
     }
-    async domainSeparatorForAsset(settlementAsset) {
-        return await this.contract.domainSeparatorForAsset(settlementAsset);
+    async domainSeparatorForAsset(settlementAsset, callOptions) {
+        return await this.contract.domainSeparatorForAsset(settlementAsset, { ...callOptions });
     }
-    async domainSeparatorForChain(chainId) {
-        return await this.contract.domainSeparatorForChain(chainId);
+    async domainSeparatorForChain(chainId, callOptions) {
+        return await this.contract.domainSeparatorForChain(chainId, { ...callOptions });
     }
-    async intentsPermissions(user) {
-        return await this.contract.intentsPermissions(user);
+    async intentsPermissions(user, callOptions) {
+        return await this.contract.intentsPermissions(user, { ...callOptions });
     }
-    async setIntentsPermissions(oftChip, dynAddressSuffix) {
+    async setIntentsPermissions(oftChip, dynAddressSuffix, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("TradeIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.setIntentsPermissions(oftChip, dynAddressSuffix);
+        const tx = await this.contract.setIntentsPermissions(oftChip, dynAddressSuffix, { ...transactionOptions });
         await tx.wait();
     }
-    async verifyIntent_traderRequest_openNewPosition(payload, v, r, s, domain, referralCode, runCapTests, value) {
+    async verifyIntent_traderRequest_openNewPosition(payload, v, r, s, domain, referralCode, runCapTests, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("TradeIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.verifyIntent_traderRequest_openNewPosition(payload, v, r, s, domain, referralCode, runCapTests, { value: value || 0n });
+        const tx = await this.contract.verifyIntent_traderRequest_openNewPosition(payload, v, r, s, domain, referralCode, runCapTests, { value: value || 0n, ...transactionOptions });
         await tx.wait();
     }
-    async verifyIntent_traderRequest_marketClosePosition(payload, v, r, s, value) {
+    async verifyIntent_traderRequest_marketClosePosition(payload, v, r, s, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("TradeIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.verifyIntent_traderRequest_marketClosePosition(payload, v, r, s, { value: value || 0n });
+        const tx = await this.contract.verifyIntent_traderRequest_marketClosePosition(payload, v, r, s, { value: value || 0n, ...transactionOptions });
         await tx.wait();
     }
-    async verifyIntent_traderAction_updatePendingLimitPosition(payload, v, r, s, value) {
+    async verifyIntent_traderAction_updatePendingLimitPosition(payload, v, r, s, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("TradeIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.verifyIntent_traderAction_updatePendingLimitPosition(payload, v, r, s, { value: value || 0n });
+        const tx = await this.contract.verifyIntent_traderAction_updatePendingLimitPosition(payload, v, r, s, { value: value || 0n, ...transactionOptions });
         await tx.wait();
     }
-    async verifyIntent_traderAction_cancelPendingLimitPosition(payload, v, r, s, value) {
+    async verifyIntent_traderAction_cancelPendingLimitPosition(payload, v, r, s, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("TradeIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.verifyIntent_traderAction_cancelPendingLimitPosition(payload, v, r, s, { value: value || 0n });
+        const tx = await this.contract.verifyIntent_traderAction_cancelPendingLimitPosition(payload, v, r, s, { value: value || 0n, ...transactionOptions });
         await tx.wait();
     }
-    async verifyIntent_traderRequest_updatePositionSingleField(payload, v, r, s, value) {
+    async verifyIntent_traderRequest_updatePositionSingleField(payload, v, r, s, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("TradeIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.verifyIntent_traderRequest_updatePositionSingleField(payload, v, r, s, { value: value || 0n });
+        const tx = await this.contract.verifyIntent_traderRequest_updatePositionSingleField(payload, v, r, s, { value: value || 0n, ...transactionOptions });
         await tx.wait();
     }
-    async verifyIntent_traderRequest_updatePositionDoubleField(payload, v, r, s, value) {
+    async verifyIntent_traderRequest_updatePositionDoubleField(payload, v, r, s, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("TradeIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.verifyIntent_traderRequest_updatePositionDoubleField(payload, v, r, s, { value: value || 0n });
+        const tx = await this.contract.verifyIntent_traderRequest_updatePositionDoubleField(payload, v, r, s, { value: value || 0n, ...transactionOptions });
         await tx.wait();
     }
-    async admin() {
-        return await this.contract.admin();
+    async admin(callOptions) {
+        return await this.contract.admin({ ...callOptions });
     }
-    async pendingAdmin() {
-        return await this.contract.pendingAdmin();
+    async pendingAdmin(callOptions) {
+        return await this.contract.pendingAdmin({ ...callOptions });
     }
-    async registry() {
-        return await this.contract.registry();
+    async registry(callOptions) {
+        return await this.contract.registry({ ...callOptions });
     }
-    async sourceChainIdForAsset(asset) {
-        return await this.contract.sourceChainIdForAsset(asset);
+    async sourceChainIdForAsset(asset, callOptions) {
+        return await this.contract.sourceChainIdForAsset(asset, { ...callOptions });
     }
-    async processedSignatures(signature) {
-        return await this.contract.processedSignatures(signature);
+    async processedSignatures(signature, callOptions) {
+        return await this.contract.processedSignatures(signature, { ...callOptions });
     }
-    async domainSeparatorsForPosition(positionId) {
-        return await this.contract.domainSeparatorsForPosition(positionId);
+    async domainSeparatorsForPosition(positionId, callOptions) {
+        return await this.contract.domainSeparatorsForPosition(positionId, { ...callOptions });
     }
-    async tradersForPosition(positionId) {
-        return await this.contract.tradersForPosition(positionId);
+    async tradersForPosition(positionId, callOptions) {
+        return await this.contract.tradersForPosition(positionId, { ...callOptions });
     }
-    async settlementAssetsForPosition(positionId) {
-        return await this.contract.settlementAssetsForPosition(positionId);
+    async settlementAssetsForPosition(positionId, callOptions) {
+        return await this.contract.settlementAssetsForPosition(positionId, { ...callOptions });
     }
-    async getTradingFloor() {
-        return await this.contract.getTradingFloor();
+    async getTradingFloor(callOptions) {
+        return await this.contract.getTradingFloor({ ...callOptions });
     }
-    async getTradersPortal() {
-        return await this.contract.getTradersPortal();
+    async getTradersPortal(callOptions) {
+        return await this.contract.getTradersPortal({ ...callOptions });
     }
     getContract() {
         return this.contract;