lynx-client 0.0.32 → 0.0.34

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

@@ -6,97 +6,97 @@ class FeatureManagement {
     constructor(contract) {
         this.contract = contract;
     }
-    async adminRegisterFeature(featureId, name) {
-        return this.contract.adminRegisterFeature(featureId, name);
+    async adminRegisterFeature(featureId, name, transactionOptions) {
+        return this.contract.adminRegisterFeature(featureId, name, { ...transactionOptions });
     }
-    async adminDisableFeatureForUser(featureId, user) {
-        return this.contract.adminDisableFeatureForUser(featureId, user);
+    async adminDisableFeatureForUser(featureId, user, transactionOptions) {
+        return this.contract.adminDisableFeatureForUser(featureId, user, { ...transactionOptions });
     }
-    async adminBatchDisableFeatureForUsers(featureId, users) {
-        return this.contract.adminBatchDisableFeatureForUsers(featureId, users);
+    async adminBatchDisableFeatureForUsers(featureId, users, transactionOptions) {
+        return this.contract.adminBatchDisableFeatureForUsers(featureId, users, { ...transactionOptions });
     }
 }
 class UserFeatureControl {
     constructor(contract) {
         this.contract = contract;
     }
-    async setFeatureActivated(featureId, enabled) {
-        return this.contract.setFeatureActivated(featureId, enabled);
+    async setFeatureActivated(featureId, enabled, transactionOptions) {
+        return this.contract.setFeatureActivated(featureId, enabled, { ...transactionOptions });
     }
 }
 class FeatureQueries {
     constructor(contract) {
         this.contract = contract;
     }
-    async isFeatureActivated(featureId, user) {
-        return this.contract.isFeatureActivated(featureId, user);
+    async isFeatureActivated(featureId, user, callOptions) {
+        return this.contract.isFeatureActivated(featureId, user, { ...callOptions });
     }
-    async isFeatureRegistered(featureId) {
-        return this.contract.isFeatureRegistered(featureId);
+    async isFeatureRegistered(featureId, callOptions) {
+        return this.contract.isFeatureRegistered(featureId, { ...callOptions });
     }
-    async getFeatureMetadata(featureId) {
-        const result = await this.contract.getFeatureMetadata(featureId);
+    async getFeatureMetadata(featureId, callOptions) {
+        const result = await this.contract.getFeatureMetadata(featureId, { ...callOptions });
         return {
             name: result.name,
             exists: result.exists,
             usersCount: result.usersCount,
         };
     }
-    async getFeatureUsers(featureId, startIndex, pageSize) {
-        const result = await this.contract.getFeatureUsers(featureId, startIndex, pageSize);
+    async getFeatureUsers(featureId, startIndex, pageSize, callOptions) {
+        const result = await this.contract.getFeatureUsers(featureId, startIndex, pageSize, { ...callOptions });
         return {
             users: result.users,
             totalCount: result.totalCount,
             hasMore: result.hasMore,
         };
     }
-    async getFeatureUsersCount(featureId) {
-        return this.contract.getFeatureUsersCount(featureId);
+    async getFeatureUsersCount(featureId, callOptions) {
+        return this.contract.getFeatureUsersCount(featureId, { ...callOptions });
     }
-    async getAllFeatureIds() {
-        return this.contract.getAllFeatureIds();
+    async getAllFeatureIds(callOptions) {
+        return this.contract.getAllFeatureIds({ ...callOptions });
     }
-    async featureName(featureId) {
-        return this.contract.featureName(featureId);
+    async featureName(featureId, callOptions) {
+        return this.contract.featureName(featureId, { ...callOptions });
     }
 }
 class ContractReferences {
     constructor(contract) {
         this.contract = contract;
     }
-    async registry() {
-        return this.contract.registry();
+    async registry(callOptions) {
+        return this.contract.registry({ ...callOptions });
     }
-    async implementation() {
-        return this.contract.implementation();
+    async implementation(callOptions) {
+        return this.contract.implementation({ ...callOptions });
     }
 }
 class PendableAdmin {
     constructor(contract) {
         this.contract = contract;
     }
-    async admin() {
-        return this.contract.admin();
+    async admin(callOptions) {
+        return this.contract.admin({ ...callOptions });
     }
-    async pendingAdmin() {
-        return this.contract.pendingAdmin();
+    async pendingAdmin(callOptions) {
+        return this.contract.pendingAdmin({ ...callOptions });
     }
 }
 class LynxVersionedContract {
     constructor(contract) {
         this.contract = contract;
     }
-    async getContractName() {
-        return this.contract.getContractName();
+    async getContractName(callOptions) {
+        return this.contract.getContractName({ ...callOptions });
     }
-    async getContractVersion() {
-        return this.contract.getContractVersion();
+    async getContractVersion(callOptions) {
+        return this.contract.getContractVersion({ ...callOptions });
     }
-    async CONTRACT_NAME() {
-        return this.contract.CONTRACT_NAME();
+    async CONTRACT_NAME(callOptions) {
+        return this.contract.CONTRACT_NAME({ ...callOptions });
     }
-    async CONTRACT_VERSION() {
-        return this.contract.CONTRACT_VERSION();
+    async CONTRACT_VERSION(callOptions) {
+        return this.contract.CONTRACT_VERSION({ ...callOptions });
     }
 }
 class FeatureFlaggerService {

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

@@ -75,6 +75,7 @@ exports.EMPTY_GROUP_CONFIGS_LENS = {
     maxLeverage: 0n,
     maxPositionSize: 0n,
     minLeverage: 0n,
+    minOpenFee: 0n,
 };
 exports.EMPTY_LEX_PAIR_STATE_LENS = {
     fundingRate: 0n,
@@ -114,11 +115,17 @@ exports.EMPTY_POOL_ACCOUNTANT_CONFIGURATIONS_LENS = {
     fundingRateModel: "",
     interestRateModel: "",
     interestShareFactor: 0n,
+    fundingShareFactor: 0n,
     matchingPool: "",
     minOpenFee: 0n,
     lexPartF: 0n,
     liquidationThresholdF: 0n,
     liquidationFeeF: 0n,
+    maxGainF: 0n,
+    fundingRateMax: 0n,
+    borrowRateMax: 0n,
+    maxTotalBorrows: 0n,
+    maxVirtualUtilization: 0n,
     supportedPairIds: [],
 };
 exports.EMPTY_COMPLETE_LEX_STATE = {

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);
-        return (0, ethersTypes_1.ethersStructResponseToObject)(result, ILexLensService_1.EMPTY_POOL_ACCOUNTANT_CONFIGURATIONS_LENS);
+    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, {}, {}, ["supportedPairIds"]);
     }
-    async getPoolAccountantConfigurationsByPoolAll(lexPools) {
-        const results = await this.contract.getPoolAccountantConfigurationsByPoolAll(lexPools);
-        return (0, ethersTypes_1.ethersStructResponseToArray)(results, ILexLensService_1.EMPTY_POOL_ACCOUNTANT_CONFIGURATIONS_LENS);
+    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, {}, {}, ["supportedPairIds"]);
     }
-    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