@owlprotocol/contracts-account-abstraction/lib/cjs/eip1193/createBundlerEIP1193.js

ERC4337 Account Abstraction support for deploying relevant smart contracts and interacting with UserOps.

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var createBundlerEIP1193_exports = {};
__export(createBundlerEIP1193_exports, {
  bundlerRpcMethods: () => bundlerRpcMethods,
  createBackendBundlerEIP1193: () => createBackendBundlerEIP1193,
  isBundlerRpcMethod: () => isBundlerRpcMethod
});
module.exports = __toCommonJS(createBundlerEIP1193_exports);
var import_viem = require("viem");
var import_utils = require("viem/utils");
var import_eip1193 = require("@owlprotocol/backend-public/eip1193");
var import_requestGetUserOperationByHash = require("./bundler/requestGetUserOperationByHash.js");
var import_requestGetUserOperationReceipt = require("./bundler/requestGetUserOperationReceipt.js");
var import_actions = require("../actions/index.js");
var import_UserOperation = require("../models/UserOperation.js");
var import_Errors = require("../models/Errors.js");
const bundlerRpcMethods = [
  "eth_chainId",
  "eth_supportedEntryPoints",
  "eth_getUserOperationByHash",
  "eth_getUserOperationReceipt",
  "eth_sendUserOperation",
  "eth_estimateUserOperationGas"
];
function isBundlerRpcMethod(method) {
  return bundlerRpcMethods.includes(method);
}
function createBackendBundlerEIP1193(client, config) {
  const request = client.request ?? config?.requestOverride;
  const requestMemoizedChainId = (0, import_eip1193.requestWithMemoizedChainId)(request);
  const requestGetUserOperationByHash = config?.createRequestGetUserOperationByHash ? config?.createRequestGetUserOperationByHash(requestMemoizedChainId) : (0, import_requestGetUserOperationByHash.createRequestGetUserOperationByHash)(requestMemoizedChainId);
  const requestGetUserOperationReceipt = config?.createRequestGetUserOperationReceipt ? config.createRequestGetUserOperationReceipt(requestMemoizedChainId) : (0, import_requestGetUserOperationReceipt.createRequestGetUserOperationReceipt)(requestMemoizedChainId);
  const requestPublic = async function(args) {
    return (0, import_eip1193.requestPublicEIP1193)(requestMemoizedChainId, args);
  };
  const requestBundler = async function(args) {
    try {
      if (args.method === "eth_supportedEntryPoints") {
        return (0, import_utils.getAction)(client, import_actions.getSupportedEntryPoints, "getSupportedEntryPoints")({});
      } else if (args.method === "eth_getUserOperationByHash") {
        return requestGetUserOperationByHash(args);
      } else if (args.method === "eth_getUserOperationReceipt") {
        return requestGetUserOperationReceipt(args);
      } else if (args.method === "eth_estimateUserOperationGas") {
        const [userOperationHex, entryPoint] = args.params;
        const supportedEntryPoints = await (0, import_utils.getAction)(
          client,
          import_actions.getSupportedEntryPoints,
          "getSupportedEntryPoints"
        )({});
        if (entryPoint && !supportedEntryPoints.includes(entryPoint)) {
          throw new Error(`Unsupported entrypoint ${entryPoint}, expected one of ${supportedEntryPoints}`);
        }
        let maxFeePerGas;
        let maxPriorityFeePerGas;
        if (userOperationHex.maxFeePerGas) {
          maxFeePerGas = userOperationHex.maxFeePerGas;
          maxPriorityFeePerGas = userOperationHex.maxPriorityFeePerGas ?? userOperationHex.maxFeePerGas;
        } else {
          const gasPrice = await (0, import_utils.getAction)(client, import_actions.getUserOperationGasPrice, "getUserOperationGasPrice")({});
          maxFeePerGas = (0, import_viem.numberToHex)(gasPrice.standard.maxFeePerGas);
          maxPriorityFeePerGas = (0, import_viem.numberToHex)(gasPrice.standard.maxPriorityFeePerGas);
        }
        const userOperation = (0, import_UserOperation.decodeUserOp)({ ...userOperationHex, maxFeePerGas, maxPriorityFeePerGas });
        const {
          preVerificationGas,
          verificationGasLimit,
          callGasLimit,
          paymasterVerificationGasLimit,
          paymasterPostOpGasLimit
        } = await (0, import_utils.getAction)(client, import_actions.estimateUserOperationGas, "estimateUserOperationGas")(userOperation);
        const result = {
          preVerificationGas: (0, import_viem.numberToHex)(preVerificationGas),
          verificationGasLimit: (0, import_viem.numberToHex)(verificationGasLimit),
          callGasLimit: (0, import_viem.numberToHex)(callGasLimit)
        };
        if (paymasterVerificationGasLimit != void 0) {
          result.paymasterVerificationGasLimit = (0, import_viem.numberToHex)(paymasterVerificationGasLimit);
        }
        if (paymasterPostOpGasLimit != void 0) {
          result.paymasterPostOpGasLimit = (0, import_viem.numberToHex)(paymasterPostOpGasLimit);
        }
        return result;
      } else if (args.method === "eth_sendUserOperation") {
        const [userOperationHex, entryPoint] = args.params;
        const supportedEntryPoints = await (0, import_utils.getAction)(
          client,
          import_actions.getSupportedEntryPoints,
          "getSupportedEntryPoints"
        )({});
        if (entryPoint && !supportedEntryPoints.includes(entryPoint)) {
          throw new Error(`Unsupported entrypoint ${entryPoint}, expected one of ${supportedEntryPoints}`);
        }
        const userOperation = (0, import_UserOperation.decodeUserOp)(userOperationHex);
        const userOperationHash = await (0, import_utils.getAction)(
          client,
          import_actions.sendUserOperation,
          "sendUserOperation"
        )(userOperation);
        console.debug({ userOperationHash });
        return userOperationHash;
      } else {
        throw new import_viem.RpcRequestError({
          body: args,
          url: "",
          error: {
            code: -32601,
            message: "Method not found"
          }
        });
      }
    } catch (error) {
      if (error instanceof import_viem.RpcRequestError) {
        throw error;
      }
      if (error instanceof import_Errors.ExecutionError || error instanceof import_viem.ContractFunctionExecutionError) {
        throw new import_viem.RpcRequestError({
          body: { method: args.method },
          url: "",
          error: {
            code: -32603,
            message: error.message
          }
        });
      }
      console.error(error);
      return null;
    }
  };
  return (0, import_eip1193.concatRequests)([
    { request: requestBundler, isRpcMethod: isBundlerRpcMethod },
    {
      request: requestPublic,
      isRpcMethod: import_eip1193.isPublicRpcMethod
    }
  ]);
}