lynx-client 0.0.31 → 0.0.33

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;

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

@@ -7,30 +7,35 @@ class TraderRequests {
     constructor(tradingContract) {
         this.tradingContract = tradingContract;
     }
-    async openNewPosition(tradeRequestIdentifier, tradeRequestParams, orderType, referrerDomain, referrerCode, runCapTests, nativeFee) {
+    async openNewPosition(tradeRequestIdentifier, tradeRequestParams, orderType, referrerDomain, referrerCode, runCapTests, nativeFee, transactionOptions) {
         return this.tradingContract.traderRequest_openNewPosition(tradeRequestIdentifier, tradeRequestParams, orderType, referrerDomain, referrerCode, runCapTests, {
             value: nativeFee,
+            ...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) {
+    async setExistingPositionToMarketClose(positionId, minPrice, maxPrice, nativeFee, transactionOptions) {
         return this.tradingContract.traderRequest_marketClosePosition(positionId, minPrice, maxPrice, {
             value: nativeFee,
+            ...transactionOptions,
         });
     }
-    async updatePositionSingleField(positionId, orderType, fieldValue, nativeFee) {
+    async updatePositionSingleField(positionId, orderType, fieldValue, nativeFee, transactionOptions) {
         return this.tradingContract.traderRequest_updatePositionSingleField(positionId, orderType, fieldValue, {
             value: nativeFee,
+            ...transactionOptions,
         });
     }
-    async updatePositionDoubleFieldTpAndSl(positionId, tpValue, slValue, nativeFee) {
+    async updatePositionDoubleFieldTpAndSl(positionId, tpValue, slValue, nativeFee, transactionOptions) {
         return this.tradingContract.traderRequest_updatePositionDoubleField(positionId, contractEnums_1.UpdatePositionFieldOrderTypeEnums.UPDATE_TP_AND_SL, tpValue, slValue, {
             value: nativeFee,
+            ...transactionOptions,
         });
     }
 }
@@ -38,139 +43,141 @@ 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) {
-        return this.tradingContract.directAction_updatePendingPosition_limit(positionId, minPrice, maxPrice, tp, sl);
+    async updatePendingPositionLimit(positionId, minPrice, maxPrice, tp, sl, transactionOptions) {
+        return this.tradingContract.directAction_updatePendingPosition_limit(positionId, minPrice, maxPrice, tp, sl, {
+            ...transactionOptions,
+        });
     }
 }
 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,