lynx-client 0.0.32 → 0.0.34

package/dist/cjs/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/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;