@arcenpay/node 0.0.1 → 0.0.2

package/dist/_esm-H6IRXC3A.mjs

@@ -0,0 +1,804 @@
+import {
+  DUMMY_ECDSA_SIG,
+  KERNEL_FEATURES,
+  KernelAccountAbi,
+  KernelFactoryStakerAbi,
+  KernelV3AccountAbi,
+  KernelV3InitAbi,
+  KernelV3_1AccountAbi,
+  KernelVersionToAddressesMap,
+  MAGIC_VALUE_SIG_REPLAYABLE,
+  VALIDATOR_MODE,
+  VALIDATOR_TYPE,
+  accountMetadata,
+  constants_exports,
+  createKernelAccountClient,
+  eip712WrapHash,
+  encodeCallData,
+  encodeCallData2,
+  encodeDeployCallData,
+  encodeDeployCallData2,
+  getAccountNonce,
+  getKernelImplementationAddress,
+  getPluginInstallCallData,
+  getSenderAddress,
+  hasKernelFeature,
+  isPluginInstalled,
+  satisfiesRange,
+  toKernelPluginManager,
+  toSigner,
+  validateKernelVersionWithEntryPoint
+} from "./chunk-XHLV6BIG.mjs";
+import "./chunk-E2J5KZ6E.mjs";
+
+// ../../node_modules/@zerodev/ecdsa-validator/_esm/getAddress.js
+import { concat, concatHex, encodeFunctionData, getContract, getContractAddress, isAddress, keccak256, toHex, zeroAddress as zeroAddress2 } from "viem";
+
+// ../../node_modules/@zerodev/ecdsa-validator/_esm/toECDSAValidatorPlugin.js
+import { zeroAddress } from "viem";
+import { getUserOperationHash } from "viem/account-abstraction";
+import { toAccount } from "viem/accounts";
+import { getChainId, signMessage } from "viem/actions";
+
+// ../../node_modules/@zerodev/ecdsa-validator/_esm/constants.js
+var kernelVersionRangeToValidator = {
+  "0.0.2 - 0.2.4": "0xd9AB5096a832b9ce79914329DAEE236f8Eea0390",
+  "0.3.0": "0x8104e3Ad430EA6d354d013A6789fDFc71E671c43",
+  ">=0.3.1": "0x845ADb2C711129d4f3966735eD98a9F09fC4cE57"
+};
+
+// ../../node_modules/@zerodev/ecdsa-validator/_esm/toECDSAValidatorPlugin.js
+var getValidatorAddress = (entryPoint, kernelVersion, validatorAddress) => {
+  validateKernelVersionWithEntryPoint(entryPoint.version, kernelVersion);
+  const ecdsaValidatorAddress = Object.entries(kernelVersionRangeToValidator).find(([range]) => satisfiesRange(kernelVersion, range))?.[1];
+  if (!ecdsaValidatorAddress && !validatorAddress) {
+    throw new Error(`Validator not found for Kernel version: ${kernelVersion}`);
+  }
+  return validatorAddress ?? ecdsaValidatorAddress ?? zeroAddress;
+};
+async function signerToEcdsaValidator(client, { signer, entryPoint, kernelVersion, validatorAddress: _validatorAddress }) {
+  const validatorAddress = getValidatorAddress(entryPoint, kernelVersion, _validatorAddress);
+  const viemSigner = await toSigner({ signer });
+  const chainId = await getChainId(client);
+  const account = toAccount({
+    address: viemSigner.address,
+    async signMessage({ message }) {
+      return signMessage(client, { account: viemSigner, message });
+    },
+    async signTransaction(_, __) {
+      throw new Error("Smart account signer doesn't need to sign transactions");
+    },
+    async signTypedData(typedData) {
+      return viemSigner.signTypedData(typedData);
+    }
+  });
+  return {
+    ...account,
+    supportedKernelVersions: kernelVersion,
+    validatorType: "SECONDARY",
+    address: validatorAddress,
+    source: "ECDSAValidator",
+    getIdentifier() {
+      return validatorAddress;
+    },
+    async getEnableData() {
+      return viemSigner.address;
+    },
+    async getNonceKey(_accountAddress, customNonceKey) {
+      if (customNonceKey) {
+        return customNonceKey;
+      }
+      return 0n;
+    },
+    // Sign a user operation
+    async signUserOperation(userOperation) {
+      const hash = getUserOperationHash({
+        userOperation: {
+          ...userOperation,
+          signature: "0x"
+        },
+        entryPointAddress: entryPoint.address,
+        entryPointVersion: entryPoint.version,
+        chainId
+      });
+      const signature = await signMessage(client, {
+        account: viemSigner,
+        message: { raw: hash }
+      });
+      return signature;
+    },
+    // Get simple dummy signature
+    async getStubSignature() {
+      return "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
+    },
+    async isEnabled(_kernelAccountAddress, _selector) {
+      return false;
+    }
+  };
+}
+
+// ../../node_modules/@zerodev/ecdsa-validator/_esm/getAddress.js
+var getInitCodeHash = async (publicClient, entryPoint, kernelVersion) => {
+  validateKernelVersionWithEntryPoint(entryPoint.version, kernelVersion);
+  const addresses = constants_exports.KernelVersionToAddressesMap[kernelVersion];
+  if (entryPoint.version === "0.6") {
+    return await initCodeHashV0_6(publicClient, addresses.factoryAddress);
+  }
+  return initCodeHashV0_7(addresses.accountImplementationAddress);
+};
+var initCodeHashV0_6 = async (publicClient, factoryAddress) => {
+  const factoryContract = getContract({
+    address: factoryAddress,
+    abi: [
+      {
+        type: "function",
+        name: "initCodeHash",
+        inputs: [],
+        outputs: [
+          {
+            name: "result",
+            type: "bytes32",
+            internalType: "bytes32"
+          }
+        ],
+        stateMutability: "view"
+      }
+    ],
+    client: publicClient
+  });
+  return await factoryContract.read.initCodeHash();
+};
+var initCodeHashV0_7 = (implementationAddress) => {
+  if (!isAddress(implementationAddress)) {
+    throw new Error("Invalid implementation address");
+  }
+  const initCode = concatHex([
+    "0x603d3d8160223d3973",
+    implementationAddress,
+    "0x6009",
+    "0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076",
+    "0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3"
+  ]);
+  const hash = keccak256(initCode);
+  return hash;
+};
+var generateSaltForV06 = (eoaAddress, index, validatorAddress) => {
+  const encodedIndex = toHex(index, { size: 32 });
+  const initData = encodeFunctionData({
+    abi: KernelAccountAbi,
+    functionName: "initialize",
+    args: [validatorAddress, eoaAddress]
+  });
+  const encodedSalt = concat([initData, encodedIndex]);
+  const salt = BigInt(keccak256(encodedSalt));
+  const mask = BigInt("0xffffffffffffffffffffffff");
+  const maskedSalt = toHex(salt & mask, { size: 32 });
+  return maskedSalt;
+};
+var generateSaltForV07 = (eoaAddress, index, hookAddress, hookData, validatorAddress, kernelVersion, initConfig) => {
+  const encodedIndex = toHex(index, { size: 32 });
+  let initData;
+  if (kernelVersion === "0.3.0") {
+    initData = encodeFunctionData({
+      abi: KernelV3InitAbi,
+      functionName: "initialize",
+      args: [
+        concatHex([
+          constants_exports.VALIDATOR_TYPE.SECONDARY,
+          validatorAddress
+        ]),
+        hookAddress,
+        eoaAddress,
+        hookData
+      ]
+    });
+    const packedData2 = concatHex([initData, encodedIndex]);
+    return keccak256(packedData2);
+  }
+  initData = encodeFunctionData({
+    abi: KernelV3_1AccountAbi,
+    functionName: "initialize",
+    args: [
+      concatHex([constants_exports.VALIDATOR_TYPE.SECONDARY, validatorAddress]),
+      hookAddress,
+      eoaAddress,
+      hookData,
+      initConfig
+    ]
+  });
+  const packedData = concatHex([initData, encodedIndex]);
+  return keccak256(packedData);
+};
+async function getKernelAddressFromECDSA(params) {
+  validateKernelVersionWithEntryPoint(params.entryPoint.version, params.kernelVersion);
+  const kernelAddresses = constants_exports.KernelVersionToAddressesMap[params.kernelVersion];
+  const ecdsaValidatorAddress = getValidatorAddress(params.entryPoint, params.kernelVersion);
+  const bytecodeHash = await (async () => {
+    if ("initCodeHash" in params && params.initCodeHash) {
+      return params.initCodeHash;
+    }
+    if ("publicClient" in params && params.publicClient) {
+      return await getInitCodeHash(params.publicClient, params.entryPoint, params.kernelVersion);
+    }
+    throw new Error("Either initCodeHash or publicClient must be provided");
+  })();
+  let salt;
+  if (params.entryPoint.version === "0.6") {
+    salt = generateSaltForV06(params.eoaAddress, params.index, ecdsaValidatorAddress);
+  } else {
+    const hookAddress = "hookAddress" in params && params.hookAddress ? params.hookAddress : zeroAddress2;
+    const hookData = "hookData" in params && params.hookData ? params.hookData : "0x";
+    const initConfig = "initConfig" in params && params.initConfig ? params.initConfig : [];
+    salt = generateSaltForV07(params.eoaAddress, params.index, hookAddress, hookData, ecdsaValidatorAddress, params.kernelVersion, initConfig);
+  }
+  return getContractAddress({
+    bytecodeHash,
+    opcode: "CREATE2",
+    from: kernelAddresses.factoryAddress,
+    salt
+  });
+}
+
+// ../../node_modules/@zerodev/ecdsa-validator/_esm/account/createEcdsaKernelMigrationAccount.js
+import { concatHex as concatHex2, createNonceManager, encodeFunctionData as encodeFunctionData2, getTypesForEIP712Domain, hashMessage, hashTypedData, isAddressEqual, maxUint16, pad, toHex as toHex2, validateTypedData, zeroAddress as zeroAddress3 } from "viem";
+import { entryPoint06Abi, entryPoint07Abi, entryPoint07Address, getUserOperationHash as getUserOperationHash2, toSmartAccount } from "viem/account-abstraction";
+import { getChainId as getChainId2, signMessage as signMessage2 } from "viem/actions";
+import { getAction } from "viem/utils";
+var getKernelInitData = ({ entryPointVersion: _entryPointVersion, kernelVersion, validatorAddress, validatorData }) => {
+  const validatorId = concatHex2([VALIDATOR_TYPE.SECONDARY, validatorAddress]);
+  if (kernelVersion === "0.3.0") {
+    return encodeFunctionData2({
+      abi: KernelV3InitAbi,
+      functionName: "initialize",
+      args: [validatorId, zeroAddress3, validatorData, "0x"]
+    });
+  }
+  return encodeFunctionData2({
+    abi: KernelV3_1AccountAbi,
+    functionName: "initialize",
+    args: [validatorId, zeroAddress3, validatorData, "0x", []]
+  });
+};
+var getAccountInitCode = async ({ entryPointVersion, kernelVersion, validatorData, index, factoryAddress, validatorAddress }) => {
+  const initializationData = getKernelInitData({
+    entryPointVersion,
+    kernelVersion,
+    validatorAddress,
+    validatorData
+  });
+  return encodeFunctionData2({
+    abi: KernelFactoryStakerAbi,
+    functionName: "deployWithFactory",
+    args: [factoryAddress, initializationData, toHex2(index, { size: 32 })]
+  });
+};
+var isKernelUpgraded = async (client, accountAddress, toKernelVersion) => {
+  const kernelImplementation = await getKernelImplementationAddress(client, {
+    address: accountAddress
+  });
+  return isAddressEqual(kernelImplementation, KernelVersionToAddressesMap[toKernelVersion].accountImplementationAddress);
+};
+async function createEcdsaKernelMigrationAccount(client, { entryPoint, signer, index = 0n, address, migrationVersion, pluginMigrations }) {
+  if (entryPoint.version === "0.6") {
+    throw new Error("EntryPointV0.6 is not supported for migration");
+  }
+  validateKernelVersionWithEntryPoint(entryPoint.version, migrationVersion.from);
+  validateKernelVersionWithEntryPoint(entryPoint.version, migrationVersion.to);
+  const fromAddresses = KernelVersionToAddressesMap[migrationVersion.from];
+  const fromValidatorAddress = getValidatorAddress(entryPoint, migrationVersion.from);
+  const toValidatorAddress = getValidatorAddress(entryPoint, migrationVersion.to);
+  const viemSigner = await toSigner({ signer });
+  let chainId;
+  const getMemoizedChainId = async () => {
+    if (chainId)
+      return chainId;
+    chainId = client.chain ? client.chain.id : await getAction(client, getChainId2, "getChainId")({});
+    return chainId;
+  };
+  const generateInitCode = async () => {
+    return getAccountInitCode({
+      entryPointVersion: entryPoint.version,
+      factoryAddress: fromAddresses.factoryAddress,
+      index,
+      kernelVersion: migrationVersion.from,
+      validatorAddress: fromValidatorAddress,
+      validatorData: viemSigner.address
+    });
+  };
+  const getFactoryArgs = async () => {
+    return {
+      factory: fromAddresses.metaFactoryAddress ?? zeroAddress3,
+      factoryData: await generateInitCode()
+    };
+  };
+  let accountAddress = address ?? await (async () => {
+    const { factory, factoryData } = await getFactoryArgs();
+    return await getSenderAddress(client, {
+      factory,
+      factoryData,
+      entryPointAddress: entryPoint.address
+    });
+  })();
+  let kernelUpgraded = await isKernelUpgraded(client, accountAddress, migrationVersion.to);
+  const pluginCache = {
+    pendingPlugins: pluginMigrations || [],
+    allInstalled: false
+  };
+  const checkPluginInstallationStatus = async () => {
+    if (!pluginCache.pendingPlugins.length || pluginCache.allInstalled) {
+      pluginCache.allInstalled = true;
+      return;
+    }
+    const installationResults = await Promise.all(pluginCache.pendingPlugins.map((plugin) => isPluginInstalled(client, {
+      address: accountAddress,
+      plugin
+    })));
+    pluginCache.pendingPlugins = pluginCache.pendingPlugins.filter((_, index2) => !installationResults[index2]);
+    pluginCache.allInstalled = pluginCache.pendingPlugins.length === 0;
+  };
+  await checkPluginInstallationStatus();
+  const _entryPoint = {
+    address: entryPoint?.address ?? entryPoint07Address,
+    abi: (entryPoint?.version ?? "0.7") === "0.6" ? entryPoint06Abi : entryPoint07Abi,
+    version: entryPoint?.version ?? "0.7"
+  };
+  return toSmartAccount({
+    kernelVersion: migrationVersion.to,
+    kernelPluginManager: await toKernelPluginManager(client, {
+      entryPoint,
+      kernelVersion: migrationVersion.to,
+      chainId: await getMemoizedChainId(),
+      sudo: await signerToEcdsaValidator(client, {
+        entryPoint,
+        signer: viemSigner,
+        kernelVersion: migrationVersion.to,
+        validatorAddress: toValidatorAddress
+      })
+    }),
+    factoryAddress: (await getFactoryArgs()).factory,
+    generateInitCode,
+    accountImplementationAddress: KernelVersionToAddressesMap[migrationVersion.to].accountImplementationAddress,
+    encodeModuleInstallCallData: async () => {
+      throw new Error("Not implemented");
+    },
+    nonceKeyManager: createNonceManager({
+      source: { get: () => 0, set: () => {
+      } }
+    }),
+    client,
+    entryPoint: _entryPoint,
+    getFactoryArgs,
+    async getAddress() {
+      if (accountAddress)
+        return accountAddress;
+      const { factory, factoryData } = await getFactoryArgs();
+      accountAddress = await getSenderAddress(client, {
+        factory,
+        factoryData,
+        entryPointAddress: entryPoint.address
+      });
+      return accountAddress;
+    },
+    // Encode the deploy call data
+    async encodeDeployCallData(_tx) {
+      throw new Error("Not implemented");
+    },
+    async encodeCalls(calls, callType) {
+      await checkPluginInstallationStatus();
+      const pluginInstallCalls = [];
+      if (pluginCache.pendingPlugins.length > 0 && entryPoint.version === "0.7") {
+        for (const plugin of pluginCache.pendingPlugins) {
+          pluginInstallCalls.push(getPluginInstallCallData(accountAddress, plugin));
+        }
+      }
+      kernelUpgraded = kernelUpgraded || await isKernelUpgraded(client, accountAddress, migrationVersion.to);
+      let _calls = calls;
+      if (!kernelUpgraded) {
+        const implementation = KernelVersionToAddressesMap[migrationVersion.to].accountImplementationAddress;
+        const upgradeCall = {
+          to: accountAddress,
+          data: encodeFunctionData2({
+            abi: KernelV3AccountAbi,
+            functionName: "upgradeTo",
+            args: [implementation]
+          }),
+          value: 0n
+        };
+        if (!isAddressEqual(fromValidatorAddress, toValidatorAddress)) {
+          const rootValidatorId = concatHex2([
+            VALIDATOR_TYPE.SECONDARY,
+            pad(toValidatorAddress, {
+              size: 20,
+              dir: "right"
+            })
+          ]);
+          const updateValidatorCall = {
+            to: accountAddress,
+            data: encodeFunctionData2({
+              abi: KernelV3_1AccountAbi,
+              functionName: "changeRootValidator",
+              args: [
+                rootValidatorId,
+                zeroAddress3,
+                viemSigner.address,
+                "0x"
+              ]
+            }),
+            value: 0n
+          };
+          _calls = [
+            upgradeCall,
+            updateValidatorCall,
+            ...pluginInstallCalls,
+            ...calls
+          ];
+        }
+        _calls = [upgradeCall, ...pluginInstallCalls, ...calls];
+      } else {
+        _calls = [...pluginInstallCalls, ...calls];
+      }
+      return encodeCallData2(_calls, callType);
+    },
+    async sign({ hash }) {
+      return this.signMessage({ message: hash });
+    },
+    async signMessage({ message, useReplayableSignature }) {
+      kernelUpgraded = kernelUpgraded || await isKernelUpgraded(client, accountAddress, migrationVersion.to);
+      const messageHash = hashMessage(message);
+      const version_ = kernelUpgraded ? migrationVersion.to : migrationVersion.from;
+      const version = version_ === "0.3.0" ? "0.3.0-beta" : version_;
+      const wrappedMessageHash = await eip712WrapHash(messageHash, {
+        name: "Kernel",
+        chainId,
+        version,
+        verifyingContract: accountAddress
+      }, useReplayableSignature);
+      let signature = await viemSigner.signMessage({
+        message: { raw: wrappedMessageHash }
+      });
+      if (!hasKernelFeature(KERNEL_FEATURES.ERC1271_WITH_VALIDATOR, version)) {
+        return signature;
+      }
+      if (useReplayableSignature && hasKernelFeature(KERNEL_FEATURES.ERC1271_REPLAYABLE, version)) {
+        signature = concatHex2([MAGIC_VALUE_SIG_REPLAYABLE, signature]);
+      }
+      return concatHex2([VALIDATOR_TYPE.SUDO, signature]);
+    },
+    async signTypedData(typedData) {
+      const { message, primaryType, types: _types, domain } = typedData;
+      const types = {
+        EIP712Domain: getTypesForEIP712Domain({
+          domain
+        }),
+        ..._types
+      };
+      validateTypedData({
+        domain,
+        message,
+        primaryType,
+        types
+      });
+      const typedHash = hashTypedData(typedData);
+      kernelUpgraded = kernelUpgraded || await isKernelUpgraded(client, accountAddress, migrationVersion.to);
+      const version_ = kernelUpgraded ? migrationVersion.to : migrationVersion.from;
+      const version = version_ === "0.3.0" ? "0.3.0-beta" : version_;
+      const wrappedMessageHash = await eip712WrapHash(typedHash, {
+        name: "Kernel",
+        chainId,
+        version,
+        verifyingContract: accountAddress
+      });
+      const signature = await viemSigner.signMessage({
+        message: { raw: wrappedMessageHash }
+      });
+      if (!hasKernelFeature(KERNEL_FEATURES.ERC1271_WITH_VALIDATOR, version)) {
+        return signature;
+      }
+      return concatHex2([VALIDATOR_TYPE.SUDO, signature]);
+    },
+    // Get the nonce of the smart account
+    async getNonce(_args) {
+      const key = getNonceKeyWithEncoding(fromValidatorAddress, _args?.key);
+      return getAccountNonce(client, {
+        address: accountAddress,
+        entryPointAddress: entryPoint.address,
+        key
+      });
+    },
+    async getStubSignature() {
+      return DUMMY_ECDSA_SIG;
+    },
+    // Sign a user operation
+    async signUserOperation(parameters) {
+      const { chainId: chainId2 = await getMemoizedChainId(), ...userOperation } = parameters;
+      const hash = getUserOperationHash2({
+        userOperation: {
+          ...userOperation,
+          sender: userOperation.sender ?? accountAddress,
+          signature: "0x"
+        },
+        entryPointAddress: entryPoint.address,
+        entryPointVersion: entryPoint.version,
+        chainId: chainId2
+      });
+      const signature = await signMessage2(client, {
+        account: viemSigner,
+        message: { raw: hash }
+      });
+      return signature;
+    }
+  });
+}
+var getNonceKeyWithEncoding = (validatorAddress, nonceKey = 0n) => {
+  if (nonceKey > maxUint16)
+    throw new Error("nonce key must be equal or less than 2 bytes(maxUint16) for Kernel version v0.7");
+  const validatorMode = VALIDATOR_MODE.DEFAULT;
+  const validatorType = VALIDATOR_TYPE.SUDO;
+  const encoding = pad(concatHex2([
+    validatorMode,
+    // 1 byte
+    validatorType,
+    // 1 byte
+    validatorAddress,
+    // 20 bytes
+    toHex2(nonceKey, { size: 2 })
+    // 2 byte
+  ]), { size: 24 });
+  return BigInt(encoding);
+};
+
+// ../../node_modules/@zerodev/ecdsa-validator/_esm/clients/kernel7702AccountClient.js
+import { prepareUserOperation as viemPrepareUserOperation } from "viem/account-abstraction";
+function create7702KernelAccountClient(parameters) {
+  return createKernelAccountClient({
+    ...parameters,
+    account: parameters.account,
+    userOperation: {
+      ...parameters.userOperation,
+      prepareUserOperation: async (opClient, opArgs) => {
+        const authorization = opArgs.authorization || await parameters.account.signAuthorization();
+        const finalArgs = {
+          ...opArgs,
+          authorization
+        };
+        return await viemPrepareUserOperation(opClient, finalArgs);
+      }
+    }
+  });
+}
+
+// ../../node_modules/@zerodev/ecdsa-validator/_esm/account/create7702KernelAccount.js
+import { concatHex as concatHex3, createNonceManager as createNonceManager2, getTypesForEIP712Domain as getTypesForEIP712Domain2, hashMessage as hashMessage2, hashTypedData as hashTypedData2, isAddressEqual as isAddressEqual2, validateTypedData as validateTypedData2, zeroAddress as zeroAddress4 } from "viem";
+import { entryPoint06Abi as entryPoint06Abi2, entryPoint07Abi as entryPoint07Abi2, entryPoint07Address as entryPoint07Address2, toSmartAccount as toSmartAccount2 } from "viem/account-abstraction";
+import { getChainId as getChainId3, getCode, signAuthorization as signAuthorizationAction } from "viem/actions";
+import { getAction as getAction2, verifyAuthorization } from "viem/utils";
+var getDefaultAddresses = (entryPointVersion, kernelVersion, { accountImplementationAddress, factoryAddress, metaFactoryAddress }) => {
+  validateKernelVersionWithEntryPoint(entryPointVersion, kernelVersion);
+  const addresses = KernelVersionToAddressesMap[kernelVersion];
+  if (!addresses) {
+    throw new Error(`No addresses found for kernel version ${kernelVersion}`);
+  }
+  return {
+    accountImplementationAddress: accountImplementationAddress ?? addresses.accountImplementationAddress,
+    factoryAddress: factoryAddress ?? addresses.factoryAddress,
+    metaFactoryAddress: metaFactoryAddress ?? addresses.metaFactoryAddress ?? zeroAddress4
+  };
+};
+async function create7702KernelAccount(client, { signer, plugins, entryPoint, accountImplementationAddress: _accountImplementationAddress, kernelVersion, pluginMigrations, eip7702Auth }) {
+  const { accountImplementationAddress } = getDefaultAddresses(entryPoint.version, kernelVersion, {
+    accountImplementationAddress: _accountImplementationAddress,
+    factoryAddress: void 0,
+    metaFactoryAddress: void 0
+  });
+  let chainId;
+  let address;
+  if (typeof signer === "object" && signer !== null && "account" in signer) {
+    address = signer.account?.address;
+  }
+  const localAccount = await toSigner({ signer, address });
+  const accountAddress = localAccount.address;
+  const getMemoizedChainId = async () => {
+    if (chainId)
+      return chainId;
+    chainId = client.chain ? client.chain.id : await getAction2(client, getChainId3, "getChainId")({});
+    return chainId;
+  };
+  const kernelPluginManager = await toKernelPluginManager(client, {
+    sudo: await signerToEcdsaValidator(client, {
+      signer: localAccount,
+      entryPoint,
+      kernelVersion
+    }),
+    entryPoint,
+    kernelVersion,
+    chainId: await getMemoizedChainId()
+  });
+  const generateInitCode = async () => {
+    return "0x";
+  };
+  const getFactoryArgs = async () => {
+    return {
+      factory: void 0,
+      factoryData: void 0
+    };
+  };
+  const signAuthorization = async () => {
+    const code = await getCode(client, { address: accountAddress });
+    if (!code || code.length === 0 || !code.toLowerCase().startsWith(`0xef0100${accountImplementationAddress.slice(2).toLowerCase()}`)) {
+      if (eip7702Auth && !isAddressEqual2(eip7702Auth.address, accountImplementationAddress)) {
+        throw new Error("EIP-7702 authorization delegate address does not match account implementation address");
+      }
+      const auth = eip7702Auth ?? await signAuthorizationAction(client, {
+        account: localAccount,
+        address: accountImplementationAddress,
+        chainId: await getMemoizedChainId()
+      });
+      const verified = await verifyAuthorization({
+        authorization: auth,
+        address: accountAddress
+      });
+      if (!verified) {
+        throw new Error("Authorization verification failed");
+      }
+      return auth;
+    }
+    return void 0;
+  };
+  const _entryPoint = {
+    address: entryPoint?.address ?? entryPoint07Address2,
+    abi: (entryPoint?.version ?? "0.7") === "0.6" ? entryPoint06Abi2 : entryPoint07Abi2,
+    version: entryPoint?.version ?? "0.7"
+  };
+  const pluginCache = {
+    pendingPlugins: pluginMigrations || [],
+    allInstalled: false
+  };
+  const checkPluginInstallationStatus = async () => {
+    if (!pluginCache.pendingPlugins.length || pluginCache.allInstalled) {
+      pluginCache.allInstalled = true;
+      return;
+    }
+    const installationResults = await Promise.all(pluginCache.pendingPlugins.map((plugin) => isPluginInstalled(client, {
+      address: accountAddress,
+      plugin
+    })));
+    pluginCache.pendingPlugins = pluginCache.pendingPlugins.filter((_, index) => !installationResults[index]);
+    pluginCache.allInstalled = pluginCache.pendingPlugins.length === 0;
+  };
+  await checkPluginInstallationStatus();
+  return toSmartAccount2({
+    kernelVersion,
+    kernelPluginManager,
+    accountImplementationAddress,
+    factoryAddress: void 0,
+    generateInitCode,
+    encodeModuleInstallCallData: async () => {
+      return await kernelPluginManager.encodeModuleInstallCallData(accountAddress);
+    },
+    nonceKeyManager: createNonceManager2({
+      source: { get: () => 0, set: () => {
+      } }
+    }),
+    client,
+    entryPoint: _entryPoint,
+    getFactoryArgs,
+    async getAddress() {
+      return accountAddress;
+    },
+    signAuthorization,
+    // Encode the deploy call data
+    async encodeDeployCallData(_tx) {
+      if (entryPoint.version === "0.6") {
+        return encodeDeployCallData(_tx);
+      }
+      return encodeDeployCallData2(_tx);
+    },
+    async encodeCalls(calls, callType) {
+      await checkPluginInstallationStatus();
+      if (pluginCache.pendingPlugins.length > 0 && entryPoint.version === "0.7" && kernelPluginManager.activeValidatorMode === "sudo") {
+        const pluginInstallCalls = [];
+        for (const plugin of pluginCache.pendingPlugins) {
+          pluginInstallCalls.push(getPluginInstallCallData(accountAddress, plugin));
+        }
+        return encodeCallData2([...calls, ...pluginInstallCalls], callType, plugins?.hook ? true : void 0);
+      }
+      if (calls.length === 1 && (!callType || callType === "call") && calls[0].to.toLowerCase() === accountAddress.toLowerCase()) {
+        return calls[0].data ?? "0x";
+      }
+      if (entryPoint.version === "0.6") {
+        return encodeCallData(calls, callType);
+      }
+      if (plugins?.hook) {
+        return encodeCallData2(calls, callType, true);
+      }
+      return encodeCallData2(calls, callType);
+    },
+    async sign({ hash }) {
+      return this.signMessage({ message: hash });
+    },
+    async signMessage({ message, useReplayableSignature }) {
+      const messageHash = hashMessage2(message);
+      const { name, chainId: metadataChainId, version } = await accountMetadata(client, accountAddress, kernelVersion, chainId);
+      const wrappedMessageHash = await eip712WrapHash(messageHash, {
+        name,
+        chainId: Number(metadataChainId),
+        version,
+        verifyingContract: accountAddress
+      }, useReplayableSignature);
+      let signature = await kernelPluginManager.signMessage({
+        message: { raw: wrappedMessageHash }
+      });
+      if (!hasKernelFeature(KERNEL_FEATURES.ERC1271_WITH_VALIDATOR, version)) {
+        return signature;
+      }
+      if (useReplayableSignature && hasKernelFeature(KERNEL_FEATURES.ERC1271_REPLAYABLE, version)) {
+        signature = concatHex3([MAGIC_VALUE_SIG_REPLAYABLE, signature]);
+      }
+      return concatHex3([kernelPluginManager.getIdentifier(), signature]);
+    },
+    async signTypedData(typedData) {
+      const { message, primaryType, types: _types, domain } = typedData;
+      const types = {
+        EIP712Domain: getTypesForEIP712Domain2({
+          domain
+        }),
+        ..._types
+      };
+      validateTypedData2({
+        domain,
+        message,
+        primaryType,
+        types
+      });
+      const typedHash = hashTypedData2(typedData);
+      const { name, chainId: metadataChainId, version } = await accountMetadata(client, accountAddress, kernelVersion, chainId);
+      const wrappedMessageHash = await eip712WrapHash(typedHash, {
+        name,
+        chainId: Number(metadataChainId),
+        version,
+        verifyingContract: accountAddress
+      });
+      const signature = await kernelPluginManager.signMessage({
+        message: { raw: wrappedMessageHash }
+      });
+      if (!hasKernelFeature(KERNEL_FEATURES.ERC1271_WITH_VALIDATOR, version)) {
+        return signature;
+      }
+      return concatHex3([kernelPluginManager.getIdentifier(), signature]);
+    },
+    // Get the nonce of the smart account
+    async getNonce(_args) {
+      const key = await kernelPluginManager.getNonceKey(accountAddress, _args?.key);
+      return getAccountNonce(client, {
+        address: accountAddress,
+        entryPointAddress: entryPoint.address,
+        key
+      });
+    },
+    async getStubSignature(userOperation) {
+      if (!userOperation) {
+        throw new Error("No user operation provided");
+      }
+      return kernelPluginManager.getStubSignature(userOperation);
+    },
+    // Sign a user operation
+    async signUserOperation(parameters) {
+      const { chainId: chainId2 = await getMemoizedChainId(), ...userOperation } = parameters;
+      return kernelPluginManager.signUserOperation({
+        ...userOperation,
+        sender: userOperation.sender ?? await this.getAddress(),
+        chainId: chainId2
+        //authorization
+      });
+    }
+  });
+}
+export {
+  create7702KernelAccount,
+  create7702KernelAccountClient,
+  createEcdsaKernelMigrationAccount,
+  getKernelAddressFromECDSA,
+  getValidatorAddress,
+  kernelVersionRangeToValidator,
+  signerToEcdsaValidator
+};