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

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

var import_vitest = require("vitest");
var import_viem = require("viem");
var import_chains = require("viem/chains");
var import_account_abstraction = require("viem/account-abstraction");
var import_viem_utils = require("@owlprotocol/viem-utils");
var import_accounts = require("viem/accounts");
var import_accounts2 = require("permissionless/accounts");
var import_clients = require("permissionless/clients");
var import_eip1193 = require("@owlprotocol/backend-public/eip1193");
var import_createBundlerEIP1193 = require("./createBundlerEIP1193.js");
var import_createBackendBundler = require("../clients/createBackendBundler.js");
var import_constants = require("../test/constants.js");
var import_SimpleAccount = require("../SimpleAccount.js");
var import_ERC1967Proxy = require("../artifacts/ERC1967Proxy.js");
var import_MyContract = require("../artifacts/MyContract.js");
var import_setupERC4337Contracts = require("../setupERC4337Contracts.js");
(0, import_vitest.describe)("eip1993/createBundlerEIP1193.test.ts", function() {
  const chain = {
    ...import_chains.localhost,
    rpcUrls: {
      default: {
        http: [`http://127.0.0.1:${import_constants.port}`]
      }
    }
  };
  const transport = (0, import_viem.http)(chain.rpcUrls.default.http[0]);
  const publicClient = (0, import_viem.createPublicClient)({
    chain,
    transport
  });
  const walletClient = (0, import_viem.createWalletClient)({
    account: (0, import_viem_utils.getLocalAccount)(0, { nonceManager: import_viem.nonceManager }),
    chain,
    transport
  });
  const entryPointAddress = import_setupERC4337Contracts.erc4337Contracts.entrypoint;
  const entryPointSimulationsAddress = import_setupERC4337Contracts.erc4337Contracts.pimlicoEntrypointSimulations;
  const factoryAddress = import_setupERC4337Contracts.erc4337Contracts.simpleAccountFactory;
  let bundlerRequest;
  let bundlerTransport;
  let bundlerClient;
  (0, import_vitest.beforeAll)(async () => {
    const requestOverride = (0, import_eip1193.createPublicEIP1193)((0, import_eip1193.createHttpEIP1193)(`http://127.0.0.1:${import_constants.port}`));
    bundlerRequest = (0, import_createBundlerEIP1193.createBackendBundlerEIP1193)(
      (0, import_createBackendBundler.createBackendBundler)({
        account: (0, import_viem_utils.getLocalAccount)(0),
        chain: import_chains.localhost,
        transport,
        entryPointSimulationsAddress
      }),
      //viem middleware bypass
      { requestOverride }
    );
    bundlerTransport = (0, import_viem.custom)({
      request: bundlerRequest,
      config: { retryCount: 0 }
    });
    bundlerClient = (0, import_account_abstraction.createBundlerClient)({ transport: bundlerTransport });
  });
  (0, import_vitest.describe)("bundlerClient", () => {
    (0, import_vitest.test)("eth_getUserOperationByHash", async () => {
      const result = await bundlerClient.request({ method: "eth_getUserOperationByHash", params: [import_viem.zeroHash] });
      (0, import_vitest.expect)(result).toBeNull();
    });
    (0, import_vitest.test)("eth_getUserOperationReceipt", async () => {
      const result = await bundlerClient.request({ method: "eth_getUserOperationReceipt", params: [import_viem.zeroHash] });
      (0, import_vitest.expect)(result).toBeNull();
    });
  });
  (0, import_vitest.describe)("smartAccountClient", () => {
    let owner;
    let smartAccount;
    let smartAccountClient;
    let contractAddressExpected;
    let contractDeployTransaction;
    (0, import_vitest.beforeEach)(async () => {
      owner = (0, import_accounts.privateKeyToAccount)((0, import_accounts.generatePrivateKey)());
      const smartAccountAddress = (0, import_SimpleAccount.getSimpleAccountAddress)(
        {
          owner: owner.address,
          salt: 0n
        },
        {
          factoryAddress,
          proxyBytecode: import_ERC1967Proxy.ERC1967Proxy.bytecode
        }
      );
      smartAccount = await (0, import_accounts2.toSimpleSmartAccount)({
        address: smartAccountAddress,
        client: publicClient,
        owner,
        factoryAddress,
        entryPoint: {
          address: entryPointAddress,
          version: "0.7"
        }
      });
      smartAccountClient = (0, import_clients.createSmartAccountClient)({
        account: smartAccount,
        chain: publicClient.chain,
        bundlerTransport
      });
      const deployParams = {
        // "random" salt
        salt: (0, import_viem.padHex)(owner.address, { size: 32 }),
        bytecode: import_MyContract.MyContract.bytecode
      };
      contractDeployTransaction = (0, import_viem_utils.getDeployDeterministicFunctionData)(deployParams);
      contractAddressExpected = (0, import_viem_utils.getDeployDeterministicAddress)(deployParams);
      const fundSimpleAccountHash = await walletClient.sendTransaction({
        to: smartAccount.address,
        value: (0, import_viem.parseEther)("5")
      });
      await publicClient.waitForTransactionReceipt({ hash: fundSimpleAccountHash });
    });
    (0, import_vitest.test)("smartAccountClient.sendTransaction", async () => {
      const hash = await smartAccountClient.sendTransaction(contractDeployTransaction);
      const receipt = await publicClient.waitForTransactionReceipt({ hash });
      (0, import_vitest.expect)(receipt).toBeDefined();
      const contractBytecode = await publicClient.getCode({ address: contractAddressExpected });
      (0, import_vitest.expect)(contractBytecode).toBeDefined();
    });
    (0, import_vitest.test)("smartAccountClient.prepareUserOperation", async () => {
      const userOperation = await smartAccountClient.prepareUserOperation({
        calls: [contractDeployTransaction]
      });
      userOperation.signature = await smartAccount.signUserOperation(userOperation);
      const userOpHash = await bundlerClient.sendUserOperation(userOperation);
      const userOpReceipt = await (0, import_account_abstraction.waitForUserOperationReceipt)(bundlerClient, { hash: userOpHash });
      (0, import_vitest.expect)(userOpReceipt).toBeDefined();
      const contractBytecode = await publicClient.getCode({ address: contractAddressExpected });
      (0, import_vitest.expect)(contractBytecode).toBeDefined();
    });
  });
});