lynx-client 0.0.32 → 0.0.33

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

@@ -7,64 +7,64 @@ class LiquidityIntentsVerifierService {
         this.contract = LiquidityIntentsVerifierV1__factory_1.LiquidityIntentsVerifierV1__factory.connect(address, signerOrProvider);
         this.isSigner = 'sendTransaction' in signerOrProvider;
     }
-    async domainSeparatorForAsset(pool) {
-        return await this.contract.domainSeparatorForAsset(pool);
+    async domainSeparatorForAsset(pool, callOptions) {
+        return await this.contract.domainSeparatorForAsset(pool, { ...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("LiquidityIntentsVerifierService: 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 interactOnBehalf_epochDeposit(pool, liquidityProvider, amount, minAmountOut, domain, referralCode, value) {
+    async interactOnBehalf_epochDeposit(pool, liquidityProvider, amount, minAmountOut, domain, referralCode, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("LiquidityIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.interactOnBehalf_epochDeposit(pool, liquidityProvider, amount, minAmountOut, domain, referralCode, { value: value || 0n });
+        const tx = await this.contract.interactOnBehalf_epochDeposit(pool, liquidityProvider, amount, minAmountOut, domain, referralCode, { value: value || 0n, ...transactionOptions });
         await tx.wait();
     }
-    async interactOnBehalf_epochRedeem(pool, liquidityProvider, amount, minAmountOut, value) {
+    async interactOnBehalf_epochRedeem(pool, liquidityProvider, amount, minAmountOut, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("LiquidityIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.interactOnBehalf_epochRedeem(pool, liquidityProvider, amount, minAmountOut, { value: value || 0n });
+        const tx = await this.contract.interactOnBehalf_epochRedeem(pool, liquidityProvider, amount, minAmountOut, { value: value || 0n, ...transactionOptions });
         await tx.wait();
     }
-    async verifyIntent_epochDeposit(payload, v, r, s, domain, referralCode, value) {
+    async verifyIntent_epochDeposit(payload, v, r, s, domain, referralCode, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("LiquidityIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.verifyIntent_epochDeposit(payload, v, r, s, domain, referralCode, { value: value || 0n });
+        const tx = await this.contract.verifyIntent_epochDeposit(payload, v, r, s, domain, referralCode, { value: value || 0n, ...transactionOptions });
         await tx.wait();
     }
-    async verifyIntent_epochRedeem(payload, v, r, s, value) {
+    async verifyIntent_epochRedeem(payload, v, r, s, value, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("LiquidityIntentsVerifierService: Write operations require a signer");
         }
-        const tx = await this.contract.verifyIntent_epochRedeem(payload, v, r, s, { value: value || 0n });
+        const tx = await this.contract.verifyIntent_epochRedeem(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 });
     }
     getContract() {
         return this.contract;

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

@@ -7,14 +7,14 @@ class PermissionQueries {
     constructor(contract) {
         this.contract = contract;
     }
-    async isPermissionValid(owner, spender, token) {
-        return await this.contract.isPermissionValid(owner, spender, token);
+    async isPermissionValid(owner, spender, token, callOptions) {
+        return await this.contract.isPermissionValid(owner, spender, token, { ...callOptions });
     }
-    async getRemainingAmount(owner, spender, token) {
-        return await this.contract.getRemainingAmount(owner, spender, token);
+    async getRemainingAmount(owner, spender, token, callOptions) {
+        return await this.contract.getRemainingAmount(owner, spender, token, { ...callOptions });
     }
-    async getPermission(owner, spender, token) {
-        const permission = await this.contract.permissions(owner, spender, token);
+    async getPermission(owner, spender, token, callOptions) {
+        const permission = await this.contract.permissions(owner, spender, token, { ...callOptions });
         return {
             amountLimit: permission.amountLimit,
             amountUsed: permission.amountUsed,
@@ -22,23 +22,23 @@ class PermissionQueries {
             isActive: permission.isActive,
         };
     }
-    async permanentlyRevoked(owner, spender) {
-        return await this.contract.permanentlyRevoked(owner, spender);
+    async permanentlyRevoked(owner, spender, callOptions) {
+        return await this.contract.permanentlyRevoked(owner, spender, { ...callOptions });
     }
-    async hasActivePermissions(owner) {
-        return await this.contract.hasActivePermissions(owner);
+    async hasActivePermissions(owner, callOptions) {
+        return await this.contract.hasActivePermissions(owner, { ...callOptions });
     }
-    async getActivePermissionCount(owner) {
-        return await this.contract.getActivePermissionCount(owner);
+    async getActivePermissionCount(owner, callOptions) {
+        return await this.contract.getActivePermissionCount(owner, { ...callOptions });
     }
-    async getActiveSpenders(owner) {
-        return await this.contract.getActiveSpenders(owner);
+    async getActiveSpenders(owner, callOptions) {
+        return await this.contract.getActiveSpenders(owner, { ...callOptions });
     }
-    async getActiveTokensForSpender(owner, spender) {
-        return await this.contract.getActiveTokensForSpender(owner, spender);
+    async getActiveTokensForSpender(owner, spender, callOptions) {
+        return await this.contract.getActiveTokensForSpender(owner, spender, { ...callOptions });
     }
-    async getAllActivePermissions(owner) {
-        const result = await this.contract.getAllActivePermissions(owner);
+    async getAllActivePermissions(owner, callOptions) {
+        const result = await this.contract.getAllActivePermissions(owner, { ...callOptions });
         return {
             spenders: result.spenders,
             tokens: result.tokens,
@@ -50,8 +50,8 @@ class PermissionQueries {
             })),
         };
     }
-    async requirePermission(owner, spender, token) {
-        await this.contract.requirePermission(owner, spender, token);
+    async requirePermission(owner, spender, token, callOptions) {
+        await this.contract.requirePermission(owner, spender, token, { ...callOptions });
     }
 }
 // ============ Permission Management Implementation ============
@@ -60,39 +60,39 @@ class PermissionManagement {
         this.contract = contract;
         this.isSigner = isSigner;
     }
-    async grantPermission(spender, token, amountLimit, duration) {
+    async grantPermission(spender, token, amountLimit, duration, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        const tx = await this.contract.grantPermission(spender, token, amountLimit, duration);
+        const tx = await this.contract.grantPermission(spender, token, amountLimit, duration, { ...transactionOptions });
         await tx.wait();
     }
-    async revokePermission(spender, token) {
+    async revokePermission(spender, token, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        const tx = await this.contract.revokePermission(spender, token);
+        const tx = await this.contract.revokePermission(spender, token, { ...transactionOptions });
         await tx.wait();
     }
-    async revokeAllPermissions(spender) {
+    async revokeAllPermissions(spender, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        const tx = await this.contract.revokeAllPermissions(spender);
+        const tx = await this.contract.revokeAllPermissions(spender, { ...transactionOptions });
         await tx.wait();
     }
-    async chargePermission(owner, spender, token, amount) {
+    async chargePermission(owner, spender, token, amount, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        const tx = await this.contract.chargePermission(owner, spender, token, amount);
+        const tx = await this.contract.chargePermission(owner, spender, token, amount, { ...transactionOptions });
         await tx.wait();
     }
-    async setPermissions(payloads) {
+    async setPermissions(payloads, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        return await this.contract.setPermissions(payloads);
+        return await this.contract.setPermissions(payloads, { ...transactionOptions });
     }
 }
 // ============ Configuration Implementation ============
@@ -100,17 +100,17 @@ class Configuration {
     constructor(contract) {
         this.contract = contract;
     }
-    async isPaused() {
-        return await this.contract.isPaused();
+    async isPaused(callOptions) {
+        return await this.contract.isPaused({ ...callOptions });
     }
-    async maxPermissionDuration() {
-        return await this.contract.maxPermissionDuration();
+    async maxPermissionDuration(callOptions) {
+        return await this.contract.maxPermissionDuration({ ...callOptions });
     }
-    async maxPermissionAmountPerToken(token) {
-        return await this.contract.maxPermissionAmountPerToken(token);
+    async maxPermissionAmountPerToken(token, callOptions) {
+        return await this.contract.maxPermissionAmountPerToken(token, { ...callOptions });
     }
-    async getContractConfiguration(tokensToQuery) {
-        const config = await this.contract.getContractConfiguration(tokensToQuery);
+    async getContractConfiguration(tokensToQuery, callOptions) {
+        const config = await this.contract.getContractConfiguration(tokensToQuery, { ...callOptions });
         return {
             isPausedState: config.isPausedState,
             maxDuration: config.maxDuration,
@@ -126,84 +126,84 @@ class AdminFunctions {
         this.contract = contract;
         this.isSigner = isSigner;
     }
-    async setMaxPermissionDuration(maxDuration) {
+    async setMaxPermissionDuration(maxDuration, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        const tx = await this.contract.setMaxPermissionDuration(maxDuration);
+        const tx = await this.contract.setMaxPermissionDuration(maxDuration, { ...transactionOptions });
         await tx.wait();
     }
-    async setMaxPermissionAmountForToken(token, maxAmount) {
+    async setMaxPermissionAmountForToken(token, maxAmount, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        const tx = await this.contract.setMaxPermissionAmountForToken(token, maxAmount);
+        const tx = await this.contract.setMaxPermissionAmountForToken(token, maxAmount, { ...transactionOptions });
         await tx.wait();
     }
-    async setMaxPermissionAmountsForTokens(tokens, maxAmounts) {
+    async setMaxPermissionAmountsForTokens(tokens, maxAmounts, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        const tx = await this.contract.setMaxPermissionAmountsForTokens(tokens, maxAmounts);
+        const tx = await this.contract.setMaxPermissionAmountsForTokens(tokens, maxAmounts, { ...transactionOptions });
         await tx.wait();
     }
-    async togglePause() {
+    async togglePause(transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        const tx = await this.contract.togglePause();
+        const tx = await this.contract.togglePause({ ...transactionOptions });
         await tx.wait();
     }
-    async setDynamicRoleCaller(caller, roleName) {
+    async setDynamicRoleCaller(caller, roleName, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        const tx = await this.contract.setDynamicRoleCaller(caller, roleName);
+        const tx = await this.contract.setDynamicRoleCaller(caller, roleName, { ...transactionOptions });
         await tx.wait();
     }
-    async setDynamicRoleCallers(callers, roleNames) {
+    async setDynamicRoleCallers(callers, roleNames, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        const tx = await this.contract.setDynamicRoleCallers(callers, roleNames);
+        const tx = await this.contract.setDynamicRoleCallers(callers, roleNames, { ...transactionOptions });
         await tx.wait();
     }
-    async adminRevokeSpecificPermission(owner, spender, token) {
+    async adminRevokeSpecificPermission(owner, spender, token, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        return await this.contract.adminRevokeSpecificPermission(owner, spender, token);
+        return await this.contract.adminRevokeSpecificPermission(owner, spender, token, { ...transactionOptions });
     }
-    async adminBatchRevokeSpecificPermissions(owners, spenders, tokens) {
+    async adminBatchRevokeSpecificPermissions(owners, spenders, tokens, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        return await this.contract.adminBatchRevokeSpecificPermissions(owners, spenders, tokens);
+        return await this.contract.adminBatchRevokeSpecificPermissions(owners, spenders, tokens, { ...transactionOptions });
     }
-    async adminRevokeAllPermissionsFromOwner(owner, spender) {
+    async adminRevokeAllPermissionsFromOwner(owner, spender, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        return await this.contract.adminRevokeAllPermissionsFromOwner(owner, spender);
+        return await this.contract.adminRevokeAllPermissionsFromOwner(owner, spender, { ...transactionOptions });
     }
-    async adminPermanentlyRevokeSpender(owner, spender) {
+    async adminPermanentlyRevokeSpender(owner, spender, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        return await this.contract.adminPermanentlyRevokeSpender(owner, spender);
+        return await this.contract.adminPermanentlyRevokeSpender(owner, spender, { ...transactionOptions });
     }
-    async setPendingAdmin(newPendingAdmin) {
+    async setPendingAdmin(newPendingAdmin, transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        const tx = await this.contract._setPendingAdmin(newPendingAdmin);
+        const tx = await this.contract._setPendingAdmin(newPendingAdmin, { ...transactionOptions });
         await tx.wait();
     }
-    async acceptAdmin() {
+    async acceptAdmin(transactionOptions) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        const tx = await this.contract._acceptAdmin();
+        const tx = await this.contract._acceptAdmin({ ...transactionOptions });
         await tx.wait();
     }
 }
@@ -212,11 +212,11 @@ class ContractReferences {
     constructor(contract) {
         this.contract = contract;
     }
-    async registry() {
-        return await this.contract.registry();
+    async registry(callOptions) {
+        return await this.contract.registry({ ...callOptions });
     }
-    async dynamicRoleCallers(address) {
-        return await this.contract.dynamicRoleCallers(address);
+    async dynamicRoleCallers(address, callOptions) {
+        return await this.contract.dynamicRoleCallers(address, { ...callOptions });
     }
 }
 // ============ Pendable Admin Implementation ============
@@ -224,11 +224,11 @@ class PendableAdmin {
     constructor(contract) {
         this.contract = contract;
     }
-    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 });
     }
 }
 // ============ Lynx Versioned Contract Implementation ============
@@ -236,17 +236,17 @@ class LynxVersionedContract {
     constructor(contract) {
         this.contract = contract;
     }
-    async getContractName() {
-        return await this.contract.getContractName();
+    async getContractName(callOptions) {
+        return await this.contract.getContractName({ ...callOptions });
     }
-    async getContractVersion() {
-        return await this.contract.getContractVersion();
+    async getContractVersion(callOptions) {
+        return await this.contract.getContractVersion({ ...callOptions });
     }
-    async CONTRACT_NAME() {
-        return await this.contract.CONTRACT_NAME();
+    async CONTRACT_NAME(callOptions) {
+        return await this.contract.CONTRACT_NAME({ ...callOptions });
     }
-    async CONTRACT_VERSION() {
-        return await this.contract.CONTRACT_VERSION();
+    async CONTRACT_VERSION(callOptions) {
+        return await this.contract.CONTRACT_VERSION({ ...callOptions });
     }
 }
 // ============ Main Service Class ============

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

@@ -6,87 +6,87 @@ class OrderManagement {
     constructor(orderBookContract) {
         this.orderBookContract = orderBookContract;
     }
-    async getAllPendingUpdateOrderIds() {
-        return this.orderBookContract.getAllPendingUpdateOrderIds();
+    async getAllPendingUpdateOrderIds(callOptions) {
+        return this.orderBookContract.getAllPendingUpdateOrderIds({ ...callOptions });
     }
-    async allPendingUpdateOrderIds(index) {
-        return this.orderBookContract.allPendingUpdateOrderIds(index);
+    async allPendingUpdateOrderIds(index, callOptions) {
+        return this.orderBookContract.allPendingUpdateOrderIds(index, { ...callOptions });
     }
-    async pendingUpdateTradeFieldOrdersById(positionId) {
-        return this.orderBookContract.pendingUpdateTradeFieldOrdersById(positionId);
+    async pendingUpdateTradeFieldOrdersById(positionId, callOptions) {
+        return this.orderBookContract.pendingUpdateTradeFieldOrdersById(positionId, { ...callOptions });
     }
-    async readAndDeleteUpdatePositionOrder(positionId) {
-        return this.orderBookContract.readAndDeleteUpdatePositionOrder(positionId);
+    async readAndDeleteUpdatePositionOrder(positionId, transactionOptions) {
+        return this.orderBookContract.readAndDeleteUpdatePositionOrder(positionId, { ...transactionOptions });
     }
-    async storeUpdatePositionDoubleFieldOrder(positionId, orderType, fieldValueA, fieldValueB) {
-        return this.orderBookContract.storeUpdatePositionDoubleFieldOrder(positionId, orderType, fieldValueA, fieldValueB);
+    async storeUpdatePositionDoubleFieldOrder(positionId, orderType, fieldValueA, fieldValueB, transactionOptions) {
+        return this.orderBookContract.storeUpdatePositionDoubleFieldOrder(positionId, orderType, fieldValueA, fieldValueB, { ...transactionOptions });
     }
-    async storeUpdatePositionSingleFieldOrder(positionId, orderType, fieldValue) {
-        return this.orderBookContract.storeUpdatePositionSingleFieldOrder(positionId, orderType, fieldValue);
+    async storeUpdatePositionSingleFieldOrder(positionId, orderType, fieldValue, transactionOptions) {
+        return this.orderBookContract.storeUpdatePositionSingleFieldOrder(positionId, orderType, fieldValue, { ...transactionOptions });
     }
-    async updateOrderIdPositionInList(positionId) {
-        return this.orderBookContract.updateOrderIdPositionInList(positionId);
+    async updateOrderIdPositionInList(positionId, callOptions) {
+        return this.orderBookContract.updateOrderIdPositionInList(positionId, { ...callOptions });
     }
 }
 class ContractReferences {
     constructor(orderBookContract) {
         this.orderBookContract = orderBookContract;
     }
-    async registry() {
-        return this.orderBookContract.registry();
+    async registry(callOptions) {
+        return this.orderBookContract.registry({ ...callOptions });
     }
-    async tradingFloor() {
-        return this.orderBookContract.tradingFloor();
+    async tradingFloor(callOptions) {
+        return this.orderBookContract.tradingFloor({ ...callOptions });
     }
 }
 class PendableAdmin {
     constructor(orderBookContract) {
         this.orderBookContract = orderBookContract;
     }
-    async admin() {
-        return this.orderBookContract.admin();
+    async admin(callOptions) {
+        return this.orderBookContract.admin({ ...callOptions });
     }
-    async pendingAdmin() {
-        return this.orderBookContract.pendingAdmin();
+    async pendingAdmin(callOptions) {
+        return this.orderBookContract.pendingAdmin({ ...callOptions });
     }
 }
 class PendableImplementation {
     constructor(orderBookContract) {
         this.orderBookContract = orderBookContract;
     }
-    async implementation() {
-        return this.orderBookContract.implementation();
+    async implementation(callOptions) {
+        return this.orderBookContract.implementation({ ...callOptions });
     }
-    async pendingImplementation() {
-        return this.orderBookContract.pendingImplementation();
+    async pendingImplementation(callOptions) {
+        return this.orderBookContract.pendingImplementation({ ...callOptions });
     }
 }
 class Administration {
     constructor(orderBookContract) {
         this.orderBookContract = orderBookContract;
     }
-    async setTradingFloor(tradingFloor) {
-        return this.orderBookContract.setTradingFloor(tradingFloor);
+    async setTradingFloor(tradingFloor, transactionOptions) {
+        return this.orderBookContract.setTradingFloor(tradingFloor, { ...transactionOptions });
     }
-    async _become(orderBookProxy) {
-        return this.orderBookContract._become(orderBookProxy);
+    async _become(orderBookProxy, transactionOptions) {
+        return this.orderBookContract._become(orderBookProxy, { ...transactionOptions });
     }
 }
 class Constants {
     constructor(orderBookContract) {
         this.orderBookContract = orderBookContract;
     }
-    async ACCURACY_IMPROVEMENT_SCALE() {
-        return this.orderBookContract.ACCURACY_IMPROVEMENT_SCALE();
+    async ACCURACY_IMPROVEMENT_SCALE(callOptions) {
+        return this.orderBookContract.ACCURACY_IMPROVEMENT_SCALE({ ...callOptions });
     }
-    async FRACTION_SCALE() {
-        return this.orderBookContract.FRACTION_SCALE();
+    async FRACTION_SCALE(callOptions) {
+        return this.orderBookContract.FRACTION_SCALE({ ...callOptions });
     }
-    async LEVERAGE_SCALE() {
-        return this.orderBookContract.LEVERAGE_SCALE();
+    async LEVERAGE_SCALE(callOptions) {
+        return this.orderBookContract.LEVERAGE_SCALE({ ...callOptions });
     }
-    async PRECISION() {
-        return this.orderBookContract.PRECISION();
+    async PRECISION(callOptions) {
+        return this.orderBookContract.PRECISION({ ...callOptions });
     }
 }
 class OrderBookService {