@alchemy/smart-accounts 0.0.0-alpha.9 → 5.0.0-beta.2

package/src/ma-v1/predictAddress.ts

@@ -1,13 +1,19 @@
 import {
   type Address,
-  getContractAddress,
+  type Client,
+  concatHex,
+  decodeFunctionData,
   encodeAbiParameters,
+  getContractAddress,
+  isAddressEqual,
   keccak256,
-  concatHex,
   type Hex,
 } from "viem";
+import type { EntryPointVersion } from "viem/account-abstraction";
 import { DefaultMaV1Address } from "./account.js";
+import { MultiOwnerModularAccountFactoryAbi } from "./abis/MultiOwnerModularAccountFactory.js";
 import { BaseError } from "@alchemy/common";
+import { getSenderFromFactoryData } from "../utils.js";
 
 export type PredictMultiOwnerModularAccountV1AddressParams = {
   salt: bigint;
@@ -46,7 +52,7 @@ export const predictMultiOwnerModularAccountV1Address = ({
     throw new BaseError("Owners array cannot be empty");
   }
   if (ownerAddresses.length > 100) {
-    throw new Error("Maximum 100 owners on creation");
+    throw new BaseError("Maximum 100 owners on creation");
   }
 
   const combinedSalt = getCombinedSalt(salt, ownerAddresses);
@@ -83,3 +89,54 @@ function getERC1967ProxyInitCodeHash(implementationAddress: Address): Hex {
 
   return keccak256(concatHex([ERC1967_PROXY_BYTECODE, constructorArgs]));
 }
+
+export type GetMultiOwnerModularAccountV1AddressFromFactoryDataParams = {
+  client: Client;
+  factoryAddress: Address;
+  factoryData: Hex;
+  entryPoint: {
+    version: EntryPointVersion;
+    address: Address;
+  };
+};
+
+/**
+ * Gets the multi-owner modular account v1 address from factory data.
+ * If the factory is a known default, decodes the args and predicts without RPC.
+ * Otherwise falls back to calling the entry point's getSenderAddress.
+ *
+ * @param {GetMultiOwnerModularAccountV1AddressFromFactoryDataParams} params - The parameters
+ * @returns {Promise<Address>} The account address
+ */
+export async function getMultiOwnerModularAccountV1AddressFromFactoryData({
+  client,
+  factoryAddress,
+  factoryData,
+  entryPoint,
+}: GetMultiOwnerModularAccountV1AddressFromFactoryDataParams): Promise<Address> {
+  if (
+    isAddressEqual(factoryAddress, DefaultMaV1Address.MULTI_OWNER_MAV1_FACTORY)
+  ) {
+    try {
+      const decoded = decodeFunctionData({
+        abi: MultiOwnerModularAccountFactoryAbi,
+        data: factoryData,
+      });
+      if (decoded.functionName === "createAccount") {
+        const [decodedSalt, decodedOwners] = decoded.args;
+        return predictMultiOwnerModularAccountV1Address({
+          factoryAddress,
+          salt: decodedSalt,
+          ownerAddresses: [...decodedOwners],
+        });
+      }
+    } catch {
+      // Decode failed, fall through to RPC
+    }
+  }
+  return getSenderFromFactoryData(client, {
+    factory: factoryAddress,
+    factoryData,
+    entryPoint,
+  });
+}

package/src/ma-v2/accounts/account.ts

@@ -9,16 +9,17 @@ import {
   type PrivateKeyAccount,
   type Transport,
 } from "viem";
-import type {
-  WebAuthnAccount,
-  ToSmartAccountParameters,
+import {
+  type ToSmartAccountParameters,
+  entryPoint07Address,
 } from "viem/account-abstraction";
 import { toModularAccountV2Base, type ModularAccountV2Base } from "./base.js";
 import type { SignerEntity } from "../types.js";
-import { predictModularAccountV2Address } from "../predictAddress.js";
-import { parsePublicKey } from "webauthn-p256";
+import {
+  getModularAccountV2AddressFromFactoryData,
+  predictModularAccountV2Address,
+} from "../predictAddress.js";
 import { accountFactoryAbi } from "../abis/accountFactoryAbi.js";
-import { webAuthnFactoryAbi } from "../abis/webAuthnFactoryAbi.js";
 import { EntityIdOverrideError } from "../../errors/EntityIdOverrideError.js";
 import { InvalidOwnerError } from "../../errors/InvalidOwnerError.js";
 import { DEFAULT_OWNER_ENTITY_ID, DefaultAddress } from "../utils/account.js";
@@ -33,7 +34,7 @@ export type ToModularAccountV2Params<
   TMode extends Mode | undefined = Mode | undefined,
 > = {
   client: Client<Transport, Chain, JsonRpcAccount | LocalAccount | undefined>;
-  owner: JsonRpcAccount | LocalAccount | WebAuthnAccount;
+  owner: JsonRpcAccount | LocalAccount;
   deferredAction?: Hex;
   signerEntity?: SignerEntity;
   accountAddress?: Address;
@@ -46,11 +47,18 @@ export type ToModularAccountV2Params<
       implementationAddress?: never;
     }
   : {
-      salt?: bigint;
       factory?: Address;
-      factoryData?: Hex;
       implementationAddress?: Address;
-    });
+    } & (
+      | {
+          salt?: bigint;
+          factoryData?: never;
+        }
+      | {
+          salt?: never;
+          factoryData?: Hex;
+        }
+    ));
 
 /**
  * Creates a MAv2 account.
@@ -81,19 +89,11 @@ export async function toModularAccountV2<TMode extends Mode = Mode>({
 
   const entityId = signerEntity?.entityId ?? DEFAULT_OWNER_ENTITY_ID;
 
-  const factoryAddress =
-    factory ??
-    (owner.type === "webAuthn"
-      ? DefaultAddress.MAV2_FACTORY_WEBAUTHN
-      : DefaultAddress.MAV2_FACTORY);
+  const factoryAddress = factory ?? DefaultAddress.MAV2_FACTORY;
 
   const implementationAddress =
     implementationAddress_ ??
-    (is7702
-      ? DefaultAddress.SMAV2_7702
-      : owner.type === "webAuthn"
-        ? DefaultAddress.MAV2
-        : DefaultAddress.SMAV2_BYTECODE);
+    (is7702 ? DefaultAddress.SMAV2_7702 : DefaultAddress.SMAV2_BYTECODE);
 
   const getFactoryArgs = async () => {
     if (is7702) {
@@ -108,20 +108,6 @@ export async function toModularAccountV2<TMode extends Mode = Mode>({
       } as const;
     }
 
-    if (owner.type === "webAuthn") {
-      const { x, y } = parsePublicKey(owner.publicKey);
-      return {
-        factory: factoryAddress,
-        factoryData:
-          factoryData_ ??
-          encodeFunctionData({
-            abi: webAuthnFactoryAbi,
-            functionName: "createWebAuthnAccount",
-            args: [x, y, salt, entityId],
-          }),
-      };
-    }
-
     return {
       factory: factoryAddress,
       factoryData:
@@ -136,24 +122,26 @@ export async function toModularAccountV2<TMode extends Mode = Mode>({
 
   const accountAddress =
     accountAddress_ ??
-    (mode === "7702" && owner.type === "local"
+    (is7702
       ? owner.address
-      : predictModularAccountV2Address({
-          factoryAddress,
-          implementationAddress,
-          salt,
-          ...(owner.type === "webAuthn"
-            ? {
-                type: "WebAuthn",
-                ownerPublicKey: owner.publicKey,
-                entityId,
-              }
-            : {
-                type: "SMA", // `MA` is never used here since we only support deploying SMA & WebAuthn accounts.
-                ownerAddress: owner.address,
-                entityId,
-              }),
-        }));
+      : factoryData_
+        ? await getModularAccountV2AddressFromFactoryData({
+            client,
+            factoryAddress,
+            factoryData: factoryData_,
+            implementationAddress,
+            entryPoint: {
+              version: "0.7",
+              address: entryPoint07Address,
+            },
+          })
+        : predictModularAccountV2Address({
+            factoryAddress,
+            implementationAddress,
+            salt,
+            type: "SMA",
+            ownerAddress: owner.address,
+          }));
 
   LOGGER.debug("toModularAccountV2:address-resolved", {
     accountAddress,
@@ -163,7 +151,6 @@ export async function toModularAccountV2<TMode extends Mode = Mode>({
   let authorization: ToSmartAccountParameters["authorization"];
   if (is7702) {
     LOGGER.debug("toModularAccountV2:7702-mode");
-    // TODO(v5): Ensure this works w/ our signer types.
     if (owner.type !== "local") {
       LOGGER.error("toModularAccountV2:invalid-owner-type", {
         ownerType: owner.type,

package/src/ma-v2/accounts/base.ts

@@ -22,10 +22,7 @@ import {
   entryPoint07Address,
   getUserOperationHash,
   toSmartAccount,
-  type WebAuthnAccount,
   type ToSmartAccountParameters,
-  estimateUserOperationGas,
-  type UserOperation,
 } from "viem/account-abstraction";
 import {
   getCode,
@@ -60,15 +57,13 @@ import {
 import { parseDeferredAction } from "../utils/deferredActions.js";
 import {
   pack1271Signature,
-  toWebAuthnSignature,
   toReplaySafeTypedData,
   packUOSignature,
-  WEBAUTHN_DUMMY_SIGNATURE,
 } from "../utils/signature.js";
-import { chainHas7212 } from "../../utils.js";
 import { InvalidDeferredActionNonceError } from "../../errors/InvalidDeferredActionNonceError.js";
 import { InvalidNonceKeyError } from "../../errors/InvalidNonceKeyError.js";
 import { InvalidEntityIdError } from "../../errors/InvalidEntityIdError.js";
+import { is7702Delegated } from "../../utils.js";
 
 export type ValidationDataParams =
   | {
@@ -104,7 +99,7 @@ export type ToModularAccountV2BaseParams<
   TTransport extends Transport = Transport,
 > = {
   client: Client<TTransport, Chain, JsonRpcAccount | LocalAccount | undefined>;
-  owner: JsonRpcAccount | LocalAccount | WebAuthnAccount;
+  owner: JsonRpcAccount | LocalAccount;
   accountAddress: Address;
   getFactoryArgs: () => Promise<{
     factory?: Address | undefined;
@@ -155,7 +150,9 @@ export async function toModularAccountV2Base<
     }
     const action = getAction(client, getCode, "getCode");
     const code = await action({ address: accountAddress });
-    isDeployed = !!code;
+    isDeployed = authorization
+      ? is7702Delegated(authorization.address, code)
+      : !!code;
     return isDeployed;
   };
 
@@ -303,17 +300,12 @@ export async function toModularAccountV2Base<
       data: toReplaySafeTypedData({
         chainId: client.chain.id,
         hash,
-        ...(owner.type === "webAuthn"
-          ? {
-              address: DefaultModuleAddress.WEBAUTHN_VALIDATION,
+        ...(entityId === DEFAULT_OWNER_ENTITY_ID
+          ? { address: accountAddress }
+          : {
+              address: DefaultModuleAddress.SINGLE_SIGNER_VALIDATION,
               salt: concatHex([`0x${"00".repeat(12)}`, accountAddress]),
-            }
-          : entityId === DEFAULT_OWNER_ENTITY_ID
-            ? { address: accountAddress }
-            : {
-                address: DefaultModuleAddress.SINGLE_SIGNER_VALIDATION,
-                salt: concatHex([`0x${"00".repeat(12)}`, accountAddress]),
-              }),
+            }),
       }),
     };
   };
@@ -321,8 +313,7 @@ export async function toModularAccountV2Base<
   const formatSignature = async (signature: Hex): Promise<Hex> => {
     return pack1271Signature({
       entityId,
-      validationSignaturePrefix:
-        owner.type === "webAuthn" ? null : SignaturePrefix.EOA,
+      validationSignaturePrefix: SignaturePrefix.EOA,
       validationSignature: signature,
     });
   };
@@ -418,10 +409,6 @@ export async function toModularAccountV2Base<
     },
 
     async getStubSignature() {
-      if (owner.type === "webAuthn") {
-        return WEBAUTHN_DUMMY_SIGNATURE;
-      }
-
       const sig = packUOSignature({
         validationSignature:
           "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c",
@@ -435,13 +422,6 @@ export async function toModularAccountV2Base<
         data: message,
       });
 
-      if (owner.type === "webAuthn") {
-        const validationSignature = toWebAuthnSignature(
-          await owner.sign({ hash: hashTypedData(data) }),
-        );
-        return formatSignature(validationSignature);
-      }
-
       const action = getAction(client, signTypedData, "signTypedData");
 
       const signature = await action({
@@ -465,15 +445,6 @@ export async function toModularAccountV2Base<
         data: td as TypedDataDefinition, // TODO(v5): Try harder to satisfy this w/o casting.
       });
 
-      if (owner.type === "webAuthn") {
-        const validationSignature = toWebAuthnSignature(
-          await owner.sign({ hash: hashTypedData(data) }),
-        );
-        return isDeferredAction
-          ? validationSignature
-          : formatSignature(validationSignature);
-      }
-
       const action = getAction(client, signTypedData, "signTypedData");
 
       const signature = await action({
@@ -497,21 +468,6 @@ export async function toModularAccountV2Base<
         },
       });
 
-      if (owner.type === "webAuthn") {
-        const validationSignature = toWebAuthnSignature(
-          await owner.sign({
-            hash: hashMessage({ raw: hash }),
-          }),
-        );
-
-        const signature = deferredActionData
-          ? concatHex([deferredActionData, validationSignature])
-          : validationSignature;
-        deferredActionData = undefined; // clear once used
-        hasAssociatedExecHooks = false; // set to falsy value once used
-        return concatHex(["0xff", signature]);
-      }
-
       const signMessageAction = getAction(client, signMessage, "signMessage");
 
       const validationSignature = await signMessageAction({
@@ -533,35 +489,6 @@ export async function toModularAccountV2Base<
       return signature;
     },
 
-    userOperation: {
-      estimateGas: async (uo) => {
-        if (owner.type !== "webAuthn") {
-          // Uses the default gas estimator.
-          // Note that we get 7702 support automatically from Viem.
-          return undefined;
-        }
-
-        const estimateGasAction = getAction(
-          client,
-          estimateUserOperationGas,
-          "estimateUserOperationGas",
-        );
-
-        const estimate = await estimateGasAction({
-          ...(uo as UserOperation<typeof entryPoint.version>),
-          entryPointAddress: entryPoint.address,
-        });
-
-        const buffer = (await chainHas7212(client)) ? 10000n : 300000n;
-
-        // TODO(v4): iterate numbers. Aim to have ~1000 gas buffer to account for longer authenticatorDatas and clientDataJSONs.
-        return {
-          ...estimate,
-          verificationGasLimit: estimate.verificationGasLimit + buffer,
-        };
-      },
-    },
-
     extend: {
       smartAccountType: "ModularAccountV2" as const,
       signerEntity: {

package/src/ma-v2/mav2StaticImpl.ts

@@ -1,14 +1,11 @@
-import { encodeFunctionData, type Address, type Hex } from "viem";
+import { encodeFunctionData, type Address } from "viem";
 import { entryPoint07Abi, entryPoint07Address } from "viem/account-abstraction";
 import { lowerAddress } from "@alchemy/common";
 import type { StaticSmartAccountImplementation } from "../types.js";
 import { semiModularAccountBytecodeAbi } from "./abis/semiModularAccountBytecodeAbi.js";
 import { accountFactoryAbi } from "./abis/accountFactoryAbi.js";
-import { webAuthnFactoryAbi } from "./abis/webAuthnFactoryAbi.js";
 import { DefaultAddress as DefaultMAV2Address } from "./utils/account.js";
 import { predictModularAccountV2Address } from "./predictAddress.js";
-import { modularAccountAbi } from "./abis/modularAccountAbi.js";
-import { parsePublicKey } from "webauthn-p256";
 
 export type SemiModularAccountV2FactoryArgs = {
   owner: Address;
@@ -84,51 +81,3 @@ export const semiModularAccount7702StaticImpl: SemiModularAccount7702StaticImpl
     ...semiModularAccountBase,
     delegationAddress: lowerAddress(DefaultMAV2Address.SMAV2_7702),
   };
-
-export type WebAuthnModularAccountV2FactoryArgs = {
-  ownerPublicKey: Hex;
-  salt: bigint;
-  entityId: number;
-};
-
-export type WebAuthnModularAccountV2StaticImpl =
-  StaticSmartAccountImplementation<
-    false,
-    "0.7",
-    WebAuthnModularAccountV2FactoryArgs,
-    typeof entryPoint07Abi,
-    typeof modularAccountAbi,
-    typeof webAuthnFactoryAbi
-  >;
-
-/**
- * Static implementation logic for WebAuthnModularAccountV2.
- *
- * TODO(v5): update JSDoc format when doc-gen supports structs or records.
- */
-export const webAuthnModularAccountV2StaticImpl: WebAuthnModularAccountV2StaticImpl =
-  {
-    entryPoint,
-    accountAbi: modularAccountAbi,
-    accountImplementation: lowerAddress(DefaultMAV2Address.MAV2),
-    factoryAddress: lowerAddress(DefaultMAV2Address.MAV2_FACTORY_WEBAUTHN),
-    factoryAbi: webAuthnFactoryAbi,
-    getFactoryData: (args: WebAuthnModularAccountV2FactoryArgs) => {
-      const { x, y } = parsePublicKey(args.ownerPublicKey);
-      return encodeFunctionData({
-        abi: webAuthnFactoryAbi,
-        functionName: "createWebAuthnAccount",
-        args: [x, y, args.salt, args.entityId],
-      });
-    },
-    predictAccountAddress: (args: WebAuthnModularAccountV2FactoryArgs) => {
-      return predictModularAccountV2Address({
-        factoryAddress: DefaultMAV2Address.MAV2_FACTORY_WEBAUTHN,
-        implementationAddress: DefaultMAV2Address.MAV2,
-        type: "WebAuthn",
-        salt: args.salt,
-        ownerPublicKey: args.ownerPublicKey,
-        entityId: args.entityId,
-      });
-    },
-  };

package/src/ma-v2/modules/time-range-module/module.ts

@@ -2,6 +2,7 @@ import { encodeAbiParameters, type Address, type Hex } from "viem";
 
 import { timeRangeModuleAbi } from "./abis/timeRangeModuleAbi.js";
 import { HookType, type HookConfig } from "../../types.js";
+import { BaseError } from "@alchemy/common";
 
 export const TimeRangeModule = {
   abi: timeRangeModuleAbi,
@@ -14,13 +15,13 @@ export const TimeRangeModule = {
     address: Address,
   ): { hookConfig: HookConfig; initData: Hex } => {
     if (installArgs.validUntil > 2 ** 48 - 1) {
-      throw new Error(
+      throw new BaseError(
         "TimeRangeModule.buildHook: validUntil > type(uint48).max",
       );
     }
 
     if (installArgs.validAfter > 2 ** 48 - 1) {
-      throw new Error(
+      throw new BaseError(
         "TimeRangeModule.buildHook: validAfter > type(uint48).max",
       );
     }

package/src/ma-v2/predictAddress.ts

@@ -1,13 +1,22 @@
 import { assertNever } from "@alchemy/common";
 import {
   concatHex,
+  decodeFunctionData,
   encodePacked,
   getContractAddress,
+  isAddressEqual,
   keccak256,
   type Address,
+  type Client,
   type Hex,
 } from "viem";
-import { parsePublicKey } from "webauthn-p256";
+import {
+  entryPoint07Address,
+  type EntryPointVersion,
+} from "viem/account-abstraction";
+import { accountFactoryAbi } from "./abis/accountFactoryAbi.js";
+import { DefaultAddress } from "./utils/account.js";
+import { getSenderFromFactoryData } from "../utils.js";
 
 export type PredictModularAccountV2AddressParams = {
   factoryAddress: Address;
@@ -23,15 +32,10 @@ export type PredictModularAccountV2AddressParams = {
       type: "SMA";
       ownerAddress: Address;
     }
-  | {
-      type: "WebAuthn";
-      ownerPublicKey: Hex;
-      entityId: number;
-    }
 );
 
 /**
- * Predicts the address of a modular account V2 based on the provided parameters, which include factory address, salt, and implementation address. This function supports different types of accounts including "SMA", "MA", and "WebAuthn".
+ * Predicts the address of a modular account V2 based on the provided parameters, which include factory address, salt, and implementation address. This function supports different types of accounts including "SMA" and "MA".
  *
  * @example
  * ```ts
@@ -80,16 +84,6 @@ export function predictModularAccountV2Address(
           ),
           initcode: getProxyBytecode(implementationAddress),
         };
-      case "WebAuthn":
-        const { x, y } = parsePublicKey(params.ownerPublicKey);
-        return {
-          combinedSalt: getCombinedSaltWebAuthn(
-            { x, y },
-            salt,
-            params.entityId,
-          ),
-          initcode: getProxyBytecode(implementationAddress),
-        };
       default:
         return assertNever(params, "Unexpected MAv2 type");
     }
@@ -116,19 +110,6 @@ function getCombinedSaltK1(
   );
 }
 
-function getCombinedSaltWebAuthn(
-  ownerPublicKey: { x: bigint; y: bigint },
-  salt: bigint,
-  entityId: number,
-): Hex {
-  return keccak256(
-    encodePacked(
-      ["uint256", "uint256", "uint256", "uint32"],
-      [ownerPublicKey.x, ownerPublicKey.y, salt, entityId],
-    ),
-  );
-}
-
 function getProxyBytecode(implementationAddress: Address): Hex {
   return concatHex([
     "0x603d3d8160223d3973",
@@ -147,3 +128,60 @@ function getProxyBytecodeWithImmutableArgs(
     2,
   )}`;
 }
+
+export type GetModularAccountV2AddressFromFactoryDataParams = {
+  client: Client;
+  factoryAddress: Address;
+  factoryData: Hex;
+  implementationAddress: Address;
+  entryPoint?: {
+    version: EntryPointVersion;
+    address: Address;
+  };
+};
+
+/**
+ * Gets the modular account v2 address from factory data.
+ * If the factory is a known default (SMA), decodes the args and predicts without RPC.
+ * Otherwise falls back to calling the entry point's getSenderAddress.
+ *
+ * @param {GetModularAccountV2AddressFromFactoryDataParams} params - The parameters
+ * @returns {Promise<Address>} The account address
+ */
+export async function getModularAccountV2AddressFromFactoryData({
+  client,
+  factoryAddress,
+  factoryData,
+  implementationAddress,
+  entryPoint = {
+    version: "0.7",
+    address: entryPoint07Address,
+  },
+}: GetModularAccountV2AddressFromFactoryDataParams): Promise<Address> {
+  // Try SMA factory
+  if (isAddressEqual(factoryAddress, DefaultAddress.MAV2_FACTORY)) {
+    try {
+      const decoded = decodeFunctionData({
+        abi: accountFactoryAbi,
+        data: factoryData,
+      });
+      if (decoded.functionName === "createSemiModularAccount") {
+        const [decodedOwner, decodedSalt] = decoded.args;
+        return predictModularAccountV2Address({
+          factoryAddress,
+          implementationAddress,
+          salt: decodedSalt,
+          type: "SMA",
+          ownerAddress: decodedOwner,
+        });
+      }
+    } catch {
+      // Decode failed, fall through to RPC
+    }
+  }
+  return getSenderFromFactoryData(client, {
+    factory: factoryAddress,
+    factoryData,
+    entryPoint,
+  });
+}

package/src/ma-v2/utils/account.ts

@@ -16,11 +16,9 @@ import type { ModularAccountV2Base } from "../accounts/base.js";
  */
 export const DefaultAddress = {
   MAV2_FACTORY: "0x00000000000017c61b5bEe81050EC8eFc9c6fecd",
-  MAV2_FACTORY_WEBAUTHN: "0x55010E571dCf07e254994bfc88b9C1C8FAe31960",
   SMAV2_BYTECODE: "0x000000000000c5A9089039570Dd36455b5C07383",
   SMAV2_STORAGE: "0x0000000000006E2f9d80CaEc0Da6500f005EB25A",
   SMAV2_7702: "0x69007702764179f14F51cdce752f4f775d74E139",
-  MAV2: "0x00000000000002377B26b1EdA7b0BC371C60DD4f",
 } satisfies Record<string, Address>;
 
 /**
@@ -28,7 +26,6 @@ export const DefaultAddress = {
  */
 export const DefaultModuleAddress = {
   SINGLE_SIGNER_VALIDATION: "0x00000000000099DE0BF6fA90dEB851E2A2df7d83",
-  WEBAUTHN_VALIDATION: "0x0000000000001D9d34E07D9834274dF9ae575217",
   TIME_RANGE: "0x00000000000082B8e2012be914dFA4f62A0573eA",
   PAYMASTER_GUARD: "0x0000000000001aA7A7F7E29abe0be06c72FD42A1",
   NATIVE_TOKEN_LIMIT: "0x00000000000001e541f0D090868FBe24b59Fbe06",