lynx-client 0.0.32 → 0.0.34

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

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

package/dist/esm/lib/contractsIntegration/LiquidityIntentsVerifierService/ILiquidityIntentsVerifierService.d.ts

@@ -1,17 +1,18 @@
 import { LiquidityIntentsVerifierV1 } from "../../typechain/contracts/Lynx/IntentsVerifier/LiquidityIntentsVerifierV1";
+import { CallOptions, TransactionOptions } from "../common";
 export interface ILiquidityIntentsVerifierService {
-    domainSeparatorForAsset(pool: string): Promise<string>;
-    domainSeparatorForChain(chainId: bigint): Promise<string>;
-    intentsPermissions(user: string): Promise<string>;
-    setIntentsPermissions(oftChip: string, dynAddressSuffix: string): Promise<void>;
-    interactOnBehalf_epochDeposit(pool: string, liquidityProvider: string, amount: bigint, minAmountOut: bigint, domain: string, referralCode: string, value?: bigint): Promise<void>;
-    interactOnBehalf_epochRedeem(pool: string, liquidityProvider: string, amount: bigint, minAmountOut: bigint, value?: bigint): Promise<void>;
-    verifyIntent_epochDeposit(payload: LiquidityIntentsVerifierV1.LiquidityProviderRequestPayload_EpochDepositStruct, v: bigint, r: string, s: string, domain: string, referralCode: string, value?: bigint): Promise<void>;
-    verifyIntent_epochRedeem(payload: LiquidityIntentsVerifierV1.LiquidityProviderRequestPayload_EpochRedeemStruct, v: bigint, r: string, s: string, value?: bigint): Promise<void>;
-    sourceChainIdForAsset(asset: string): Promise<bigint>;
-    processedSignatures(signature: string): Promise<boolean>;
-    admin(): Promise<string>;
-    pendingAdmin(): Promise<string>;
-    registry(): Promise<string>;
+    domainSeparatorForAsset(pool: string, callOptions?: CallOptions): Promise<string>;
+    domainSeparatorForChain(chainId: bigint, callOptions?: CallOptions): Promise<string>;
+    intentsPermissions(user: string, callOptions?: CallOptions): Promise<string>;
+    setIntentsPermissions(oftChip: string, dynAddressSuffix: string, transactionOptions?: TransactionOptions): Promise<void>;
+    interactOnBehalf_epochDeposit(pool: string, liquidityProvider: string, amount: bigint, minAmountOut: bigint, domain: string, referralCode: string, value?: bigint, transactionOptions?: TransactionOptions): Promise<void>;
+    interactOnBehalf_epochRedeem(pool: string, liquidityProvider: string, amount: bigint, minAmountOut: bigint, value?: bigint, transactionOptions?: TransactionOptions): Promise<void>;
+    verifyIntent_epochDeposit(payload: LiquidityIntentsVerifierV1.LiquidityProviderRequestPayload_EpochDepositStruct, v: bigint, r: string, s: string, domain: string, referralCode: string, value?: bigint, transactionOptions?: TransactionOptions): Promise<void>;
+    verifyIntent_epochRedeem(payload: LiquidityIntentsVerifierV1.LiquidityProviderRequestPayload_EpochRedeemStruct, v: bigint, r: string, s: string, value?: bigint, transactionOptions?: TransactionOptions): Promise<void>;
+    sourceChainIdForAsset(asset: string, callOptions?: CallOptions): Promise<bigint>;
+    processedSignatures(signature: string, callOptions?: CallOptions): Promise<boolean>;
+    admin(callOptions?: CallOptions): Promise<string>;
+    pendingAdmin(callOptions?: CallOptions): Promise<string>;
+    registry(callOptions?: CallOptions): Promise<string>;
 }
 //# sourceMappingURL=ILiquidityIntentsVerifierService.d.ts.map

package/dist/esm/lib/contractsIntegration/LiquidityIntentsVerifierService/ILiquidityIntentsVerifierService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ILiquidityIntentsVerifierService.d.ts","sourceRoot":"","sources":["../../../../../lib/contractsIntegration/LiquidityIntentsVerifierService/ILiquidityIntentsVerifierService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,2EAA2E,CAAA;AAEtH,MAAM,WAAW,gCAAgC;IAE/C,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACtD,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAGzD,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACjD,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAG/E,6BAA6B,CAC3B,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,MAAM,EACzB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAAA;IAGhB,4BAA4B,CAC1B,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,MAAM,EACzB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAAA;IAGhB,yBAAyB,CACvB,OAAO,EAAE,0BAA0B,CAAC,kDAAkD,EACtF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAAA;IAEhB,wBAAwB,CACtB,OAAO,EAAE,0BAA0B,CAAC,iDAAiD,EACrF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAAA;IAGhB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACrD,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAGxD,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,CAAA;IACxB,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAAA;IAC/B,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAAA;CAC5B"}
+{"version":3,"file":"ILiquidityIntentsVerifierService.d.ts","sourceRoot":"","sources":["../../../../../lib/contractsIntegration/LiquidityIntentsVerifierService/ILiquidityIntentsVerifierService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,2EAA2E,CAAA;AACtH,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AAE3D,MAAM,WAAW,gCAAgC;IAE/C,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACjF,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAGpF,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAC5E,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,kBAAkB,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAGxH,6BAA6B,CAC3B,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,MAAM,EACzB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,EACd,kBAAkB,CAAC,EAAE,kBAAkB,GACtC,OAAO,CAAC,IAAI,CAAC,CAAA;IAGhB,4BAA4B,CAC1B,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,MAAM,EACzB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,EACd,kBAAkB,CAAC,EAAE,kBAAkB,GACtC,OAAO,CAAC,IAAI,CAAC,CAAA;IAGhB,yBAAyB,CACvB,OAAO,EAAE,0BAA0B,CAAC,kDAAkD,EACtF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,EACd,kBAAkB,CAAC,EAAE,kBAAkB,GACtC,OAAO,CAAC,IAAI,CAAC,CAAA;IAEhB,wBAAwB,CACtB,OAAO,EAAE,0BAA0B,CAAC,iDAAiD,EACrF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,CAAC,EAAE,MAAM,EACd,kBAAkB,CAAC,EAAE,kBAAkB,GACtC,OAAO,CAAC,IAAI,CAAC,CAAA;IAGhB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAChF,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAGnF,KAAK,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACjD,YAAY,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACxD,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CACrD"}

package/dist/esm/lib/contractsIntegration/LiquidityIntentsVerifierService/LiquidityIntentsVerifierService.d.ts

@@ -1,23 +1,24 @@
 import { Provider, Signer } from "ethers";
 import { LiquidityIntentsVerifierV1 } from "../../typechain/contracts/Lynx/IntentsVerifier/LiquidityIntentsVerifierV1";
 import { ILiquidityIntentsVerifierService } from "./ILiquidityIntentsVerifierService";
+import { CallOptions, TransactionOptions } from "../common";
 export declare class LiquidityIntentsVerifierService implements ILiquidityIntentsVerifierService {
     private readonly contract;
     private readonly isSigner;
     constructor(signerOrProvider: Signer | Provider, address: string);
-    domainSeparatorForAsset(pool: string): Promise<string>;
-    domainSeparatorForChain(chainId: bigint): Promise<string>;
-    intentsPermissions(user: string): Promise<string>;
-    setIntentsPermissions(oftChip: string, dynAddressSuffix: string): Promise<void>;
-    interactOnBehalf_epochDeposit(pool: string, liquidityProvider: string, amount: bigint, minAmountOut: bigint, domain: string, referralCode: string, value?: bigint): Promise<void>;
-    interactOnBehalf_epochRedeem(pool: string, liquidityProvider: string, amount: bigint, minAmountOut: bigint, value?: bigint): Promise<void>;
-    verifyIntent_epochDeposit(payload: LiquidityIntentsVerifierV1.LiquidityProviderRequestPayload_EpochDepositStruct, v: bigint, r: string, s: string, domain: string, referralCode: string, value?: bigint): Promise<void>;
-    verifyIntent_epochRedeem(payload: LiquidityIntentsVerifierV1.LiquidityProviderRequestPayload_EpochRedeemStruct, v: bigint, r: string, s: string, value?: bigint): Promise<void>;
-    admin(): Promise<string>;
-    pendingAdmin(): Promise<string>;
-    registry(): Promise<string>;
-    sourceChainIdForAsset(asset: string): Promise<bigint>;
-    processedSignatures(signature: string): Promise<boolean>;
+    domainSeparatorForAsset(pool: string, callOptions?: CallOptions): Promise<string>;
+    domainSeparatorForChain(chainId: bigint, callOptions?: CallOptions): Promise<string>;
+    intentsPermissions(user: string, callOptions?: CallOptions): Promise<string>;
+    setIntentsPermissions(oftChip: string, dynAddressSuffix: string, transactionOptions?: TransactionOptions): Promise<void>;
+    interactOnBehalf_epochDeposit(pool: string, liquidityProvider: string, amount: bigint, minAmountOut: bigint, domain: string, referralCode: string, value?: bigint, transactionOptions?: TransactionOptions): Promise<void>;
+    interactOnBehalf_epochRedeem(pool: string, liquidityProvider: string, amount: bigint, minAmountOut: bigint, value?: bigint, transactionOptions?: TransactionOptions): Promise<void>;
+    verifyIntent_epochDeposit(payload: LiquidityIntentsVerifierV1.LiquidityProviderRequestPayload_EpochDepositStruct, v: bigint, r: string, s: string, domain: string, referralCode: string, value?: bigint, transactionOptions?: TransactionOptions): Promise<void>;
+    verifyIntent_epochRedeem(payload: LiquidityIntentsVerifierV1.LiquidityProviderRequestPayload_EpochRedeemStruct, v: bigint, r: string, s: string, value?: bigint, transactionOptions?: TransactionOptions): Promise<void>;
+    admin(callOptions?: CallOptions): Promise<string>;
+    pendingAdmin(callOptions?: CallOptions): Promise<string>;
+    registry(callOptions?: CallOptions): Promise<string>;
+    sourceChainIdForAsset(asset: string, callOptions?: CallOptions): Promise<bigint>;
+    processedSignatures(signature: string, callOptions?: CallOptions): Promise<boolean>;
     getContract(): LiquidityIntentsVerifierV1;
 }
 //# sourceMappingURL=LiquidityIntentsVerifierService.d.ts.map

package/dist/esm/lib/contractsIntegration/LiquidityIntentsVerifierService/LiquidityIntentsVerifierService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LiquidityIntentsVerifierService.d.ts","sourceRoot":"","sources":["../../../../../lib/contractsIntegration/LiquidityIntentsVerifierService/LiquidityIntentsVerifierService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACzC,OAAO,EAAE,0BAA0B,EAAE,MAAM,2EAA2E,CAAA;AAEtH,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAA;AAErF,qBAAa,+BAAgC,YAAW,gCAAgC;IACtF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;IACrD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,gBAAgB,EAAE,MAAM,GAAG,QAAQ,EAAE,OAAO,EAAE,MAAM;IAK1D,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAItD,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIzD,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIjD,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ/E,6BAA6B,CACjC,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,MAAM,EACzB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IAgBV,4BAA4B,CAChC,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,MAAM,EACzB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IAcV,yBAAyB,CAC7B,OAAO,EAAE,0BAA0B,CAAC,kDAAkD,EACtF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IAgBV,wBAAwB,CAC5B,OAAO,EAAE,0BAA0B,CAAC,iDAAiD,EACrF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IAcV,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAIxB,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAI/B,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC;IAI3B,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIrD,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI9D,WAAW,IAAI,0BAA0B;CAG1C"}
+{"version":3,"file":"LiquidityIntentsVerifierService.d.ts","sourceRoot":"","sources":["../../../../../lib/contractsIntegration/LiquidityIntentsVerifierService/LiquidityIntentsVerifierService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACzC,OAAO,EAAE,0BAA0B,EAAE,MAAM,2EAA2E,CAAA;AAEtH,OAAO,EAAE,gCAAgC,EAAE,MAAM,oCAAoC,CAAA;AACrF,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AAE3D,qBAAa,+BAAgC,YAAW,gCAAgC;IACtF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;IACrD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,gBAAgB,EAAE,MAAM,GAAG,QAAQ,EAAE,OAAO,EAAE,MAAM;IAK1D,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAIjF,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAIpF,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAI5E,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,kBAAkB,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAQxH,6BAA6B,CACjC,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,MAAM,EACzB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,EACd,kBAAkB,CAAC,EAAE,kBAAkB,GACtC,OAAO,CAAC,IAAI,CAAC;IAgBV,4BAA4B,CAChC,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,MAAM,EACzB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,EACd,kBAAkB,CAAC,EAAE,kBAAkB,GACtC,OAAO,CAAC,IAAI,CAAC;IAcV,yBAAyB,CAC7B,OAAO,EAAE,0BAA0B,CAAC,kDAAkD,EACtF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,EACd,kBAAkB,CAAC,EAAE,kBAAkB,GACtC,OAAO,CAAC,IAAI,CAAC;IAgBV,wBAAwB,CAC5B,OAAO,EAAE,0BAA0B,CAAC,iDAAiD,EACrF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,CAAC,EAAE,MAAM,EACd,kBAAkB,CAAC,EAAE,kBAAkB,GACtC,OAAO,CAAC,IAAI,CAAC;IAcV,KAAK,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAIjD,YAAY,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAIxD,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAIpD,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAIhF,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAIzF,WAAW,IAAI,0BAA0B;CAG1C"}

package/dist/esm/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/esm/lib/contractsIntegration/OnBehalfTradingService/IOnBehalfTradingService.d.ts

@@ -1,5 +1,5 @@
 import { ContractTransactionResponse } from "ethers";
-import { ILynxVersionedContract, IPendableAdmin } from "../common";
+import { ILynxVersionedContract, IPendableAdmin, TransactionOptions, CallOptions } from "../common";
 export interface PermissionInfo {
     amountLimit: bigint;
     amountUsed: bigint;
@@ -25,47 +25,47 @@ export interface PermissionSettingPayload {
     duration: bigint;
 }
 export interface IOnBehalfTradingFunctionsGroup_PermissionQueries {
-    isPermissionValid(owner: string, spender: string, token: string): Promise<boolean>;
-    getRemainingAmount(owner: string, spender: string, token: string): Promise<bigint>;
-    getPermission(owner: string, spender: string, token: string): Promise<PermissionInfo>;
-    permanentlyRevoked(owner: string, spender: string): Promise<boolean>;
-    hasActivePermissions(owner: string): Promise<boolean>;
-    getActivePermissionCount(owner: string): Promise<bigint>;
-    getActiveSpenders(owner: string): Promise<string[]>;
-    getActiveTokensForSpender(owner: string, spender: string): Promise<string[]>;
-    getAllActivePermissions(owner: string): Promise<AllActivePermissionsResult>;
-    requirePermission(owner: string, spender: string, token: string): Promise<void>;
+    isPermissionValid(owner: string, spender: string, token: string, callOptions?: CallOptions): Promise<boolean>;
+    getRemainingAmount(owner: string, spender: string, token: string, callOptions?: CallOptions): Promise<bigint>;
+    getPermission(owner: string, spender: string, token: string, callOptions?: CallOptions): Promise<PermissionInfo>;
+    permanentlyRevoked(owner: string, spender: string, callOptions?: CallOptions): Promise<boolean>;
+    hasActivePermissions(owner: string, callOptions?: CallOptions): Promise<boolean>;
+    getActivePermissionCount(owner: string, callOptions?: CallOptions): Promise<bigint>;
+    getActiveSpenders(owner: string, callOptions?: CallOptions): Promise<string[]>;
+    getActiveTokensForSpender(owner: string, spender: string, callOptions?: CallOptions): Promise<string[]>;
+    getAllActivePermissions(owner: string, callOptions?: CallOptions): Promise<AllActivePermissionsResult>;
+    requirePermission(owner: string, spender: string, token: string, callOptions?: CallOptions): Promise<void>;
 }
 export interface IOnBehalfTradingFunctionsGroup_PermissionManagement {
-    grantPermission(spender: string, token: string, amountLimit: bigint, duration: bigint): Promise<void>;
-    revokePermission(spender: string, token: string): Promise<void>;
-    revokeAllPermissions(spender: string): Promise<void>;
-    chargePermission(owner: string, spender: string, token: string, amount: bigint): Promise<void>;
-    setPermissions(payloads: PermissionSettingPayload[]): Promise<ContractTransactionResponse>;
+    grantPermission(spender: string, token: string, amountLimit: bigint, duration: bigint, transactionOptions?: TransactionOptions): Promise<void>;
+    revokePermission(spender: string, token: string, transactionOptions?: TransactionOptions): Promise<void>;
+    revokeAllPermissions(spender: string, transactionOptions?: TransactionOptions): Promise<void>;
+    chargePermission(owner: string, spender: string, token: string, amount: bigint, transactionOptions?: TransactionOptions): Promise<void>;
+    setPermissions(payloads: PermissionSettingPayload[], transactionOptions?: TransactionOptions): Promise<ContractTransactionResponse>;
 }
 export interface IOnBehalfTradingFunctionsGroup_Configuration {
-    isPaused(): Promise<boolean>;
-    maxPermissionDuration(): Promise<bigint>;
-    maxPermissionAmountPerToken(token: string): Promise<bigint>;
-    getContractConfiguration(tokensToQuery: string[]): Promise<ContractConfiguration>;
+    isPaused(callOptions?: CallOptions): Promise<boolean>;
+    maxPermissionDuration(callOptions?: CallOptions): Promise<bigint>;
+    maxPermissionAmountPerToken(token: string, callOptions?: CallOptions): Promise<bigint>;
+    getContractConfiguration(tokensToQuery: string[], callOptions?: CallOptions): Promise<ContractConfiguration>;
 }
 export interface IOnBehalfTradingFunctionsGroup_AdminFunctions {
-    setMaxPermissionDuration(maxDuration: bigint): Promise<void>;
-    setMaxPermissionAmountForToken(token: string, maxAmount: bigint): Promise<void>;
-    setMaxPermissionAmountsForTokens(tokens: string[], maxAmounts: bigint[]): Promise<void>;
-    togglePause(): Promise<void>;
-    setDynamicRoleCaller(caller: string, roleName: string): Promise<void>;
-    setDynamicRoleCallers(callers: string[], roleNames: string[]): Promise<void>;
-    adminRevokeSpecificPermission(owner: string, spender: string, token: string): Promise<ContractTransactionResponse>;
-    adminBatchRevokeSpecificPermissions(owners: string[], spenders: string[], tokens: string[]): Promise<ContractTransactionResponse>;
-    adminRevokeAllPermissionsFromOwner(owner: string, spender: string): Promise<ContractTransactionResponse>;
-    adminPermanentlyRevokeSpender(owner: string, spender: string): Promise<ContractTransactionResponse>;
-    setPendingAdmin(newPendingAdmin: string): Promise<void>;
-    acceptAdmin(): Promise<void>;
+    setMaxPermissionDuration(maxDuration: bigint, transactionOptions?: TransactionOptions): Promise<void>;
+    setMaxPermissionAmountForToken(token: string, maxAmount: bigint, transactionOptions?: TransactionOptions): Promise<void>;
+    setMaxPermissionAmountsForTokens(tokens: string[], maxAmounts: bigint[], transactionOptions?: TransactionOptions): Promise<void>;
+    togglePause(transactionOptions?: TransactionOptions): Promise<void>;
+    setDynamicRoleCaller(caller: string, roleName: string, transactionOptions?: TransactionOptions): Promise<void>;
+    setDynamicRoleCallers(callers: string[], roleNames: string[], transactionOptions?: TransactionOptions): Promise<void>;
+    adminRevokeSpecificPermission(owner: string, spender: string, token: string, transactionOptions?: TransactionOptions): Promise<ContractTransactionResponse>;
+    adminBatchRevokeSpecificPermissions(owners: string[], spenders: string[], tokens: string[], transactionOptions?: TransactionOptions): Promise<ContractTransactionResponse>;
+    adminRevokeAllPermissionsFromOwner(owner: string, spender: string, transactionOptions?: TransactionOptions): Promise<ContractTransactionResponse>;
+    adminPermanentlyRevokeSpender(owner: string, spender: string, transactionOptions?: TransactionOptions): Promise<ContractTransactionResponse>;
+    setPendingAdmin(newPendingAdmin: string, transactionOptions?: TransactionOptions): Promise<void>;
+    acceptAdmin(transactionOptions?: TransactionOptions): Promise<void>;
 }
 export interface IOnBehalfTradingFunctionsGroup_ContractReferences {
-    registry(): Promise<string>;
-    dynamicRoleCallers(address: string): Promise<string>;
+    registry(callOptions?: CallOptions): Promise<string>;
+    dynamicRoleCallers(address: string, callOptions?: CallOptions): Promise<string>;
 }
 export interface IOnBehalfTradingService {
     permissionQueries: IOnBehalfTradingFunctionsGroup_PermissionQueries;