@aa-sdk/core 4.0.0-alpha.1 → 4.0.0-alpha.11

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(),
-  };
-}

package/src/account/types.ts

@@ -1,184 +0,0 @@
-import type { Address } from "abitype";
-import type { Hash, Hex, HttpTransport, Transport } from "viem";
-import type { SignTypedDataParameters } from "viem/accounts";
-import type { z } from "zod";
-import type { BundlerClient } from "../client/bundlerClient";
-import type { SmartAccountSigner } from "../signer/types";
-import type { BatchUserOperationCallData } from "../types";
-import type {
-  SimpleSmartAccountParamsSchema,
-  createBaseSmartAccountParamsSchema,
-} from "./schema";
-
-/** @deprecated */
-export type SignTypedDataParams = Omit<SignTypedDataParameters, "privateKey">;
-
-/**
- * @deprecated don't use base smart account anymore, migrate to using toSmartContractAccount instead
- */
-export type BaseSmartAccountParams<
-  TTransport extends Transport = Transport,
-  TSigner extends SmartAccountSigner = SmartAccountSigner
-> = z.input<
-  ReturnType<typeof createBaseSmartAccountParamsSchema<TTransport, TSigner>>
->;
-
-export type SimpleSmartAccountParams<
-  TTransport extends Transport = Transport,
-  TSigner extends SmartAccountSigner = SmartAccountSigner
-> = z.input<
-  ReturnType<typeof SimpleSmartAccountParamsSchema<TTransport, TSigner>>
->;
-
-/**
- * @deprecated use `toSmartContractAccount` instead for creating instances of smart accounts
- */
-export interface ISmartContractAccount<
-  TTransport extends Transport = Transport,
-  TSigner extends SmartAccountSigner = SmartAccountSigner
-> {
-  /**
-   * The RPC provider the account uses to make RPC calls
-   */
-  readonly rpcProvider:
-    | BundlerClient<TTransport>
-    | BundlerClient<HttpTransport>;
-
-  /**
-   * @returns the init code for the account
-   */
-  getInitCode(): Promise<Hex>;
-
-  /**
-   * This is useful for estimating gas costs. It should return a signature that doesn't cause the account to revert
-   * when validation is run during estimation.
-   *
-   * @returns a dummy signature that doesn't cause the account to revert during estimation
-   */
-  getDummySignature(): Hex | Promise<Hex>;
-
-  /**
-   * Encodes a call to the account's execute function.
-   *
-   * @param target - the address receiving the call data
-   * @param value - optionally the amount of native token to send
-   * @param data - the call data or "0x" if empty
-   */
-  encodeExecute(target: string, value: bigint, data: string): Promise<Hex>;
-
-  /**
-   * Encodes a batch of transactions to the account's batch execute function.
-   * NOTE: not all accounts support batching.
-   *
-   * @param txs - An Array of objects containing the target, value, and data for each transaction
-   * @returns the encoded callData for a UserOperation
-   */
-  encodeBatchExecute(txs: BatchUserOperationCallData): Promise<Hex>;
-
-  /**
-   * @returns the nonce of the account
-   */
-  getNonce(): Promise<bigint>;
-
-  /**
-   * 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
-   */
-  signUserOperationHash(uoHash: Hash): Promise<Hash>;
-
-  /**
-   * Returns a signed and prefixed message.
-   *
-   * @param msg - the message to sign
-   * @returns the signature of the message
-   */
-  signMessage(msg: string | Uint8Array | Hex): Promise<Hex>;
-
-  /**
-   * Signs a typed data object as per ERC-712
-   *
-   * @param params - {@link SignTypedDataParams}
-   * @returns the signed hash for the message passed
-   */
-  signTypedData(params: SignTypedDataParams): Promise<Hash>;
-
-  /**
-   * If the account is not deployed, it will sign the message and then wrap it in 6492 format
-   *
-   * @param msg - the message to sign
-   * @returns ths signature wrapped in 6492 format
-   */
-  signMessageWith6492(msg: string | Uint8Array | Hex): Promise<Hex>;
-
-  /**
-   * If the account is not deployed, it will sign the typed data blob and then wrap it in 6492 format
-   *
-   * @param params - {@link SignTypedDataParams}
-   * @returns the signed hash for the params passed in wrapped in 6492 format
-   */
-  signTypedDataWith6492(params: SignTypedDataParams): Promise<Hash>;
-
-  /**
-   * @returns the address of the account
-   */
-  getAddress(): Promise<Address>;
-
-  /**
-   * @returns the current account signer instance that the smart account client
-   * operations are being signed with.
-   *
-   * The signer is expected to be the owner or one of the owners of the account
-   * for the signatures to be valid for the acting account.
-   */
-  getSigner(): TSigner;
-
-  /**
-   * The factory address of the smart account created by the factory
-   *
-   * @returns the address of the factory contract for the smart account
-   */
-  getFactoryAddress(): Address;
-
-  /**
-   * The entrypoint address is the address ERC 4337 entrypoint singleton contract
-   * that this smart account and the connected bundler client use
-   *
-   * @returns the address of the entry point contract for the smart account
-   */
-  getEntryPointAddress(): Address;
-
-  /**
-   * Allows you to add additional functionality and utility methods to this account
-   * via a decorator pattern.
-   *
-   * NOTE: this method does not allow you to override existing methods on the account.
-   *
-   * @example
-   * ```ts
-   * const account = new BaseSmartCobntractAccount(...).extend((account) => ({
-   *  readAccountState: async (...args) => {
-   *    return this.rpcProvider.readContract({
-   *        address: await this.getAddress(),
-   *        abi: ThisContractsAbi
-   *        args: args
-   *    });
-   *  }
-   * }));
-   *
-   * account.debugSendUserOperation(...);
-   * ```
-   *
-   * @param extendFn -- this function gives you access to the created account instance and returns an object
-   * with the extension methods
-   * @returns -- the account with the extension methods added
-   */
-  extend: <R>(extendFn: (self: this) => R) => this & R;
-
-  encodeUpgradeToAndCall: (
-    upgradeToImplAddress: Address,
-    upgradeToInitData: Hex
-  ) => Promise<Hex>;
-}

package/src/chains/index.ts

@@ -1,194 +0,0 @@
-import { defineChain, type Chain } from "viem";
-import {
-  arbitrum as vab,
-  arbitrumGoerli as vabg,
-  arbitrumSepolia as vabs,
-  base as vbase,
-  baseGoerli as vbaseg,
-  baseSepolia as vbases,
-  goerli as vgo,
-  mainnet as vmain,
-  optimism as vop,
-  optimismGoerli as vopg,
-  optimismSepolia as vops,
-  polygon as vpg,
-  polygonMumbai as vpgm,
-  polygonAmoy as vpga,
-  sepolia as vsep,
-  fraxtal as vfrax,
-  zora as vzora,
-  zoraSepolia as vzoras,
-} from "viem/chains";
-
-export const arbitrum: Chain = {
-  ...vab,
-  rpcUrls: {
-    ...vab.rpcUrls,
-    alchemy: {
-      http: ["https://arb-mainnet.g.alchemy.com/v2"],
-    },
-  },
-};
-
-export const arbitrumGoerli: Chain = {
-  ...vabg,
-  rpcUrls: {
-    ...vabg.rpcUrls,
-    alchemy: {
-      http: ["https://arb-goerli.g.alchemy.com/v2"],
-    },
-  },
-};
-
-export const arbitrumSepolia: Chain = {
-  ...vabs,
-  rpcUrls: {
-    ...vabs.rpcUrls,
-    alchemy: {
-      http: ["https://arb-sepolia.g.alchemy.com/v2"],
-    },
-  },
-};
-export const goerli: Chain = {
-  ...vgo,
-  rpcUrls: {
-    ...vgo.rpcUrls,
-    alchemy: {
-      http: ["https://eth-goerli.g.alchemy.com/v2"],
-    },
-  },
-};
-export const mainnet: Chain = {
-  ...vmain,
-  rpcUrls: {
-    ...vmain.rpcUrls,
-    alchemy: {
-      http: ["https://eth-mainnet.g.alchemy.com/v2"],
-    },
-  },
-};
-export const optimism: Chain = {
-  ...vop,
-  rpcUrls: {
-    ...vop.rpcUrls,
-    alchemy: {
-      http: ["https://opt-mainnet.g.alchemy.com/v2"],
-    },
-  },
-};
-export const optimismGoerli: Chain = {
-  ...vopg,
-  rpcUrls: {
-    ...vopg.rpcUrls,
-    alchemy: {
-      http: ["https://opt-goerli.g.alchemy.com/v2"],
-    },
-  },
-};
-export const optimismSepolia: Chain = {
-  ...vops,
-  rpcUrls: {
-    ...vops.rpcUrls,
-    alchemy: {
-      http: ["https://opt-sepolia.g.alchemy.com/v2"],
-    },
-  },
-};
-export const sepolia: Chain = {
-  ...vsep,
-  rpcUrls: {
-    ...vsep.rpcUrls,
-    alchemy: {
-      http: ["https://eth-sepolia.g.alchemy.com/v2"],
-    },
-  },
-};
-export const base: Chain = {
-  ...vbase,
-  rpcUrls: {
-    ...vbase.rpcUrls,
-    alchemy: {
-      http: ["https://base-mainnet.g.alchemy.com/v2"],
-    },
-  },
-};
-export const baseGoerli: Chain = {
-  ...vbaseg,
-  rpcUrls: {
-    ...vbaseg.rpcUrls,
-    alchemy: {
-      http: ["https://base-goerli.g.alchemy.com/v2"],
-    },
-  },
-};
-export const baseSepolia: Chain = {
-  ...vbases,
-  rpcUrls: {
-    ...vbases.rpcUrls,
-    alchemy: {
-      http: ["https://base-sepolia.g.alchemy.com/v2"],
-    },
-  },
-};
-
-export const polygonMumbai: Chain = {
-  ...vpgm,
-  rpcUrls: {
-    ...vpgm.rpcUrls,
-    alchemy: {
-      http: ["https://polygon-mumbai.g.alchemy.com/v2"],
-    },
-  },
-};
-
-export const polygonAmoy: Chain = {
-  ...vpga,
-  rpcUrls: {
-    ...vpga.rpcUrls,
-    alchemy: {
-      http: ["https://polygon-amoy.g.alchemy.com/v2"],
-    },
-  },
-};
-
-export const polygon: Chain = {
-  ...vpg,
-  rpcUrls: {
-    ...vpg.rpcUrls,
-    alchemy: {
-      http: ["https://polygon-mainnet.g.alchemy.com/v2"],
-    },
-  },
-};
-
-export const fraxtal: Chain = {
-  ...vfrax,
-  rpcUrls: {
-    ...vfrax.rpcUrls,
-  },
-};
-
-export const fraxtalSepolia: Chain = defineChain({
-  id: 2523,
-  name: "Fraxtal Sepolia",
-  nativeCurrency: { name: "Frax Ether", symbol: "frxETH", decimals: 18 },
-  rpcUrls: {
-    default: {
-      http: ["https://rpc.testnet-sepolia.frax.com"],
-    },
-  },
-});
-
-export const zora: Chain = {
-  ...vzora,
-  rpcUrls: {
-    ...vzora.rpcUrls,
-  },
-};
-
-export const zoraSepolia: Chain = {
-  ...vzoras,
-  rpcUrls: {
-    ...vzoras.rpcUrls,
-  },
-};