@nevermined-io/core-kit 0.4.5 → 0.5.1

package/dist/contracts/ContractBase.js

@@ -1,9 +1,10 @@
 import { createKernelAccountClient, createZeroDevPaymasterClient } from '@zerodev/sdk';
-import { estimateUserOperationFees, getBundlerRpcUrl, getPaymasterRpcUrl, isRelayerMode, } from '../nevermined/utils/BlockchainViemUtils.js';
-import { BaseError, ContractFunctionRevertedError, encodeFunctionData, getContract, http, parseAbi, parseEventLogs, } from 'viem';
+import { estimateUserOperationFees, getBundlerRpcUrl, getPaymasterRpcUrl, isRelayerMode } from '../nevermined/utils/BlockchainViemUtils.js';
+import { BaseError, ContractFunctionRevertedError, encodeFunctionData, getContract, http, parseAbi, parseEventLogs } from 'viem';
 import { ContractsError, ContractSimulationError } from '../errors/index.js';
 import { Instantiable } from '../Instantiable.abstract.js';
 import { getInputsOfFunctionFormatted, getTransactionReceipt } from '../nevermined/index.js';
+import { getRandomBigInt } from '../utils/helpers.js';
 import { getChain } from '../utils/Network.js';
 /**
  * When a testnet RPC (Base Sepolia) fails internally, some providers return
@@ -17,23 +18,26 @@ import { getChain } from '../utils/Network.js';
  * chance to intercept a bogus estimate. We run the estimation ourselves
  * here, sanity-check the result, and always pass an explicit gas value
  * into `writeContract` so it doesn't re-query the misbehaving RPC.
- */
-const GAS_SANITY_THRESHOLD = 25000000n;
-const GAS_FALLBACK_CAP = 5000000n;
+ */ const GAS_SANITY_THRESHOLD = 25_000_000n;
+const GAS_FALLBACK_CAP = 5_000_000n;
+// EntryPoint v0.7: ZeroDev's `toKernelPluginManager` rejects `customNonceKey > maxUint16`.
+// 16 bits = 65 536 channels — collision probability for the SDK's expected concurrency
+// (k=2–5 parallel sends from one SCA) is negligible (< 0.02 %). High-fan-out callers
+// (k > 50) should consider a per-process monotonic counter instead. See issue #1579.
+const ZERODEV_NONCE_KEY_BITS = 16;
+// Client-side cap on `waitForUserOperationReceipt`. The userOp is already in the bundler
+// mempool when this fires — a client-side timeout does NOT cancel it. Callers that catch
+// the resulting `ContractsError` MUST poll `bundlerClient.getUserOperationReceipt(hash)`
+// before retrying; otherwise a retry can produce a duplicate on-chain op.
+const USEROP_RECEIPT_TIMEOUT_MS = 90_000;
 function capForBogusEstimate(estimatedGas, logger) {
-    if (estimatedGas < GAS_SANITY_THRESHOLD)
-        return estimatedGas;
-    logger.warn(`Estimated gas (${estimatedGas}) exceeds sanity threshold ` +
-        `(${GAS_SANITY_THRESHOLD}); overriding with ${GAS_FALLBACK_CAP} to bypass misbehaving RPC estimate.`);
+    if (estimatedGas < GAS_SANITY_THRESHOLD) return estimatedGas;
+    logger.warn(`Estimated gas (${estimatedGas}) exceeds sanity threshold ` + `(${GAS_SANITY_THRESHOLD}); overriding with ${GAS_FALLBACK_CAP} to bypass misbehaving RPC estimate.`);
     return GAS_FALLBACK_CAP;
 }
 export class ContractBase extends Instantiable {
-    contractName;
-    contract;
-    address;
-    _zeroDevPaymaster = null;
-    constructor(contractName, address) {
-        super();
+    constructor(contractName, address){
+        super(), this._zeroDevPaymaster = null;
         this.contractName = contractName;
         this.address = address;
     }
@@ -43,21 +47,27 @@ export class ContractBase extends Instantiable {
         this.contract = getContract({
             address: contractConfig.address,
             abi: contractConfig.abi,
-            client: { public: this.publicClient, wallet: this.walletClient },
+            client: {
+                public: this.publicClient,
+                wallet: this.walletClient
+            }
         });
     }
     async call(functionName, args, from) {
         try {
-            return (await this.client.public.readContract({
+            return await this.client.public.readContract({
                 address: this.address,
                 abi: this.contract.abi,
-                functionName: parseAbi([functionName]),
+                functionName: parseAbi([
+                    functionName
+                ]),
                 args,
-                ...(from && { account: from }),
-            }));
-            //return await this.contract[functionSignature](...args, { from })
-        }
-        catch (err) {
+                ...from && {
+                    account: from
+                }
+            });
+        //return await this.contract[functionSignature](...args, { from })
+        } catch (err) {
             throw new ContractsError(`Calling method "${functionName}" on contract "${this.contractName}" failed. Args: ${args} - ${err}`);
         }
     }
@@ -66,16 +76,14 @@ export class ContractBase extends Instantiable {
         if ('transactionHash' in txHash) {
             // txHash is TransactionReceipt
             return txHash;
-        }
-        else if ('userOpHash' in txHash) {
+        } else if ('userOpHash' in txHash) {
             // txHash is UserOperationReceipt, fetch the actual receipt using the utility function with retry logic
             const hash = txHash.receipt.transactionHash;
             return await getTransactionReceipt({
                 txHash: hash,
-                publicClient: this.client.public,
+                publicClient: this.client.public
             });
-        }
-        else {
+        } else {
             throw new Error('Unknown transaction type');
         }
     }
@@ -84,23 +92,20 @@ export class ContractBase extends Instantiable {
             abi: this.contract.abi,
             logs: txReceipt.logs,
             eventName,
-            strict: false,
+            strict: false
         });
     }
     async multicall(calls, from, params = {}) {
         if (from.type === 'local') {
             this.logger.debug(`Blockchain Multicall using Local account`);
             return await this.localAccountMulticall(calls, from, params, params.progress);
-        }
-        else if (from.type === 'json-rpc') {
+        } else if (from.type === 'json-rpc') {
             this.logger.debug(`Blockchain Multicall using JSON-RPC account`);
             return await this.localAccountMulticall(calls, from, params, params.progress);
-        }
-        else if (from.type === 'smart') {
+        } else if (from.type === 'smart') {
             this.logger.debug(`Blockchain Multicall using ZeroDev account`);
             return await this.internalMulticallSmartAccount(calls, from, params, params.progress);
-        }
-        else {
+        } else {
             throw new ContractsError(`Account not supported`);
         }
     }
@@ -108,16 +113,13 @@ export class ContractBase extends Instantiable {
         if (from.type === 'local') {
             this.logger.debug(`Simulating calls using Local account`);
             return await this.localAccountSimulateMulticall(calls, from, params);
-        }
-        else if (from.type === 'json-rpc') {
+        } else if (from.type === 'json-rpc') {
             this.logger.debug(`Simulating calls using JSON-RPC account`);
             return await this.localAccountSimulateMulticall(calls, from, params);
-        }
-        else if (from.type === 'smart') {
+        } else if (from.type === 'smart') {
             this.logger.debug(`Simulating calls using Smart Account account`);
             return await this.internalSimulateMulticallSmartAccount(calls, from, params);
-        }
-        else {
+        } else {
             throw new ContractsError(`Account not supported`);
         }
     }
@@ -125,16 +127,13 @@ export class ContractBase extends Instantiable {
         if (from.type === 'local') {
             this.logger.debug(`Simulating calls using Local account`);
             return await this.localAccountSimulate(functionName, from, args, params);
-        }
-        else if (from.type === 'json-rpc') {
+        } else if (from.type === 'json-rpc') {
             this.logger.debug(`Simulating calls using JSON-RPC account`);
             return await this.localAccountSimulate(functionName, from, args, params);
-        }
-        else if (from.type === 'smart') {
+        } else if (from.type === 'smart') {
             this.logger.debug(`Simulating calls using Smart Account account`);
             return await this.internalSimulateSmartAccount(functionName, from, args, params);
-        }
-        else {
+        } else {
             throw new ContractsError(`Account not supported`);
         }
     }
@@ -142,16 +141,13 @@ export class ContractBase extends Instantiable {
         if (from.type === 'local') {
             this.logger.debug(`Blockchain Send using Local account with functionName: ${functionName} and following args: ${args}`);
             return await this.localAccountSend(functionName, from, args, params, params.progress);
-        }
-        else if (from.type === 'json-rpc') {
+        } else if (from.type === 'json-rpc') {
             this.logger.debug(`Blockchain Send using JSON-RPC account to ${functionName}`);
             return await this.localAccountSend(functionName, from, args, params, params.progress);
-        }
-        else if (from.type === 'smart') {
+        } else if (from.type === 'smart') {
             this.logger.debug(`Blockchain Send using ZeroDev account`);
             return await this.internalSendSmartAccount(functionName, from, args, params, params.progress);
-        }
-        else {
+        } else {
             throw new ContractsError(`Account not supported`);
         }
     }
@@ -162,7 +158,7 @@ export class ContractBase extends Instantiable {
                 args: [],
                 method: '',
                 from: from,
-                contractAddress: this.address,
+                contractAddress: this.address
             });
         }
         const kernelClient = createKernelAccountClient({
@@ -172,26 +168,34 @@ export class ContractBase extends Instantiable {
             client: this.client.public,
             ...this.getPaymasterConfig(),
             userOperation: {
-                estimateFeesPerGas: async ({ bundlerClient }) => {
+                estimateFeesPerGas: async ({ bundlerClient })=>{
                     return estimateUserOperationFees(bundlerClient, this.client.public);
-                },
-            },
+                }
+            }
         });
         const encodedCalls = [];
-        calls.map((call) => {
+        calls.map((call)=>{
             encodedCalls.push({
                 to: call.contractAddress || this.address,
                 value: txparams.value || 0n,
                 data: encodeFunctionData({
                     abi: call.abi,
                     functionName: call.functionName,
-                    args: call.args,
-                }),
+                    args: call.args
+                })
             });
         });
+        let userOpHash;
         try {
-            const userOpHash = await kernelClient.sendUserOperation({
+            // Random nonce key per send so concurrent userOps from the same SCA
+            // hit distinct EntryPoint nonce channels instead of colliding on the
+            // default `customNonceKey=0n`. See issue #1579.
+            const nonce = await from.getNonce({
+                key: getRandomBigInt(ZERODEV_NONCE_KEY_BITS)
+            });
+            userOpHash = await kernelClient.sendUserOperation({
                 callData: await kernelClient.account.encodeCalls(encodedCalls),
+                nonce
             });
             if (progress) {
                 progress({
@@ -199,31 +203,33 @@ export class ContractBase extends Instantiable {
                     args: [],
                     method: '',
                     from: from,
-                    contractAddress: this.address,
+                    contractAddress: this.address
                 });
             }
             // Wait for the transaction to be mined
             this.logger.debug(`Waiting for transaction to be mined... ${userOpHash}`);
-            const txReceipt = await kernelClient.waitForUserOperationReceipt({ hash: userOpHash });
+            const txReceipt = await kernelClient.waitForUserOperationReceipt({
+                hash: userOpHash,
+                timeout: USEROP_RECEIPT_TIMEOUT_MS
+            });
             this.logger.debug(`Transaction mined - UserOperationHash: ${userOpHash}`);
             this.logger.debug(`Transaction receipt - TransactionHash: ${txReceipt.receipt.transactionHash}`);
             this.assertUserOpSucceeded(txReceipt, 'multicall', userOpHash);
             return txReceipt.receipt;
-        }
-        catch (err) {
+        } catch (err) {
             if (err instanceof BaseError) {
-                const revertError = err.walk((err) => err instanceof ContractFunctionRevertedError);
+                const revertError = err.walk((err)=>err instanceof ContractFunctionRevertedError);
                 this.logger.error(`revertError: ${String(revertError)}`);
             }
-            throw new ContractsError(`Multicall failed: ${err}`);
+            // Surface userOpHash so callers can poll for eventual inclusion before
+            // retrying — a client-side receipt-wait timeout does NOT cancel the userOp.
+            const hashSuffix = userOpHash ? ` userOpHash=${userOpHash}` : '';
+            throw new ContractsError(`Multicall failed:${hashSuffix} ${err}`);
         }
     }
     assertUserOpSucceeded(txReceipt, method, userOpHash) {
-        if (txReceipt.success)
-            return;
-        throw new ContractsError(`UserOp inner call reverted for "${method}" on "${this.contractName}". ` +
-            `userOpHash=${userOpHash} txHash=${txReceipt.receipt.transactionHash} ` +
-            `reason=${txReceipt.reason ?? 'unknown'}`);
+        if (txReceipt.success) return;
+        throw new ContractsError(`UserOp inner call reverted for "${method}" on "${this.contractName}". ` + `userOpHash=${userOpHash} txHash=${txReceipt.receipt.transactionHash} ` + `reason=${txReceipt.reason ?? 'unknown'}`);
     }
     async internalSendSmartAccount(name, from, args, txparams, progress) {
         const functionInputs = getInputsOfFunctionFormatted(this.contract.abi, name, args);
@@ -237,7 +243,7 @@ export class ContractBase extends Instantiable {
                 value,
                 contractName: this.contractName,
                 contractAddress: this.address,
-                gasLimit,
+                gasLimit
             });
         }
         try {
@@ -247,12 +253,13 @@ export class ContractBase extends Instantiable {
                 functionName: name,
                 args,
                 account: from,
-                ...(txparams.value && { value: txparams.value }),
+                ...txparams.value && {
+                    value: txparams.value
+                }
             });
-        }
-        catch (err) {
+        } catch (err) {
             if (err instanceof BaseError) {
-                const revertError = err.walk((err) => err instanceof ContractFunctionRevertedError);
+                const revertError = err.walk((err)=>err instanceof ContractFunctionRevertedError);
                 this.logger.error(`revertError: ${String(revertError)}`);
             }
             throw new ContractsError(`Calling method "${name}" on contract "${this.contractName}" failed. Args: ${args} - ${err}`);
@@ -264,27 +271,37 @@ export class ContractBase extends Instantiable {
             client: this.client.public,
             ...this.getPaymasterConfig(),
             userOperation: {
-                estimateFeesPerGas: async ({ bundlerClient }) => {
+                estimateFeesPerGas: async ({ bundlerClient })=>{
                     return estimateUserOperationFees(bundlerClient, this.client.public);
-                },
-            },
+                }
+            }
+        });
+        const data = encodeFunctionData({
+            abi: this.contract.abi,
+            functionName: name,
+            args
         });
-        const data = encodeFunctionData({ abi: this.contract.abi, functionName: name, args });
         let userOpHash;
         try {
+            // Random nonce key per send so concurrent userOps from the same SCA
+            // hit distinct EntryPoint nonce channels instead of colliding on the
+            // default `customNonceKey=0n`. See issue #1579.
+            const nonce = await from.getNonce({
+                key: getRandomBigInt(ZERODEV_NONCE_KEY_BITS)
+            });
             userOpHash = await kernelClient.sendUserOperation({
                 callData: await kernelClient.account.encodeCalls([
                     {
                         to: this.address,
                         value: txparams.value || 0n,
-                        data,
-                    },
+                        data
+                    }
                 ]),
+                nonce
             });
-        }
-        catch (err) {
+        } catch (err) {
             if (err instanceof BaseError) {
-                const revertError = err.walk((err) => err instanceof ContractFunctionRevertedError);
+                const revertError = err.walk((err)=>err instanceof ContractFunctionRevertedError);
                 this.logger.error(`revertError: ${String(revertError)}`);
             }
             throw new ContractsError(`Calling method "${name}" on contract "${this.contractName}" failed. Args: ${args} - ${err}`);
@@ -299,10 +316,22 @@ export class ContractBase extends Instantiable {
                 value,
                 contractName: this.contractName,
                 contractAddress: this.address,
-                gasLimit,
+                gasLimit
+            });
+        }
+        let txReceipt;
+        try {
+            txReceipt = await kernelClient.waitForUserOperationReceipt({
+                hash: userOpHash,
+                timeout: USEROP_RECEIPT_TIMEOUT_MS
             });
+        } catch (err) {
+            // The userOp is already in the bundler mempool — a client-side timeout
+            // does NOT cancel it. Surface userOpHash so callers can poll for eventual
+            // inclusion before retrying, otherwise a retry can produce a duplicate
+            // on-chain op. Wrap symmetric to `internalMulticallSmartAccount`.
+            throw new ContractsError(`Calling method "${name}" on contract "${this.contractName}" timed out ` + `waiting for UserOp receipt. userOpHash=${userOpHash} — confirm on-chain ` + `inclusion before retrying. Underlying: ${err}`);
         }
-        const txReceipt = await kernelClient.waitForUserOperationReceipt({ hash: userOpHash });
         this.assertUserOpSucceeded(txReceipt, name, userOpHash);
         if (progress) {
             progress({
@@ -314,7 +343,7 @@ export class ContractBase extends Instantiable {
                 value,
                 contractName: this.contractName,
                 contractAddress: this.address,
-                gasLimit,
+                gasLimit
             });
         }
         return txReceipt;
@@ -327,11 +356,12 @@ export class ContractBase extends Instantiable {
                 functionName: name,
                 args,
                 account: from.address,
-                ...(txparams.value && { value: txparams.value }),
+                ...txparams.value && {
+                    value: txparams.value
+                }
             });
             return true;
-        }
-        catch (err) {
+        } catch (err) {
             throw new ContractSimulationError(`Error Simulating contract call "${name}" on contract "${this.contractName}" failed. Args: ${args} - ${err}`);
         }
     }
@@ -343,10 +373,11 @@ export class ContractBase extends Instantiable {
                 functionName: name,
                 args,
                 account: from,
-                ...(txparams.value && { value: txparams.value }),
+                ...txparams.value && {
+                    value: txparams.value
+                }
             });
-        }
-        catch (err) {
+        } catch (err) {
             throw new ContractSimulationError(`Error Simulating contract call "${name}" on contract "${this.contractName}" failed. Args: ${args} - ${err}`);
         }
         return true;
@@ -384,7 +415,7 @@ export class ContractBase extends Instantiable {
                 value,
                 contractName,
                 contractAddress,
-                gasLimit,
+                gasLimit
             });
         }
         let txHash;
@@ -395,7 +426,9 @@ export class ContractBase extends Instantiable {
                 functionName: name,
                 args,
                 account: from,
-                ...(txparams.value && { value: txparams.value }),
+                ...txparams.value && {
+                    value: txparams.value
+                }
             });
             // Resolve gas ourselves so `writeContract` never falls back to its own
             // `eth_estimateGas`. An explicit caller `gasLimit` always wins; otherwise
@@ -410,25 +443,24 @@ export class ContractBase extends Instantiable {
                         functionName: name,
                         args,
                         account: from,
-                        ...(txparams.value && { value: txparams.value }),
+                        ...txparams.value && {
+                            value: txparams.value
+                        }
                     });
                     resolvedGas = capForBogusEstimate(estimate, this.logger);
-                }
-                catch (estErr) {
-                    this.logger.warn(`estimateContractGas for "${name}" on "${contractName}" failed (${estErr}); ` +
-                        `falling back to ${GAS_FALLBACK_CAP} to avoid a bogus RPC re-estimate in writeContract.`);
+                } catch (estErr) {
+                    this.logger.warn(`estimateContractGas for "${name}" on "${contractName}" failed (${estErr}); ` + `falling back to ${GAS_FALLBACK_CAP} to avoid a bogus RPC re-estimate in writeContract.`);
                     resolvedGas = GAS_FALLBACK_CAP;
                 }
             }
             txHash = await this.client.wallet.writeContract({
                 ...request,
                 account: from,
-                gas: resolvedGas,
+                gas: resolvedGas
             });
-        }
-        catch (err) {
+        } catch (err) {
             if (err instanceof BaseError) {
-                const revertError = err.walk((err) => err instanceof ContractFunctionRevertedError);
+                const revertError = err.walk((err)=>err instanceof ContractFunctionRevertedError);
                 this.logger.error(`revertError: ${String(revertError)}`);
             }
             throw new ContractsError(`Calling method "${name}" on contract "${contractName}" failed. Args: ${args} - ${err}`);
@@ -443,10 +475,13 @@ export class ContractBase extends Instantiable {
                 value,
                 contractName,
                 contractAddress,
-                gasLimit,
+                gasLimit
             });
         }
-        const txReceipt = getTransactionReceipt({ txHash, publicClient: this.client.public });
+        const txReceipt = getTransactionReceipt({
+            txHash,
+            publicClient: this.client.public
+        });
         if (progress) {
             progress({
                 stage: 'receipt',
@@ -457,33 +492,30 @@ export class ContractBase extends Instantiable {
                 value,
                 contractName,
                 contractAddress,
-                gasLimit,
+                gasLimit
             });
         }
         return txReceipt;
     }
     async localAccountMulticall(calls, from, txparams, progress) {
         const receipts = [];
-        for (const call of calls) {
+        for (const call of calls){
             receipts.push(await this.localAccountSend(call.functionName, from, call.args, txparams, progress, call.abi, call.contractAddress, call.contractName));
         }
-        if (receipts.length > 0)
-            return receipts.pop();
-        else
-            throw new ContractsError(`No receipts found for multicall`);
+        if (receipts.length > 0) return receipts.pop();
+        else throw new ContractsError(`No receipts found for multicall`);
     }
     async localAccountSimulateMulticall(calls, from, txparams) {
         try {
             const { results } = await this.client.public.simulateCalls({
                 calls,
-                account: from,
+                account: from
             });
             this.logger.debug(`Simulated multicall - ${results}`);
             return true;
-        }
-        catch (err) {
+        } catch (err) {
             if (err instanceof BaseError) {
-                const revertError = err.walk((err) => err instanceof ContractFunctionRevertedError);
+                const revertError = err.walk((err)=>err instanceof ContractFunctionRevertedError);
                 this.logger.error(`revertError: ${String(revertError)}`);
             }
             throw new ContractsError(`Error simulating multicall - ${err}`);
@@ -498,21 +530,21 @@ export class ContractBase extends Instantiable {
                 client: this.client.public,
                 ...this.getPaymasterConfig(),
                 userOperation: {
-                    estimateFeesPerGas: async ({ bundlerClient }) => {
+                    estimateFeesPerGas: async ({ bundlerClient })=>{
                         return estimateUserOperationFees(bundlerClient, this.client.public);
-                    },
-                },
+                    }
+                }
             });
             const encodedCalls = [];
-            for (const call of calls) {
+            for (const call of calls){
                 encodedCalls.push({
                     to: call.to,
                     value: call.value || 0n,
                     data: encodeFunctionData({
                         abi: call.abi,
                         functionName: call.functionName,
-                        args: call.args,
-                    }),
+                        args: call.args
+                    })
                 });
             }
             // DONT DELETE THE COMMENTED LINES - ARE NECESSARY FOR F***ING ZERODEV DEBUGGING
@@ -529,14 +561,13 @@ export class ContractBase extends Instantiable {
             //   this.logger.info(`Call ${index}: to=${call.to}, value=${call.value}, data=${call.data.slice(0, 10)}...`)
             // })
             await kernelClient.prepareUserOperation({
-                callData: await kernelClient.account.encodeCalls(encodedCalls),
+                callData: await kernelClient.account.encodeCalls(encodedCalls)
             });
             return true;
-        }
-        catch (err) {
+        } catch (err) {
             this.logger.error(`Error details: ${JSON.stringify(err, null, 2)}`);
             if (err instanceof BaseError) {
-                const revertError = err.walk((e) => e instanceof ContractFunctionRevertedError);
+                const revertError = err.walk((e)=>e instanceof ContractFunctionRevertedError);
                 if (revertError) {
                     this.logger.error(`Revert error: ${String(revertError)}`);
                 }
@@ -548,26 +579,26 @@ export class ContractBase extends Instantiable {
         if (!this._zeroDevPaymaster) {
             this._zeroDevPaymaster = createZeroDevPaymasterClient({
                 chain: getChain(this.config.chainId),
-                transport: http(this.getPaymasterRPC()),
+                transport: http(this.getPaymasterRPC())
             });
         }
         return this._zeroDevPaymaster;
     }
     /**
-     * Builds the `paymaster` partial for `createKernelAccountClient`. In relayer
-     * mode (e.g. local `ultra-relay` for tests) returns an empty object so the
-     * kernel client submits UserOps without paymaster fields and the bundler
-     * pays gas via its executor key. In production returns the ZeroDev paymaster
-     * sponsorship callback.
-     */
-    getPaymasterConfig() {
-        if (isRelayerMode())
-            return {};
+   * Builds the `paymaster` partial for `createKernelAccountClient`. In relayer
+   * mode (e.g. local `ultra-relay` for tests) returns an empty object so the
+   * kernel client submits UserOps without paymaster fields and the bundler
+   * pays gas via its executor key. In production returns the ZeroDev paymaster
+   * sponsorship callback.
+   */ getPaymasterConfig() {
+        if (isRelayerMode()) return {};
         const zerodevPaymaster = this.getOrCreatePaymaster();
         return {
             paymaster: {
-                getPaymasterData: (userOperation) => zerodevPaymaster.sponsorUserOperation({ userOperation }),
-            },
+                getPaymasterData: (userOperation)=>zerodevPaymaster.sponsorUserOperation({
+                        userOperation
+                    })
+            }
         };
     }
     getBundlerRPC() {
@@ -592,3 +623,5 @@ export class ContractBase extends Instantiable {
         return getPaymasterRpcUrl(projectId, this.config.chainId);
     }
 }
+
+//# sourceMappingURL=ContractBase.js.map