Types

1
export type BatchUserOperationCallData = Exclude<UserOperationCallData, Hex>[];

1
export const BigNumberishSchema = z.union([HexSchema, z.number(), z.bigint()]);

1
export const BigNumberishRangeSchema = z
2
  .object({
3
    min: BigNumberishSchema.optional(),
4
    max: BigNumberishSchema.optional(),
5
  })
6
  .strict();

1
export type BundlerActions = {
2
  /**
3
   * calls `eth_estimateUserOperationGas` and  returns the result
4
   *
5
   * @param request - the UserOperationRequest to estimate gas for
6
   * @param entryPoint - the entry point address the op will be sent to
7
   * @param stateOverride - the state override to use for the estimation
8
   * @returns the gas estimates for the given response
9
   */
10
  estimateUserOperationGas<
11
    TEntryPointVersion extends EntryPointVersion = EntryPointVersion,
12
  >(
13
    request: UserOperationRequest<TEntryPointVersion>,
14
    entryPoint: Address,
15
    stateOverride?: StateOverride,
16
  ): Promise<UserOperationEstimateGasResponse<TEntryPointVersion>>;
17
18
  /**
19
   * calls `eth_sendUserOperation` and returns the hash of the sent UserOperation
20
   *
21
   * @param request - the UserOperationRequest to send
22
   * @param entryPoint - the entry point address the op will be sent to
23
   * @returns the hash of the sent UserOperation
24
   */
25
  sendRawUserOperation<
26
    TEntryPointVersion extends EntryPointVersion = EntryPointVersion,
27
  >(
28
    request: UserOperationRequest<TEntryPointVersion>,
29
    entryPoint: Address,
30
  ): Promise<Hash>;
31
32
  /**
33
   * calls `eth_getUserOperationByHash` and returns the UserOperationResponse
34
   *
35
   * @param hash - the hash of the UserOperation to fetch
36
   * @returns - the user operation if found or null
37
   */
38
  getUserOperationByHash(hash: Hash): Promise<UserOperationResponse | null>;
39
40
  /**
41
   * calls `eth_getUserOperationReceipt` and returns the UserOperationReceipt
42
   *
43
   * @param hash - the hash of the UserOperation to get the receipt for
44
   * @param tag - if client want to get receipt for different block tag.
45
   * @returns - a user operation receipt or null if not found
46
   */
47
  getUserOperationReceipt(
48
    hash: Hash,
49
    tag?: "pending" | "latest",
50
  ): Promise<UserOperationReceipt | null>;
51
52
  /**
53
   * calls `eth_supportedEntryPoints` and returns the entry points the RPC supports
54
   *
55
   * @returns - an array of the entrypoint addresses supported
56
   */
57
  getSupportedEntryPoints(): Promise<Address[]>;
58
};

1
export type BundlerClient<T extends Transport = Transport> = Client<
2
  T,
3
  Chain,
4
  undefined,
5
  [...PublicRpcSchema, ...BundlerRpcSchema],
6
  PublicActions<T, Chain> & BundlerActions
7
>;
8
9
/**
10
 * Creates a bundler client from an existing public client with the provided transport and chain.
11
 *
12
 * @example
13
 * ```ts
14
 * import { createPublicClient } from "viem";
15
 * import { createBundlerClientFromExisting } from "@aa-sdk/core";
16
 *
17
 * const publicClient = createPublicClient(...);
18
 * const bundlerClient = createBundlerClientFromExisting(publicClient);
19
 * ```
20
 *
21
 * @param {PublicClient<T, Chain>} client The existing public client to be extended with bundler actions
22
 * @returns {BundlerClient<T>} A bundler client that extends the functionality of the provided public client
23
 */
24
export const createBundlerClientFromExisting: <
25
  T extends Transport | FallbackTransport = Transport,
26
>(
27
  client: PublicClient<T, Chain>,
28
) => BundlerClient<T> = <T extends Transport | FallbackTransport = Transport>(
29
  client: PublicClient<T, Chain>,
30
): BundlerClient<T> => {
31
  return client.extend(bundlerActions);
32
};

1
export type ClientMiddleware<
2
  TContext extends UserOperationContext | undefined =
3
    | UserOperationContext
4
    | undefined,
5
> = {
6
  dummyPaymasterAndData: ClientMiddlewareFn<TContext>;
7
  feeEstimator: ClientMiddlewareFn<TContext>;
8
  gasEstimator: ClientMiddlewareFn<TContext>;
9
  customMiddleware: ClientMiddlewareFn<TContext>;
10
  paymasterAndData: ClientMiddlewareFn<TContext>;
11
  userOperationSimulator: ClientMiddlewareFn<TContext>;
12
  signUserOperation: ClientMiddlewareFn<TContext>;
13
};

1
export type ClientMiddlewareConfig<
2
  TContext extends UserOperationContext | undefined =
3
    | UserOperationContext
4
    | undefined,
5
> = Partial<ClientMiddleware<TContext>>;

1
export type ClientMiddlewareFn<
2
  TContext extends UserOperationContext | undefined =
3
    | UserOperationContext
4
    | undefined,
5
> = <
6
  TAccount extends SmartContractAccount,
7
  C extends MiddlewareClient,
8
  TEntryPointVersion extends
9
    GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>,
10
>(
11
  struct: Deferrable<UserOperationStruct<TEntryPointVersion>>,
12
  args: ClientMiddlewareArgs<TAccount, C, TContext, TEntryPointVersion>,
13
) => Promise<Deferrable<UserOperationStruct<TEntryPointVersion>>>;

1
export type EntryPointDef<
2
  TEntryPointVersion extends EntryPointVersion = EntryPointVersion,
3
  TChain extends Chain = Chain,
4
  TAbi extends Abi | readonly unknown[] = Abi,
5
> = {
6
  version: TEntryPointVersion;
7
  address: Address;
8
  chain: TChain;
9
  abi: GetContractParameters<Transport, TChain, Account, TAbi>["abi"];
10
  getUserOperationHash: (
11
    request: UserOperationRequest<TEntryPointVersion>,
12
  ) => Hex;
13
  packUserOperation: (
14
    userOperation: UserOperationRequest<TEntryPointVersion>,
15
  ) => Hex;
16
};

1
export const MultiplierSchema = z
2
  .object({
3
    /**
4
     * Multiplier value with max precision of 4 decimal places
5
     */
6
    multiplier: z.number().refine(
7
      (n) => {
8
        return (n.toString().split(".")[1]?.length ?? 0) <= 4;
9
      },
10
      { message: "Max precision is 4 decimal places" },
11
    ),
12
  })
13
  .strict();

1
/**
2
 * Extends the @interface SmartAccountSigner interface with authentication.
3
 *
4
 * @template AuthParams - the generic type of the authentication parameters
5
 * @template AuthDetails - the generic type of the authentication details
6
 * @template Inner - the generic type of the inner client that the signer wraps to provide functionality such as signing, etc.
7
 */
8
export interface SmartAccountAuthenticator<AuthParams, AuthDetails, Inner = any>
9
  extends SmartAccountSigner<Inner> {
10
  authenticate: (params: AuthParams) => Promise<AuthDetails>;
11
12
  getAuthDetails: () => Promise<AuthDetails>;
13
}

1
export type SmartAccountClient<
2
  transport extends Transport = Transport,
3
  chain extends Chain | undefined = Chain | undefined,
4
  account extends SmartContractAccount | undefined =
5
    | SmartContractAccount
6
    | undefined,
7
  actions extends Record<string, unknown> = Record<string, unknown>,
8
  rpcSchema extends RpcSchema = SmartAccountClientRpcSchema,
9
  context extends UserOperationContext | undefined =
10
    | UserOperationContext
11
    | undefined,
12
> = Prettify<
13
  Client<
14
    transport,
15
    chain,
16
    account,
17
    rpcSchema,
18
    actions & SmartAccountClientActions<chain, account, context>
19
  >
20
>;

1
export type SmartAccountClientActions<
2
  chain extends Chain | undefined = Chain | undefined,
3
  account extends SmartContractAccount | undefined =
4
    | SmartContractAccount
5
    | undefined,
6
  context extends UserOperationContext | undefined =
7
    | UserOperationContext
8
    | undefined,
9
> = BaseSmartAccountClientActions<chain, account, context> &
10
  BundlerActions &
11
  PublicActions;

1
// TODO: This is a temporary type to be removed when viem is updated
2
export type AuthorizationRequest<uint32 = number> = OneOf<
3
  | {
4
      address: Address;
5
    }
6
  | {
7
      contractAddress: Address;
8
    }
9
> & {
10
  /** Chain ID. */
11
  chainId: uint32;
12
  /** Nonce of the EOA to delegate to. */
13
  nonce: uint32;
14
};
15
16
/**
17
 * A signer that can sign messages and typed data.
18
 *
19
 * @template Inner - the generic type of the inner client that the signer wraps to provide functionality such as signing, etc.
20
 */
21
export interface SmartAccountSigner<Inner = any> {
22
  signerType: string;
23
  inner: Inner;
24
25
  getAddress: () => Promise<Address>;
26
27
  signMessage: (message: SignableMessage) => Promise<Hex>;
28
29
  signTypedData: <
30
    const TTypedData extends TypedData | Record<string, unknown>,
31
    TPrimaryType extends keyof TTypedData | "EIP712Domain" = keyof TTypedData,
32
  >(
33
    params: TypedDataDefinition<TTypedData, TPrimaryType>,
34
  ) => Promise<Hex>;
35
36
  signAuthorization?: (
37
    unsignedAuthorization: AuthorizationRequest<number>,
38
  ) => Promise<SignedAuthorization<number>>;
39
}

1
export type SmartContractAccount<
2
  Name extends string = string,
3
  TEntryPointVersion extends EntryPointVersion = EntryPointVersion,
4
> = LocalAccount<Name> & {
5
  source: Name;
6
  getDummySignature: () => Hex | Promise<Hex>;
7
  encodeExecute: (tx: AccountOp) => Promise<Hex>;
8
  encodeBatchExecute: (txs: AccountOp[]) => Promise<Hex>;
9
  signUserOperationHash: (uoHash: Hex) => Promise<Hex>;
10
  signMessageWith6492: (params: { message: SignableMessage }) => Promise<Hex>;
11
  signTypedDataWith6492: <
12
    const typedData extends TypedData | Record<string, unknown>,
13
    primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
14
  >(
15
    typedDataDefinition: TypedDataDefinition<typedData, primaryType>,
16
  ) => Promise<Hex>;
17
  encodeUpgradeToAndCall: (params: UpgradeToAndCallParams) => Promise<Hex>;
18
  getAccountNonce(nonceKey?: bigint): Promise<bigint>;
19
  getInitCode: () => Promise<Hex>;
20
  isAccountDeployed: () => Promise<boolean>;
21
  getFactoryAddress: () => Promise<Address>;
22
  getFactoryData: () => Promise<Hex>;
23
  getEntryPoint: () => EntryPointDef<TEntryPointVersion>;
24
  getImplementationAddress: () => Promise<NullAddress | Address>;
25
} & SigningMethods;

1
export type ToSmartContractAccountParams<
2
  Name extends string = string,
3
  TTransport extends Transport = Transport,
4
  TChain extends Chain = Chain,
5
  TEntryPointVersion extends EntryPointVersion = EntryPointVersion,
6
> = {
7
  source: Name;
8
  transport: TTransport;
9
  chain: TChain;
10
  entryPoint: EntryPointDef<TEntryPointVersion, TChain>;
11
  accountAddress?: Address;
12
  getAccountInitCode: () => Promise<Hex>;
13
  getDummySignature: () => Hex | Promise<Hex>;
14
  encodeExecute: (tx: AccountOp) => Promise<Hex>;
15
  encodeBatchExecute?: (txs: AccountOp[]) => Promise<Hex>;
16
  getNonce?: (nonceKey?: bigint) => Promise<bigint>;
17
  // if not provided, will default to just using signMessage over the Hex
18
  signUserOperationHash?: (uoHash: Hex) => Promise<Hex>;
19
  encodeUpgradeToAndCall?: (params: UpgradeToAndCallParams) => Promise<Hex>;
20
  getImplementationAddress?: () => Promise<NullAddress | Address>;
21
} & Omit<CustomSource, "signTransaction" | "address"> &
22
  (SigningMethods | Never<SigningMethods>);

1
export type User = {
2
  email?: string;
3
  phone?: string;
4
  orgId: string;
5
  userId: string;
6
  address: Address;
7
  solanaAddress?: string;
8
  credentialId?: string;
9
  idToken?: string;
10
  accessToken?: string;
11
  claims?: Record<string, unknown>;
12
};

1
export type UserOperationCallData =
2
  | {
3
      /* the target of the call */
4
      target: Address;
5
      /* the data passed to the target */
6
      data: Hex;
7
      /* the amount of native token to send to the target (default: 0) */
8
      value?: bigint;
9
    }
10
  | Hex;

1
export interface UserOperationEstimateGasResponse<
2
  TEntryPointVersion extends EntryPointVersion = EntryPointVersion,
3
> {
4
  /* Gas overhead of this UserOperation */
5
  preVerificationGas: BigNumberish;
6
  /* Actual gas used by the validation of this UserOperation */
7
  verificationGasLimit: BigNumberish;
8
  /* Value used by inner account execution */
9
  callGasLimit: BigNumberish;
10
  /*
11
   * EntryPoint v0.7.0 operations only.
12
   * The amount of gas to allocate for the paymaster validation code.
13
   * Note: `eth_estimateUserOperationGas` does not return paymasterPostOpGasLimit.
14
   */
15
  paymasterVerificationGasLimit: TEntryPointVersion extends "0.7.0"
16
    ? BigNumberish | undefined
17
    : never;
18
}

1
export type UserOperationOverrides<
2
  TEntryPointVersion extends EntryPointVersion = EntryPointVersion,
3
> = Partial<
4
  {
5
    callGasLimit:
6
      | UserOperationStruct<TEntryPointVersion>["callGasLimit"]
7
      | Multiplier;
8
    maxFeePerGas:
9
      | UserOperationStruct<TEntryPointVersion>["maxFeePerGas"]
10
      | Multiplier;
11
    maxPriorityFeePerGas:
12
      | UserOperationStruct<TEntryPointVersion>["maxPriorityFeePerGas"]
13
      | Multiplier;
14
    preVerificationGas:
15
      | UserOperationStruct<TEntryPointVersion>["preVerificationGas"]
16
      | Multiplier;
17
    verificationGasLimit:
18
      | UserOperationStruct<TEntryPointVersion>["verificationGasLimit"]
19
      | Multiplier;
20
21
    /**
22
     * The same state overrides for
23
     * [`eth_call`](https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-eth#eth-call) method.
24
     * An address-to-state mapping, where each entry specifies some state to be ephemerally overridden
25
     * prior to executing the call. State overrides allow you to customize the network state for
26
     * the purpose of the simulation, so this feature is useful when you need to estimate gas
27
     * for user operation scenarios under conditions that aren’t currently present on the live network.
28
     */
29
    stateOverride: StateOverride;
30
  } & UserOperationPaymasterOverrides<TEntryPointVersion>
31
> &
32
  /**
33
   * This can be used to override the nonce or nonce key used when calling `entryPoint.getNonce`
34
   * It is useful when you want to use parallel nonces for user operations
35
   *
36
   * NOTE: not all bundlers fully support this feature and it could be that your bundler will still only include
37
   * one user operation for your account in a bundle
38
   */
39
  Partial<
40
    | {
41
        nonceKey: bigint;
42
        nonce: never;
43
      }
44
    | { nonceKey: never; nonce: bigint }
45
  >;

1
export interface UserOperationReceipt {
2
  /* The request hash of the UserOperation. */
3
  userOpHash: Hash;
4
  /* The entry point address used for the UserOperation. */
5
  entryPoint: Address;
6
  /* The account initiating the UserOperation. */
7
  sender: Address;
8
  /* The nonce used in the UserOperation. */
9
  nonce: BigNumberish;
10
  /* The paymaster used for this UserOperation (or empty). */
11
  paymaster?: Address;
12
  /* The actual amount paid (by account or paymaster) for this UserOperation. */
13
  actualGasCost: BigNumberish;
14
  /* The total gas used by this UserOperation (including preVerification, creation, validation, and execution). */
15
  actualGasUsed: BigNumberish;
16
  /* Indicates whether the execution completed without reverting. */
17
  success: boolean;
18
  /* In case of revert, this is the revert reason. */
19
  reason?: string;
20
  /* The logs generated by this UserOperation (not including logs of other UserOperations in the same bundle). */
21
  logs: string[];
22
  /* The TransactionReceipt object for the entire bundle, not only for this UserOperation. */
23
  receipt: TransactionReceipt;
24
  /* The status of the useroperation. Could be "Mined" or "Preconfirmed". */
25
  status: string;
26
}

1
// Reference: https://eips.ethereum.org/EIPS/eip-4337#definitions
2
export type UserOperationRequest<
3
  TEntryPointVersion extends EntryPointVersion = EntryPointVersion,
4
> = (TEntryPointVersion extends "0.6.0"
5
  ? UserOperationRequest_v6
6
  : TEntryPointVersion extends "0.7.0"
7
    ? UserOperationRequest_v7
8
    : never) &
9
  Eip7702ExtendedFields;

1
export interface UserOperationResponse<
2
  TEntryPointVersion extends EntryPointVersion = EntryPointVersion,
3
> {
4
  /* the User Operation */
5
  userOperation: UserOperationRequest<TEntryPointVersion>;
6
  /* the address of the entry point contract that executed the user operation */
7
  entryPoint: Address;
8
  /* the block number the user operation was included in */
9
  blockNumber: BigNumberish;
10
  /* the hash of the block the user operation was included in */
11
  blockHash: Hash;
12
  /* the hash of the transaction that included the user operation */
13
  transactionHash: Hash;
14
}

1
export type UserOperationStruct<
2
  TEntryPointVersion extends EntryPointVersion = EntryPointVersion,
3
> = (TEntryPointVersion extends "0.6.0"
4
  ? UserOperationStruct_v6
5
  : TEntryPointVersion extends "0.7.0"
6
    ? UserOperationStruct_v7
7
    : never) &
8
  Eip7702ExtendedFields;