add gas to txOverrides

src/db/transactions/queueTx.ts

@@ -15,6 +15,11 @@ interface QueueTxParams {
   deployedContractType?: string;
   simulateTx?: boolean;
   idempotencyKey?: string;
+  txOverrides?: {
+    gasLimit?: string;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+  };
 }
 
 export const queueTx = async ({
@@ -26,6 +31,7 @@ export const queueTx = async ({
   deployedContractType,
   simulateTx,
   idempotencyKey,
+  txOverrides,
 }: QueueTxParams) => {
   // TODO: We need a much safer way of detecting if the transaction should be a user operation
   const isUserOp = !!(tx.getSigner as ERC4337EthersSigner).erc4337provider;
@@ -38,6 +44,7 @@ export const queueTx = async ({
     deployedContractType: deployedContractType,
     data: tx.encode(),
     value: BigNumber.from(await tx.getValue()).toHexString(),
+    ...txOverrides,
   };
 
   if (isUserOp) {

src/server/routes/contract/write/write.ts

@@ -85,14 +85,26 @@ export async function writeToContract(fastify: FastifyInstance) {
         walletAddress,
         accountAddress,
       });
-      const tx = await contract.prepare(functionName, args, txOverrides);
+      const tx = contract.prepare(functionName, args, {
+        value: txOverrides?.value,
+        gasLimit: txOverrides?.gas,
+        maxFeePerGas: txOverrides?.maxFeePerGas,
+        maxPriorityFeePerGas: txOverrides?.maxPriorityFeePerGas,
+      });
+
+      const gasLimit = txOverrides?.gas;
+      delete txOverrides?.gas;
 
       const queueId = await queueTx({
         tx,
         chainId,
         simulateTx,
         extension: "none",
         idempotencyKey,
+        txOverrides: {
+          ...txOverrides,
+          gasLimit,
+        },
       });
 
       reply.status(StatusCodes.OK).send({

src/server/schemas/txOverrides.ts

@@ -5,10 +5,28 @@ export const txOverrides = Type.Object({
     Type.Object({
       value: Type.Optional(
         Type.String({
-          examples: ["0"],
+          examples: ["10000000000"],
           description: "Amount of native currency to send",
         }),
       ),
+      gas: Type.Optional(
+        Type.String({
+          examples: ["530000"],
+          description: "Gas limit for the transaction",
+        }),
+      ),
+      maxFeePerGas: Type.Optional(
+        Type.String({
+          examples: ["1000000000"],
+          description: "Maximum fee per gas",
+        }),
+      ),
+      maxPriorityFeePerGas: Type.Optional(
+        Type.String({
+          examples: ["1000000000"],
+          description: "Maximum priority fee per gas",
+        }),
+      ),
     }),
   ),
 });

src/worker/tasks/processTx.ts

@@ -171,11 +171,27 @@ export const processTx = async () => {
                 ...gasOverrides,
               });
 
-              // TODO: We need to target specific cases
-              // Bump gas limit to avoid occasional out of gas errors
-              txRequest.gasLimit = txRequest.gasLimit
-                ? BigNumber.from(txRequest.gasLimit).mul(120).div(100)
-                : undefined;
+              // Gas limit override
+              if (tx.gasLimit) {
+                txRequest.gasLimit = BigNumber.from(tx.gasLimit);
+              } else {
+                // TODO: We need to target specific cases
+                // Bump gas limit to avoid occasional out of gas errors
+                txRequest.gasLimit = txRequest.gasLimit
+                  ? BigNumber.from(txRequest.gasLimit).mul(120).div(100)
+                  : undefined;
+              }
+
+              // Gas price overrides
+              if (tx.maxFeePerGas) {
+                txRequest.maxFeePerGas = BigNumber.from(tx.maxFeePerGas);
+              }
+
+              if (tx.maxPriorityFeePerGas) {
+                txRequest.maxPriorityFeePerGas = BigNumber.from(
+                  tx.maxPriorityFeePerGas,
+                );
+              }
 
               const signature = await signer.signTransaction(txRequest);
               const rpcRequest = {
@@ -378,6 +394,24 @@ export const processTx = async () => {
                   nonce,
                 },
               );
+
+            // Temporary fix untill SDK allows us to do this
+            if (tx.gasLimit) {
+              unsignedOp.callGasLimit = BigNumber.from(tx.gasLimit);
+              unsignedOp.paymasterAndData = "0x";
+              const DUMMY_SIGNATURE =
+                "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
+              unsignedOp.signature = DUMMY_SIGNATURE;
+              const paymasterResult =
+                await signer.smartAccountAPI.paymasterAPI.getPaymasterAndData(
+                  unsignedOp,
+                );
+              const paymasterAndData = paymasterResult.paymasterAndData;
+              if (paymasterAndData && paymasterAndData !== "0x") {
+                unsignedOp.paymasterAndData = paymasterAndData;
+              }
+            }
+
             const userOp = await signer.smartAccountAPI.signUserOp(unsignedOp);
             const userOpHash = await signer.smartAccountAPI.getUserOpHash(
               userOp,