@aa-sdk/core 4.0.0-alpha.5 → 4.0.0-alpha.6

package/src/account/base.ts

@@ -1,415 +0,0 @@
-import type { Address } from "abitype";
-import {
-  getContract,
-  http,
-  trim,
-  type GetContractReturnType,
-  type Hash,
-  type Hex,
-  type HttpTransport,
-  type PublicClient,
-  type Transport,
-} from "viem";
-import { EntryPointAbi_v6 as EntryPointAbi } from "../abis/EntryPointAbi_v6.js";
-import {
-  createBundlerClient,
-  type BundlerClient,
-} from "../client/bundlerClient.js";
-import { getEntryPoint } from "../entrypoint/index.js";
-import {
-  BatchExecutionNotSupportedError,
-  FailedToGetStorageSlotError,
-  GetCounterFactualAddressError,
-  UpgradeToAndCallNotSupportedError,
-} from "../errors/account.js";
-import { InvalidRpcUrlError } from "../errors/client.js";
-import { Logger } from "../logger.js";
-import type { SmartAccountSigner } from "../signer/types.js";
-import { wrapSignatureWith6492 } from "../signer/utils.js";
-import type { BatchUserOperationCallData, NullAddress } from "../types.js";
-import { createBaseSmartAccountParamsSchema } from "./schema.js";
-import type {
-  BaseSmartAccountParams,
-  ISmartContractAccount,
-  SignTypedDataParams,
-} from "./types.js";
-
-export enum DeploymentState {
-  UNDEFINED = "0x0",
-  NOT_DEPLOYED = "0x1",
-  DEPLOYED = "0x2",
-}
-
-/**
- * @deprecated use `toSmartContractAccount` instead for creating SmartAccountInstances
- */
-export abstract class BaseSmartContractAccount<
-  TTransport extends Transport = Transport,
-  TSigner extends SmartAccountSigner = SmartAccountSigner
-> implements ISmartContractAccount<TTransport, TSigner>
-{
-  protected factoryAddress: Address;
-  protected deploymentState: DeploymentState = DeploymentState.UNDEFINED;
-  protected accountAddress?: Address;
-  protected accountInitCode?: Hex;
-  protected signer: TSigner;
-  protected entryPoint: GetContractReturnType<
-    typeof EntryPointAbi,
-    PublicClient
-  >;
-  protected entryPointAddress: Address;
-  readonly rpcProvider:
-    | BundlerClient<TTransport>
-    | BundlerClient<HttpTransport>;
-
-  constructor(params_: BaseSmartAccountParams<TTransport, TSigner>) {
-    const params = createBaseSmartAccountParamsSchema<
-      TTransport,
-      TSigner
-    >().parse(params_);
-
-    this.entryPointAddress =
-      params.entryPointAddress ?? getEntryPoint(params.chain).address;
-
-    const rpcUrl =
-      typeof params.rpcClient === "string"
-        ? params.rpcClient
-        : params.rpcClient.transport.type === "http"
-        ? (
-            params.rpcClient.transport as ReturnType<HttpTransport>["config"] &
-              ReturnType<HttpTransport>["value"]
-          ).url || params.chain.rpcUrls.default.http[0]
-        : undefined;
-
-    const fetchOptions =
-      typeof params.rpcClient === "string"
-        ? undefined
-        : params.rpcClient.transport.type === "http"
-        ? (
-            params.rpcClient.transport as ReturnType<HttpTransport>["config"] &
-              ReturnType<HttpTransport>["value"]
-          ).fetchOptions
-        : undefined;
-
-    this.rpcProvider = rpcUrl
-      ? createBundlerClient({
-          chain: params.chain,
-          transport: http(rpcUrl, {
-            fetchOptions: {
-              ...fetchOptions,
-              headers: {
-                ...fetchOptions?.headers,
-                ...(rpcUrl.toLowerCase().indexOf("alchemy") > -1
-                  ? {
-                      "Alchemy-Aa-Sdk-Signer":
-                        params.signer?.signerType || "unknown",
-                      "Alchemy-Aa-Sdk-Factory-Address": params.factoryAddress,
-                    }
-                  : undefined),
-              },
-            },
-          }),
-        })
-      : (params.rpcClient as BundlerClient<TTransport>);
-
-    this.accountAddress = params.accountAddress;
-    this.factoryAddress = params.factoryAddress;
-    this.signer = params.signer as TSigner;
-    this.accountInitCode = params.initCode as Hex;
-
-    this.entryPoint = getContract({
-      address: this.entryPointAddress,
-      abi: EntryPointAbi,
-      client: this.rpcProvider as PublicClient,
-    });
-  }
-
-  //#region abstract-methods
-
-  /**
-   * This method should return a signature that will not `revert` during validation.
-   * It does not have to pass validation, just not cause the contract to revert.
-   * This is required for gas estimation so that the gas estimate are accurate.
-   *
-   */
-  abstract getDummySignature(): Hex | Promise<Hex>;
-
-  /**
-   * this method should return the abi encoded function data for a call to your contract's `execute` method
-   *
-   * @param target -- equivalent to `to` in a normal transaction
-   * @param value -- equivalent to `value` in a normal transaction
-   * @param data -- equivalent to `data` in a normal transaction
-   * @returns abi encoded function data for a call to your contract's `execute` method
-   */
-  abstract encodeExecute(
-    target: string,
-    value: bigint,
-    data: string
-  ): Promise<Hash>;
-
-  /**
-   * this should return an ERC-191 compliant message and is used to sign UO Hashes
-   *
-   * @param msg -- the message to sign
-   */
-  abstract signMessage(msg: string | Uint8Array): Promise<Hash>;
-
-  /**
-   * this should return the init code that will be used to create an account if one does not exist.
-   * This is the concatenation of the account's factory address and the abi encoded function data of the account factory's `createAccount` method.
-   * https://github.com/eth-infinitism/account-abstraction/blob/abff2aca61a8f0934e533d0d352978055fddbd96/contracts/core/SenderCreator.sol#L12
-   */
-  protected abstract getAccountInitCode(): Promise<Hash>;
-
-  //#endregion abstract-methods
-
-  //#region optional-methods
-
-  /**
-   * If your account handles 1271 signatures of personal_sign differently
-   * than it does UserOperations, you can implement two different approaches to signing
-   *
-   * @param uoHash -- The hash of the UserOperation to sign
-   * @returns the signature of the UserOperation
-   */
-  async signUserOperationHash(uoHash: Hash): Promise<Hash> {
-    return this.signMessage(uoHash);
-  }
-
-  /**
-   * If your contract supports signing and verifying typed data,
-   * you should implement this method.
-   *
-   * @param _params -- Typed Data params to sign
-   */
-  async signTypedData(_params: SignTypedDataParams): Promise<`0x${string}`> {
-    throw new Error("signTypedData not supported");
-  }
-
-  /**
-   * This method should wrap the result of `signMessage` as per
-   * [EIP-6492](https://eips.ethereum.org/EIPS/eip-6492)
-   *
-   * @param msg -- the message to sign
-   * @returns the signature wrapped in 6492 format
-   */
-  async signMessageWith6492(msg: string | Uint8Array): Promise<`0x${string}`> {
-    const [isDeployed, signature] = await Promise.all([
-      this.isAccountDeployed(),
-      this.signMessage(msg),
-    ]);
-
-    return this.create6492Signature(isDeployed, signature);
-  }
-
-  /**
-   * Similar to the signMessageWith6492 method above,
-   * this method should wrap the result of `signTypedData` as per
-   * [EIP-6492](https://eips.ethereum.org/EIPS/eip-6492)
-   *
-   * @param params -- Typed Data params to sign
-   * @returns the signature wrapped in 6492 format
-   */
-  async signTypedDataWith6492(
-    params: SignTypedDataParams
-  ): Promise<`0x${string}`> {
-    const [isDeployed, signature] = await Promise.all([
-      this.isAccountDeployed(),
-      this.signTypedData(params),
-    ]);
-
-    return this.create6492Signature(isDeployed, signature);
-  }
-
-  /**
-   * Not all contracts support batch execution.
-   * If your contract does, this method should encode a list of
-   * transactions into the call data that will be passed to your
-   * contract's batch execution method.
-   *
-   * @param _txs -- the transactions to batch execute
-   */
-  async encodeBatchExecute(
-    _txs: BatchUserOperationCallData
-  ): Promise<`0x${string}`> {
-    throw new BatchExecutionNotSupportedError("BaseAccount");
-  }
-
-  /**
-   * If your contract supports UUPS, you can implement this method which can be
-   * used to upgrade the implementation of the account.
-   *
-   * @param _upgradeToImplAddress -- the implementation address of the contract you want to upgrade to
-   * @param _upgradeToInitData -- the initialization data required by that account
-   */
-  encodeUpgradeToAndCall = async (
-    _upgradeToImplAddress: Address,
-    _upgradeToInitData: Hex
-  ): Promise<Hex> => {
-    throw new UpgradeToAndCallNotSupportedError("BaseAccount");
-  };
-  //#endregion optional-methods
-
-  // Extra implementations
-  async getNonce(): Promise<bigint> {
-    if (!(await this.isAccountDeployed())) {
-      return 0n;
-    }
-    const address = await this.getAddress();
-    return this.entryPoint.read.getNonce([address, BigInt(0)]);
-  }
-
-  async getInitCode(): Promise<Hex> {
-    if (this.deploymentState === DeploymentState.DEPLOYED) {
-      return "0x";
-    }
-
-    const contractCode = await this.rpcProvider.getBytecode({
-      address: await this.getAddress(),
-    });
-
-    if ((contractCode?.length ?? 0) > 2) {
-      this.deploymentState = DeploymentState.DEPLOYED;
-      return "0x";
-    } else {
-      this.deploymentState = DeploymentState.NOT_DEPLOYED;
-    }
-
-    return this._getAccountInitCode();
-  }
-
-  async getAddress(): Promise<Address> {
-    if (!this.accountAddress) {
-      const initCode = await this._getAccountInitCode();
-      Logger.verbose(
-        "[BaseSmartContractAccount](getAddress) initCode: ",
-        initCode
-      );
-      try {
-        await this.entryPoint.simulate.getSenderAddress([initCode]);
-      } catch (err: any) {
-        Logger.verbose(
-          "[BaseSmartContractAccount](getAddress) getSenderAddress err: ",
-          err
-        );
-
-        if (err.cause?.data?.errorName === "SenderAddressResult") {
-          this.accountAddress = err.cause.data.args[0] as Address;
-          Logger.verbose(
-            "[BaseSmartContractAccount](getAddress) entryPoint.getSenderAddress result:",
-            this.accountAddress
-          );
-          return this.accountAddress;
-        }
-
-        if (err.details === "Invalid URL") {
-          throw new InvalidRpcUrlError();
-        }
-      }
-
-      throw new GetCounterFactualAddressError();
-    }
-
-    return this.accountAddress;
-  }
-
-  extend = <R>(fn: (self: this) => R): this & R => {
-    const extended = fn(this) as any;
-    // this should make it so extensions can't overwrite the base methods
-    for (const key in this) {
-      delete extended[key];
-    }
-    return Object.assign(this, extended);
-  };
-
-  getSigner(): TSigner {
-    return this.signer;
-  }
-
-  getFactoryAddress(): Address {
-    return this.factoryAddress;
-  }
-
-  getEntryPointAddress(): Address {
-    return this.entryPointAddress;
-  }
-
-  async isAccountDeployed(): Promise<boolean> {
-    return (await this.getDeploymentState()) === DeploymentState.DEPLOYED;
-  }
-
-  async getDeploymentState(): Promise<DeploymentState> {
-    if (this.deploymentState === DeploymentState.UNDEFINED) {
-      const initCode = await this.getInitCode();
-      return initCode === "0x"
-        ? DeploymentState.DEPLOYED
-        : DeploymentState.NOT_DEPLOYED;
-    } else {
-      return this.deploymentState;
-    }
-  }
-
-  /**
-   * https://eips.ethereum.org/EIPS/eip-4337#first-time-account-creation
-   * The initCode field (if non-zero length) is parsed as a 20-byte address,
-   * followed by calldata to pass to this address.
-   * The factory address is the first 40 char after the 0x, and the callData is the rest.
-   *
-   * @returns [factoryAddress, factoryCalldata]
-   */
-  protected async parseFactoryAddressFromAccountInitCode(): Promise<
-    [Address, Hex]
-  > {
-    const initCode = await this._getAccountInitCode();
-    const factoryAddress: Address = `0x${initCode.substring(2, 42)}`;
-    const factoryCalldata: Hex = `0x${initCode.substring(42)}`;
-    return [factoryAddress, factoryCalldata];
-  }
-
-  protected async getImplementationAddress(): Promise<NullAddress | Address> {
-    const accountAddress = await this.getAddress();
-
-    const storage = await this.rpcProvider.getStorageAt({
-      address: accountAddress,
-      // This is the default slot for the implementation address for Proxies
-      slot: "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc",
-    });
-
-    if (storage == null) {
-      throw new FailedToGetStorageSlotError(
-        "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc",
-        "Proxy Implementation Address"
-      );
-    }
-
-    return trim(storage);
-  }
-
-  private async _getAccountInitCode(): Promise<Hash> {
-    return this.accountInitCode ?? this.getAccountInitCode();
-  }
-
-  private async create6492Signature(
-    isDeployed: boolean,
-    signature: Hash
-  ): Promise<Hash> {
-    if (isDeployed) {
-      return signature;
-    }
-
-    const [factoryAddress, factoryCalldata] =
-      await this.parseFactoryAddressFromAccountInitCode();
-
-    Logger.verbose(
-      `[BaseSmartContractAccount](create6492Signature)\
-        factoryAddress: ${factoryAddress}, factoryCalldata: ${factoryCalldata}`
-    );
-
-    return wrapSignatureWith6492({
-      factoryAddress,
-      factoryCalldata,
-      signature,
-    });
-  }
-}

package/src/account/schema.ts

@@ -1,51 +0,0 @@
-import { Address } from "abitype/zod";
-import { isHex, type Transport } from "viem";
-import z from "zod";
-import { createPublicErc4337ClientSchema } from "../client/schema.js";
-import { isEntryPointVersion } from "../entrypoint/index.js";
-import type { EntryPointVersion } from "../entrypoint/types.js";
-import { isSigner } from "../signer/schema.js";
-import type { SmartAccountSigner } from "../signer/types.js";
-import { ChainSchema } from "../utils/index.js";
-
-export const createBaseSmartAccountParamsSchema = <
-  TTransport extends Transport = Transport,
-  TSigner extends SmartAccountSigner = SmartAccountSigner
->() =>
-  z.object({
-    rpcClient: z.union([
-      z.string(),
-      createPublicErc4337ClientSchema<TTransport>(),
-    ]),
-    factoryAddress: Address,
-    signer: z.custom<TSigner>(isSigner),
-    entryPointAddress: Address.optional(),
-    chain: ChainSchema,
-    accountAddress: Address.optional().describe(
-      "Optional override for the account address."
-    ),
-    initCode: z
-      .string()
-      .refine(
-        (x) => isHex(x, { strict: true }),
-        "initCode must be a valid hex."
-      )
-      .optional()
-      .describe("Optional override for the account init code."),
-    entryPointVersion: z
-      .custom<EntryPointVersion>(isEntryPointVersion)
-      .optional(),
-  });
-
-export const SimpleSmartAccountParamsSchema = <
-  TTransport extends Transport = Transport,
-  TSigner extends SmartAccountSigner = SmartAccountSigner
->() =>
-  createBaseSmartAccountParamsSchema<TTransport, TSigner>()
-    .omit({
-      rpcClient: true,
-    })
-    .extend({
-      transport: z.custom<TTransport>(),
-      salt: z.bigint().optional(),
-    });

package/src/account/simple.ts

@@ -1,221 +0,0 @@
-import type { Address } from "abitype";
-import {
-  concatHex,
-  encodeFunctionData,
-  isHex,
-  type Chain,
-  type FallbackTransport,
-  type Hex,
-  type Transport,
-} from "viem";
-import { SimpleAccountAbi_v6 } from "../abis/SimpleAccountAbi_v6.js";
-import { SimpleAccountAbi_v7 } from "../abis/SimpleAccountAbi_v7.js";
-import { SimpleAccountFactoryAbi } from "../abis/SimpleAccountFactoryAbi.js";
-import { createBundlerClient } from "../client/bundlerClient.js";
-import {
-  defaultEntryPointVersion,
-  getEntryPoint,
-} from "../entrypoint/index.js";
-import type {
-  DefaultEntryPointVersion,
-  EntryPointParameter,
-  EntryPointVersion,
-} from "../entrypoint/types.js";
-import { AccountRequiresOwnerError } from "../errors/account.js";
-import type { SmartAccountSigner } from "../signer/types.js";
-import type { BatchUserOperationCallData } from "../types.js";
-import { getDefaultSimpleAccountFactoryAddress } from "../utils/defaults.js";
-import { BaseSmartContractAccount } from "./base.js";
-import { SimpleSmartAccountParamsSchema } from "./schema.js";
-import {
-  toSmartContractAccount,
-  type SmartContractAccountWithSigner,
-  type ToSmartContractAccountParams,
-} from "./smartContractAccount.js";
-import type { SimpleSmartAccountParams } from "./types.js";
-
-class SimpleSmartContractAccount<
-  TTransport extends Transport | FallbackTransport = Transport,
-  TSigner extends SmartAccountSigner = SmartAccountSigner
-> extends BaseSmartContractAccount<TTransport, TSigner> {
-  protected index: bigint;
-  protected entryPointVersion: EntryPointVersion;
-
-  constructor(params: SimpleSmartAccountParams<TTransport, TSigner>) {
-    SimpleSmartAccountParamsSchema().parse(params);
-
-    // This is a hack for now, we should kill the SimpleSmart Account when we kill Base Account
-    const client = createBundlerClient({
-      transport: params.transport as TTransport,
-      chain: params.chain,
-    });
-
-    // @ts-expect-error zod custom type not recognized as required params for signers
-    super({ ...params, rpcClient: client });
-    this.signer = params.signer as TSigner;
-    this.index = params.salt ?? 0n;
-    this.entryPointVersion =
-      params.entryPointVersion ?? defaultEntryPointVersion;
-  }
-
-  getDummySignature(): `0x${string}` {
-    return "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
-  }
-
-  async encodeExecute(
-    target: Hex,
-    value: bigint,
-    data: Hex
-  ): Promise<`0x${string}`> {
-    return encodeFunctionData({
-      abi:
-        this.entryPointVersion === "0.6.0"
-          ? SimpleAccountAbi_v6
-          : SimpleAccountAbi_v7,
-      functionName: "execute",
-      args: [target, value, data],
-    });
-  }
-
-  override async encodeBatchExecute(
-    txs: BatchUserOperationCallData
-  ): Promise<`0x${string}`> {
-    const [targets, datas] = txs.reduce(
-      (accum, curr) => {
-        accum[0].push(curr.target);
-        accum[1].push(curr.data);
-
-        return accum;
-      },
-      [[], []] as [Address[], Hex[]]
-    );
-
-    return encodeFunctionData({
-      abi:
-        this.entryPointVersion === "0.6.0"
-          ? SimpleAccountAbi_v6
-          : SimpleAccountAbi_v7,
-      functionName: "executeBatch",
-      args: [targets, datas],
-    });
-  }
-
-  signMessage(msg: Uint8Array | string): Promise<`0x${string}`> {
-    return this.signer.signMessage(
-      typeof msg === "string" && !isHex(msg) ? msg : { raw: msg }
-    );
-  }
-
-  public async getAccountInitCode(): Promise<`0x${string}`> {
-    return concatHex([
-      this.factoryAddress,
-      encodeFunctionData({
-        abi: SimpleAccountFactoryAbi,
-        functionName: "createAccount",
-        args: [await this.signer.getAddress(), this.index],
-      }),
-    ]);
-  }
-}
-
-export type SimpleSmartAccount<
-  TSigner extends SmartAccountSigner = SmartAccountSigner,
-  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
-> = SmartContractAccountWithSigner<
-  "SimpleAccount",
-  TSigner,
-  TEntryPointVersion
->;
-
-export type CreateSimpleAccountParams<
-  TTransport extends Transport = Transport,
-  TSigner extends SmartAccountSigner = SmartAccountSigner,
-  TEntryPointVersion extends EntryPointVersion = DefaultEntryPointVersion
-> = Pick<
-  ToSmartContractAccountParams<
-    "SimpleAccount",
-    TTransport,
-    Chain,
-    TEntryPointVersion
-  >,
-  "chain" | "transport"
-> & {
-  signer: TSigner;
-  salt?: bigint;
-  accountAddress?: Address;
-  factoryAddress?: Address;
-  initCode?: Hex;
-} & EntryPointParameter<TEntryPointVersion, Chain>;
-
-export async function createSimpleSmartAccount<
-  TTransport extends Transport = Transport,
-  TSigner extends SmartAccountSigner = SmartAccountSigner,
-  TEntryPointVersion extends EntryPointVersion = DefaultEntryPointVersion
->(
-  config: CreateSimpleAccountParams<TTransport, TSigner, TEntryPointVersion>
-): Promise<SimpleSmartAccount<TSigner, TEntryPointVersion>>;
-
-/**
- * Creates a simple smart account using the provided parameters, including chain, entry point, factory address, and additional parameters. This function also ensures that a signer is provided.
- *
- * @param {CreateSimpleAccountParams} config The parameters for creating a simple smart account
- * @returns {Promise<SimpleSmartAccount>} A promise that resolves to a `SimpleSmartAccount` object containing the created account information and methods
- */
-export async function createSimpleSmartAccount({
-  chain,
-  entryPoint = getEntryPoint(chain),
-  factoryAddress = getDefaultSimpleAccountFactoryAddress(
-    chain,
-    entryPoint.version
-  ),
-  ...params
-}: CreateSimpleAccountParams): Promise<SimpleSmartAccount> {
-  if (!params.signer) throw new AccountRequiresOwnerError("SimpleAccount");
-  const simpleAccount = new SimpleSmartContractAccount(
-    SimpleSmartAccountParamsSchema().parse({
-      chain,
-      entryPointAddress: entryPoint.address,
-      factoryAddress,
-      ...params,
-    })
-  );
-
-  const parsedParams = SimpleSmartAccountParamsSchema().parse({
-    chain,
-    entryPointAddress: entryPoint.address,
-    entryPointVersion: entryPoint.version,
-    factoryAddress,
-    ...params,
-  });
-
-  const base = await toSmartContractAccount({
-    source: "SimpleAccount",
-    transport: params.transport,
-    chain,
-    encodeBatchExecute: simpleAccount.encodeBatchExecute.bind(simpleAccount),
-    encodeExecute: (tx) =>
-      simpleAccount.encodeExecute.bind(simpleAccount)(
-        tx.target,
-        tx.value ?? 0n,
-        tx.data
-      ),
-    entryPoint,
-    getAccountInitCode: async () => {
-      if (parsedParams.initCode) return parsedParams.initCode as Hex;
-      return simpleAccount.getAccountInitCode();
-    },
-    getDummySignature: simpleAccount.getDummySignature.bind(simpleAccount),
-    signMessage: ({ message }) =>
-      simpleAccount.signMessage(
-        typeof message === "string" ? message : message.raw
-      ),
-    // @ts-expect-error these types still represent the same thing, but they are just a little off in there definitions
-    signTypedData: simpleAccount.signTypedData.bind(simpleAccount),
-    accountAddress: parsedParams.accountAddress,
-  });
-
-  return {
-    ...base,
-    getSigner: () => simpleAccount.getSigner(),
-  };
-}