abstractionkit/dist/index.d.cts

Account Abstraction 4337 SDK by Candidelabs

//#endregion
//#region src/transport/Transport.d.ts
interface RequestArgs {
  readonly method: string;
  readonly params?: readonly unknown[] | object;
}
interface RequestOptions {
  readonly signal?: AbortSignal;
}
interface ProviderRpcError extends Error {
  readonly code: number;
  readonly data?: unknown;
}
declare class TransportRpcError extends Error implements ProviderRpcError {
  readonly code: number;
  readonly data?: unknown;
  constructor(code: number, message: string, data?: unknown);
}
interface Transport {
  request<T = unknown>(args: RequestArgs, options?: RequestOptions): Promise<T>;
}
interface EventfulTransport extends Transport {
  on(event: string, listener: (...args: unknown[]) => void): void;
  removeListener(event: string, listener: (...args: unknown[]) => void): void;
}
declare function isEventfulTransport(transport: Transport): transport is EventfulTransport;
//#endregion
//#region src/transport/BaseRpcTransport.d.ts
interface JsonRpcEnvelope {
  readonly jsonrpc: "2.0";
  readonly id: number;
  readonly method: string;
  readonly params?: unknown;
}
declare abstract class BaseRpcTransport implements Transport {
  private nextId;
  request<T = unknown>(args: RequestArgs, options?: RequestOptions): Promise<T>;
  protected abstract send(envelope: JsonRpcEnvelope, options?: RequestOptions): Promise<unknown>;
  protected static serializeEnvelope(envelope: JsonRpcEnvelope): string;
  private static parseResponse;
}
//#endregion
//#region src/transport/HttpTransport.d.ts
interface HttpTransportOptions {
  fetch?: typeof globalThis.fetch;
  headers?: Record<string, string>;
}
declare class HttpTransport extends BaseRpcTransport {
  readonly url: string;
  readonly options: HttpTransportOptions;
  constructor(url: string, options?: HttpTransportOptions);
  protected send(envelope: JsonRpcEnvelope, options?: RequestOptions): Promise<unknown>;
}
declare function isHttpTransport(transport: Transport): transport is HttpTransport;
//#endregion
//#region src/utils7702.d.ts
type Authorization7702 = {
  chainId: bigint;
  address: string;
  nonce: bigint;
  yParity: 0 | 1;
  r: bigint;
  s: bigint;
};
type Authorization7702Hex = {
  chainId: string;
  address: string;
  nonce: string;
  yParity: string;
  r: string;
  s: string;
};
declare function createAndSignLegacyRawTransaction(chainId: bigint, nonce: bigint, gas_price: bigint, gas_limit: bigint, destination: string, value: bigint, data: string, eoaPrivateKey: string): string;
declare function createAndSignEip7702DelegationAuthorization(chainId: bigint, address: string, nonce: bigint, signer: string): Authorization7702Hex;
declare function createAndSignEip7702DelegationAuthorization(chainId: bigint, address: string, nonce: bigint, signer: (hash: string) => Promise<string>): Promise<Authorization7702Hex>;
declare function createEip7702DelegationAuthorizationHash(chainId: bigint, address: string, nonce: bigint): string;
declare function signHash(authHash: string, eoaPrivateKey: string): {
  yParity: 0 | 1;
  r: bigint;
  s: bigint;
};
declare function createAndSignEip7702RawTransaction(chainId: bigint, nonce: bigint, max_priority_fee_per_gas: bigint, max_fee_per_gas: bigint, gas_limit: bigint, destination: string, value: bigint, data: string, access_list: [string, string[]][], authorization_list: Authorization7702[], eoaPrivateKey: string): string;
declare function createEip7702TransactionHash(chainId: bigint, nonce: bigint, max_priority_fee_per_gas: bigint, max_fee_per_gas: bigint, gas_limit: bigint, destination: string, value: bigint, data: string, access_list: [string, string[]][], authorization_list: Authorization7702[]): string;
//#endregion
//#region src/types.d.ts
interface BaseUserOperation {
  sender: string;
  nonce: bigint;
  callData: string;
  callGasLimit: bigint;
  verificationGasLimit: bigint;
  preVerificationGas: bigint;
  maxFeePerGas: bigint;
  maxPriorityFeePerGas: bigint;
  signature: string;
}
interface UserOperationV6 extends BaseUserOperation {
  initCode: string;
  paymasterAndData: string;
}
interface UserOperationV7 extends BaseUserOperation {
  factory: string | null;
  factoryData: string | null;
  paymaster: string | null;
  paymasterVerificationGasLimit: bigint | null;
  paymasterPostOpGasLimit: bigint | null;
  paymasterData: string | null;
}
interface UserOperationV8 extends BaseUserOperation {
  factory: string | null;
  factoryData: string | null;
  paymaster: string | null;
  paymasterVerificationGasLimit: bigint | null;
  paymasterPostOpGasLimit: bigint | null;
  paymasterData: string | null;
  eip7702Auth: Authorization7702Hex | null;
}
interface UserOperationV9 extends UserOperationV8 {}
type AbiInputValue = string | bigint | number | boolean | AbiInputValue[];
type JsonRpcParam = string | bigint | boolean | object | JsonRpcParam[];
type JsonRpcResponse = {
  id: number | null;
  jsonrpc: string;
  result?: JsonRpcResult;
  simulation_results?: JsonRpcResult;
  error?: JsonRpcError;
};
type ChainIdResult = string;
type SupportedEntryPointsResult = string[];
type SingleTransactionTenderlySimulationResult = {
  transaction: Record<string, unknown>;
  simulation: {
    id: string;
  } & Record<string, unknown>;
};
type TenderlySimulationResult = SingleTransactionTenderlySimulationResult[];
type JsonRpcResult = ChainIdResult | SupportedEntryPointsResult | GasEstimationResult | UserOperationByHashResult | UserOperationReceipt | UserOperationReceiptResult | SupportedERC20TokensAndMetadata | PmUserOperationV7Result | PmUserOperationV6Result | TenderlySimulationResult;
type JsonRpcError = {
  code: number;
  message: string;
  data: object;
};
type GasEstimationResult = {
  callGasLimit: bigint;
  preVerificationGas: bigint;
  verificationGasLimit: bigint;
  paymasterVerificationGasLimit?: bigint;
  paymasterPostOpGasLimit?: bigint;
};
type UserOperationByHashResult = {
  userOperation: UserOperationV6 | UserOperationV7 | UserOperationV8 | UserOperationV9;
  entryPoint: string;
  blockNumber: bigint | null;
  blockHash: string | null;
  transactionHash: string | null;
} | null;
type Log = {
  address: string;
  topics: string[];
  data: string;
  blockNumber?: string;
  blockHash?: string;
  transactionHash?: string;
  transactionIndex?: string;
  logIndex?: string;
  removed?: boolean;
};
type UserOperationReceipt = {
  blockHash: string;
  blockNumber: bigint;
  from: string;
  cumulativeGasUsed: bigint;
  gasUsed: bigint;
  logs: Log[];
  logsBloom: string;
  transactionHash: string;
  transactionIndex: bigint;
  effectiveGasPrice?: bigint;
};
type UserOperationReceiptResult = {
  userOpHash: string;
  entryPoint: string;
  sender: string;
  nonce: bigint;
  paymaster: string;
  actualGasCost: bigint;
  actualGasUsed: bigint;
  success: boolean;
  logs: Log[];
  receipt: UserOperationReceipt;
} | null;
type SponsorMetadata = {
  name: string;
  description: string;
  url: string;
  icons: string[];
};
type TokenQuote = {
  token: string;
  exchangeRate: bigint;
  tokenCost: bigint;
};
type SponsorInfo = {
  name: string;
  icon?: string;
};
type PmUserOperationV7Result = {
  paymaster: string;
  paymasterVerificationGasLimit: bigint;
  paymasterPostOpGasLimit: bigint;
  paymasterData: string;
  callGasLimit?: bigint;
  verificationGasLimit?: bigint;
  preVerificationGas?: bigint;
  maxFeePerGas?: bigint;
  maxPriorityFeePerGas?: bigint;
  sponsor?: SponsorInfo;
};
type PmUserOperationV6Result = {
  paymasterAndData: string;
  callGasLimit?: bigint;
  preVerificationGas?: bigint;
  verificationGasLimit?: bigint;
  maxFeePerGas?: bigint;
  maxPriorityFeePerGas?: bigint;
  sponsor?: SponsorInfo;
};
declare enum Operation {
  Call = 0,
  Delegate = 1
}
interface MetaTransaction {
  to: string;
  value: bigint;
  data: string;
  operation?: Operation;
}
interface ERC20Token {
  name: string;
  symbol: string;
  address: string;
  decimals: number;
}
interface ERC20TokenWithExchangeRate extends ERC20Token {
  exchangeRate: bigint;
}
interface PaymasterMetadata {
  name: string;
  description: string;
  icons: string[];
  address: string;
  sponsoredEventTopic: string;
  dummyPaymasterAndData: {
    paymaster: string;
    paymasterVerificationGasLimit: bigint;
    paymasterPostOpGasLimit: bigint;
    paymasterData: string;
  } | string;
}
interface SupportedERC20TokensAndMetadata {
  paymasterMetadata: PaymasterMetadata;
  tokens: ERC20Token[];
}
interface SupportedERC20TokensAndMetadataWithExchangeRate {
  paymasterMetadata: PaymasterMetadata;
  tokens: ERC20TokenWithExchangeRate[];
}
interface Dictionary<T> {
  [Key: string]: T;
}
type AddressToState = {
  balance?: bigint;
  nonce?: bigint;
  code?: string;
  state?: Dictionary<string>;
  stateDiff?: Dictionary<string>;
};
type StateOverrideSet = {
  [key: string]: AddressToState;
};
declare enum GasOption {
  Slow = 1,
  Medium = 1.2,
  Fast = 1.5
}
declare enum PolygonChain {
  Mainnet = "v2",
  ZkMainnet = "zkevm",
  Amoy = "amoy",
  Cardona = "cardona"
}
type OnChainIdentifierParamsType = {
  project: string;
  platform?: "Web" | "Mobile" | "Safe App" | "Widget";
  tool?: string;
  toolVersion?: string;
};
interface ParallelPaymasterInitValues {
  paymaster: string;
  paymasterVerificationGasLimit: bigint;
  paymasterPostOpGasLimit: bigint;
  paymasterData: string;
}
//#endregion
//#region src/signer/types.d.ts
interface TypedData {
  domain: {
    name?: string;
    version?: string;
    chainId?: number | bigint;
    verifyingContract?: `0x${string}`;
    salt?: `0x${string}`;
  };
  types: Record<string, Array<{
    name: string;
    type: string;
  }>>;
  primaryType: string;
  message: Record<string, unknown>;
}
type SigningScheme = "hash" | "typedData";
interface SignContext<T extends BaseUserOperation = BaseUserOperation> {
  readonly userOperation: T;
  readonly chainId: bigint;
  readonly entryPoint: string;
}
interface MultiOpSignContext<T extends BaseUserOperation = BaseUserOperation> {
  readonly userOperations: ReadonlyArray<{
    readonly userOperation: T;
    readonly chainId: bigint;
  }>;
  readonly entryPoint: string;
}
interface ExternalSignerBase {
  readonly address: `0x${string}`;
  readonly type?: "ecdsa" | "contract";
}
type SignHashFn<C = SignContext> = (hash: `0x${string}`, context: C) => `0x${string}` | Promise<`0x${string}`>;
type SignTypedDataFn<C = SignContext> = (data: TypedData, context: C) => `0x${string}` | Promise<`0x${string}`>;
type ExternalSigner<C = SignContext> = ExternalSignerBase & ({
  signHash: SignHashFn<C>;
  signTypedData?: SignTypedDataFn<C>;
} | {
  signHash?: SignHashFn<C>;
  signTypedData: SignTypedDataFn<C>;
});
//#endregion
//#region src/utils.d.ts
declare function createUserOperationHash(useroperation: UserOperationV6 | UserOperationV7 | UserOperationV8 | UserOperationV9, entrypointAddress: string, chainId: bigint): string;
declare function createCallData(functionSelector: string, functionInputAbi: string[], functionInputParameters: AbiInputValue[]): string;
declare function sendJsonRpcRequest(rpc: string | Transport | JsonRpcNode, method: string, params: JsonRpcParam, headers?: Record<string, string>, paramsKeyName?: string): Promise<JsonRpcResult>;
declare function getFunctionSelector(functionSignature: string): string;
declare function fetchAccountNonce(rpc: string | Transport | JsonRpcNode, entryPoint: string, account: string, key?: number | bigint): Promise<bigint>;
declare function calculateUserOperationMaxGasCost(useroperation: UserOperationV6 | UserOperationV7): bigint;
type DepositInfo = {
  deposit: bigint;
  staked: boolean;
  stake: bigint;
  unstakeDelaySec: bigint;
  withdrawTime: bigint;
};
//#endregion
//#region src/transport/JsonRpcNode.d.ts
type EthCallTransaction = {
  from?: string;
  to: string;
  gas?: bigint;
  gasPrice?: bigint;
  value?: bigint;
  data?: string;
};
declare class JsonRpcNode implements Transport {
  readonly transport: Transport;
  private readonly outbound;
  constructor(rpc: string | Transport);
  static from(input: string | Transport | JsonRpcNode): JsonRpcNode;
  request<T = unknown>(args: RequestArgs, options?: RequestOptions): Promise<T>;
  chainId(options?: RequestOptions): Promise<string>;
  blockNumber(options?: RequestOptions): Promise<bigint>;
  getCode(address: string, blockTag?: string | bigint, options?: RequestOptions): Promise<string>;
  getStorageAt(address: string, slot: string, blockTag?: string | bigint, options?: RequestOptions): Promise<string>;
  call(tx: EthCallTransaction, blockTag?: string | bigint, stateOverrides?: object, options?: RequestOptions): Promise<string>;
  getTransactionCount(address: string, blockTag?: string | bigint, options?: RequestOptions): Promise<bigint>;
  getFeeData(gasLevel?: GasOption, options?: RequestOptions): Promise<[bigint, bigint]>;
  getDelegatedAddress(accountAddress: string, options?: RequestOptions): Promise<string | null>;
  getEntryPointNonce(entryPoint: string, account: string, key?: bigint, options?: RequestOptions): Promise<bigint>;
  getEntryPointDeposit(address: string, entryPoint: string, options?: RequestOptions): Promise<bigint>;
  getEntryPointDepositInfo(address: string, entryPoint: string, options?: RequestOptions): Promise<DepositInfo>;
}
//#endregion
//#region src/Bundler.d.ts
declare class Bundler implements Transport {
  readonly transport: Transport;
  private readonly outbound;
  constructor(rpc: string | Transport);
  static from(input: string | Transport | Bundler): Bundler;
  request<T = unknown>(args: RequestArgs, options?: RequestOptions): Promise<T>;
  chainId(): Promise<string>;
  supportedEntryPoints(): Promise<string[]>;
  estimateUserOperationGas(useroperation: UserOperationV6 | UserOperationV7 | UserOperationV8 | UserOperationV9, entrypointAddress: string, state_override_set?: StateOverrideSet): Promise<GasEstimationResult>;
  sendUserOperation(useroperation: UserOperationV6 | UserOperationV7 | UserOperationV8 | UserOperationV9, entrypointAddress: string): Promise<string>;
  getUserOperationReceipt(useroperationhash: string): Promise<UserOperationReceiptResult>;
  getUserOperationByHash(useroperationhash: string): Promise<UserOperationByHashResult>;
}
//#endregion
//#region src/paymaster/types.d.ts
type AnyUserOperation = UserOperationV9 | UserOperationV8 | UserOperationV7 | UserOperationV6;
type SameUserOp<T extends AnyUserOperation> = T extends UserOperationV9 ? UserOperationV9 : T extends UserOperationV8 ? UserOperationV8 : T extends UserOperationV7 ? UserOperationV7 : UserOperationV6;
interface CandidePaymasterContext {
  token?: string;
  sponsorshipPolicyId?: string;
  signingPhase?: "commit" | "finalize";
}
interface SmartAccountWithEntrypoint {
  readonly entrypointAddress: string;
}
interface PrependTokenPaymasterApproveAccount extends SmartAccountWithEntrypoint {
  prependTokenPaymasterApproveToCallData(callData: string, tokenAddress: string, paymasterAddress: string, approveAmount: bigint): string;
}
type Erc7677Provider = "pimlico" | "candide" | null;
interface Erc7677PaymasterConstructorOptions {
  chainId?: bigint;
  provider?: "auto" | Erc7677Provider;
}
interface BasePaymasterUserOperationOverrides {
  entrypoint?: string;
  resetApproval?: boolean;
}
interface GasPaymasterUserOperationOverrides extends BasePaymasterUserOperationOverrides {
  callGasLimit?: bigint;
  verificationGasLimit?: bigint;
  preVerificationGas?: bigint;
  callGasLimitPercentageMultiplier?: number;
  verificationGasLimitPercentageMultiplier?: number;
  preVerificationGasPercentageMultiplier?: number;
  state_override_set?: StateOverrideSet;
}
//#endregion
//#region src/account/SendUseroperationResponse.d.ts
declare class SendUseroperationResponse {
  readonly userOperationHash: string;
  readonly bundler: Bundler;
  readonly entrypointAddress: string;
  constructor(userOperationHash: string, bundler: Bundler, entrypointAddress: string);
  private delay;
  included(timeoutInSeconds?: number, requestIntervalInSeconds?: number): Promise<UserOperationReceiptResult>;
}
//#endregion
//#region src/account/SmartAccount.d.ts
declare abstract class SmartAccount {
  readonly accountAddress: string;
  static readonly proxyByteCode: string;
  static readonly initializerFunctionSelector: string;
  static readonly initializerFunctionInputAbi: string[];
  static readonly executorFunctionSelector: string;
  static readonly executorFunctionInputAbi: string[];
  constructor(accountAddress: string);
}
//#endregion
//#region src/account/simple/Simple7702Account.d.ts
interface SimpleMetaTransaction {
  to: string;
  value: bigint;
  data: string;
}
interface CreateUserOperationOverrides {
  nonce?: bigint;
  callData?: string;
  callGasLimit?: bigint;
  verificationGasLimit?: bigint;
  preVerificationGas?: bigint;
  maxFeePerGas?: bigint;
  maxPriorityFeePerGas?: bigint;
  callGasLimitPercentageMultiplier?: number;
  verificationGasLimitPercentageMultiplier?: number;
  preVerificationGasPercentageMultiplier?: number;
  maxFeePerGasPercentageMultiplier?: number;
  maxPriorityFeePerGasPercentageMultiplier?: number;
  state_override_set?: StateOverrideSet;
  skipGasEstimation?: boolean;
  dummySignature?: string;
  gasLevel?: GasOption;
  polygonGasStation?: PolygonChain;
  eip7702Auth?: {
    chainId: bigint;
    address?: string;
    nonce?: bigint;
    yParity?: string;
    r?: string;
    s?: string;
  };
  parallelPaymasterInitValues?: {
    paymaster: string;
    paymasterVerificationGasLimit: bigint;
    paymasterPostOpGasLimit: bigint;
    paymasterData: string;
  };
}
declare class BaseSimple7702Account extends SmartAccount {
  static readonly executorFunctionSelector = "0xb61d27f6";
  static readonly executorFunctionInputAbi: string[];
  static readonly batchExecutorFunctionSelector = "0x34fcd5be";
  static readonly batchExecutorFunctionInputAbi: string[];
  static readonly dummySignature = "0xd2614025fc173b86704caf37b2fb447f7618101a0d31f5f304c777024cef38a060a29ee43fcf0c46f9107d4f670b8a85c2c017a1fe9e4af891f24f0be6ba5d671c";
  readonly entrypointAddress: string;
  readonly delegateeAddress: string;
  constructor(accountAddress: string, entrypointAddress: string, delegateeAddress: string);
  isDelegatedToThisAccount(providerRpc: string | Transport | JsonRpcNode): Promise<boolean>;
  createRevokeDelegationTransaction(eoaPrivateKey: string, providerRpc: string | Transport | JsonRpcNode, overrides?: {
    nonce?: bigint;
    authorizationNonce?: bigint;
    maxFeePerGas?: bigint;
    maxPriorityFeePerGas?: bigint;
    gasLimit?: bigint;
    chainId?: bigint;
  }): Promise<string>;
  static createAccountCallData(to: string, value: bigint, data: string): string;
  static createAccountCallDataSingleTransaction(metaTransaction: SimpleMetaTransaction): string;
  static createAccountCallDataBatchTransactions(transactions: SimpleMetaTransaction[]): string;
  protected baseCreateUserOperation(transactions: SimpleMetaTransaction[], providerRpc?: string | Transport | JsonRpcNode, bundlerRpc?: string | Transport | Bundler, overrides?: CreateUserOperationOverrides): Promise<UserOperationV8 | UserOperationV9>;
  protected baseEstimateUserOperationGas(userOperation: UserOperationV8 | UserOperationV9, bundlerRpc: string | Transport | Bundler, overrides?: {
    stateOverrideSet?: StateOverrideSet;
    dummySignature?: string;
  }): Promise<[bigint, bigint, bigint]>;
  protected baseSignUserOperation(useroperation: UserOperationV8 | UserOperationV9, privateKey: string, chainId: bigint): string;
  static readonly ACCEPTED_SIGNING_SCHEMES: readonly SigningScheme[];
  static getUserOperationEip712Data(userOperation: UserOperationV8 | UserOperationV9, chainId: bigint, overrides?: {
    entrypointAddress?: string;
  }): TypedData;
  static getUserOperationEip712Hash(userOperation: UserOperationV8 | UserOperationV9, chainId: bigint, overrides?: {
    entrypointAddress?: string;
  }): string;
  protected baseSignUserOperationWithSigner<T extends UserOperationV8 | UserOperationV9>(useroperation: T, signer: ExternalSigner, chainId: bigint): Promise<string>;
  protected baseSendUserOperation(userOperation: UserOperationV8 | UserOperationV9, bundlerRpc: string | Transport | Bundler): Promise<SendUseroperationResponse>;
  prependTokenPaymasterApproveToCallData(callData: string, tokenAddress: string, paymasterAddress: string, approveAmount: bigint): string;
  static prependTokenPaymasterApproveToCallDataStatic(callData: string, tokenAddress: string, paymasterAddress: string, approveAmount: bigint): string;
}
declare class Simple7702Account extends BaseSimple7702Account {
  static readonly DEFAULT_DELEGATEE_ADDRESS = "0xe6Cae83BdE06E4c305530e199D7217f42808555B";
  constructor(accountAddress: string, overrides?: {
    entrypointAddress?: string;
    delegateeAddress?: string;
  });
  createUserOperation(transactions: SimpleMetaTransaction[], providerRpc?: string | Transport | JsonRpcNode, bundlerRpc?: string | Transport | Bundler, overrides?: CreateUserOperationOverrides): Promise<UserOperationV8>;
  estimateUserOperationGas(userOperation: UserOperationV8, bundlerRpc: string | Transport | Bundler, overrides?: {
    stateOverrideSet?: StateOverrideSet;
    dummySignature?: string;
  }): Promise<[bigint, bigint, bigint]>;
  signUserOperation(useroperation: UserOperationV8, privateKey: string, chainId: bigint): string;
  signUserOperationWithSigner(useroperation: UserOperationV8, signer: ExternalSigner, chainId: bigint): Promise<string>;
  sendUserOperation(userOperation: UserOperationV8, bundlerRpc: string | Transport | Bundler): Promise<SendUseroperationResponse>;
}
//#endregion
//#region src/account/Calibur/types.d.ts
declare enum CaliburKeyType {
  P256 = 0,
  WebAuthnP256 = 1,
  Secp256k1 = 2
}
interface CaliburKey {
  keyType: CaliburKeyType;
  publicKey: string;
}
interface CaliburKeySettings {
  hook?: string;
  expiration?: number;
  isAdmin?: boolean;
}
interface CaliburKeySettingsResult {
  hook: string;
  expiration: number;
  isAdmin: boolean;
}
interface WebAuthnSignatureData {
  authenticatorData: string;
  clientDataJSON: string;
  challengeIndex: bigint;
  typeIndex: bigint;
  r: bigint;
  s: bigint;
}
interface CaliburCreateUserOperationOverrides {
  nonce?: bigint;
  callData?: string;
  callGasLimit?: bigint;
  verificationGasLimit?: bigint;
  preVerificationGas?: bigint;
  maxFeePerGas?: bigint;
  maxPriorityFeePerGas?: bigint;
  callGasLimitPercentageMultiplier?: number;
  verificationGasLimitPercentageMultiplier?: number;
  preVerificationGasPercentageMultiplier?: number;
  maxFeePerGasPercentageMultiplier?: number;
  maxPriorityFeePerGasPercentageMultiplier?: number;
  state_override_set?: StateOverrideSet;
  skipGasEstimation?: boolean;
  dummySignature?: string;
  gasLevel?: GasOption;
  polygonGasStation?: PolygonChain;
  revertOnFailure?: boolean;
  paymasterFields?: ParallelPaymasterInitValues;
  eip7702Auth?: {
    chainId: bigint;
    address?: string;
    nonce?: bigint;
    yParity?: string;
    r?: string;
    s?: string;
  };
}
interface CaliburSignatureOverrides {
  hookData?: string;
  keyHash?: string;
}
//#endregion
//#region src/account/Calibur/Calibur7702Account.d.ts
declare class Calibur7702Account extends SmartAccount implements PrependTokenPaymasterApproveAccount {
  static readonly executorFunctionSelector = "0x8dd7712f";
  static readonly dummySignature: string;
  static createDummyWebAuthnSignature(keyHash: string): string;
  static wrapSignature(keyHash: string, rawSignature: string, hookData?: string): string;
  static formatEip712SingleSignatureToUseroperationSignature(signature: string, overrides?: CaliburSignatureOverrides): string;
  readonly entrypointAddress: string;
  readonly delegateeAddress: string;
  constructor(accountAddress: string, overrides?: {
    entrypointAddress?: string;
    delegateeAddress?: string;
  });
  getUserOperationHash(userOperation: UserOperationV8, chainId: bigint): string;
  static getUserOperationEip712Data(userOperation: UserOperationV8 | UserOperationV9, chainId: bigint, overrides?: {
    entrypointAddress?: string;
  }): TypedData;
  static getUserOperationEip712Hash(userOperation: UserOperationV8 | UserOperationV9, chainId: bigint, overrides?: {
    entrypointAddress?: string;
  }): string;
  static createAccountCallData(transactions: SimpleMetaTransaction[], revertOnFailure?: boolean): string;
  createUserOperation(transactions: SimpleMetaTransaction[], providerRpc?: string | Transport | JsonRpcNode, bundlerRpc?: string | Transport | Bundler, overrides?: CaliburCreateUserOperationOverrides): Promise<UserOperationV8>;
  signUserOperation(userOperation: UserOperationV8, privateKey: string, chainId: bigint, overrides?: CaliburSignatureOverrides): string;
  static readonly ACCEPTED_SIGNING_SCHEMES: readonly SigningScheme[];
  signUserOperationWithSigner(userOperation: UserOperationV8, signer: ExternalSigner, chainId: bigint, overrides?: CaliburSignatureOverrides): Promise<string>;
  formatWebAuthnSignature(keyHash: string, webAuthnAuth: WebAuthnSignatureData, overrides?: CaliburSignatureOverrides): string;
  sendUserOperation(userOperation: UserOperationV8, bundlerRpc: string | Transport | Bundler): Promise<SendUseroperationResponse>;
  static createSecp256k1Key(address: string): CaliburKey;
  static createWebAuthnP256Key(x: bigint, y: bigint): CaliburKey;
  static createP256Key(x: bigint, y: bigint): CaliburKey;
  static getKeyHash(key: CaliburKey): string;
  static packKeySettings(settings: CaliburKeySettings): bigint;
  static unpackKeySettings(packed: bigint): CaliburKeySettingsResult;
  static createRegisterKeyMetaTransactions(key: CaliburKey, settings?: CaliburKeySettings): [SimpleMetaTransaction, SimpleMetaTransaction];
  static createRevokeKeyMetaTransaction(keyHash: string): SimpleMetaTransaction;
  createRevokeAllKeysMetaTransactions(providerRpc: string | Transport | JsonRpcNode): Promise<SimpleMetaTransaction[]>;
  createRevokeDelegationRawTransaction(chainId: bigint, eoaPrivateKey: string, providerRpc: string | Transport | JsonRpcNode, overrides?: {
    nonce?: bigint;
    authorizationNonce?: bigint;
    maxFeePerGas?: bigint;
    maxPriorityFeePerGas?: bigint;
    gasLimit?: bigint;
  }): Promise<string>;
  static createUpdateKeySettingsMetaTransaction(keyHash: string, settings: CaliburKeySettings): SimpleMetaTransaction;
  static createInvalidateNonceMetaTransaction(newNonce: bigint): SimpleMetaTransaction;
  isDelegatedToThisAccount(providerRpc: string | Transport | JsonRpcNode): Promise<boolean>;
  getNonce(providerRpc: string | Transport | JsonRpcNode, sequenceKey?: number): Promise<bigint>;
  isKeyRegistered(providerRpc: string | Transport | JsonRpcNode, keyHash: string): Promise<boolean>;
  getKeySettings(providerRpc: string | Transport | JsonRpcNode, keyHash: string): Promise<CaliburKeySettingsResult>;
  getKey(providerRpc: string | Transport | JsonRpcNode, keyHash: string): Promise<CaliburKey>;
  getKeys(providerRpc: string | Transport | JsonRpcNode, overrides?: {
    blockNumber?: bigint;
  }): Promise<CaliburKey[]>;
  prependTokenPaymasterApproveToCallData(callData: string, tokenAddress: string, paymasterAddress: string, approveAmount: bigint): string;
  static prependTokenPaymasterApproveToCallDataStatic(callData: string, tokenAddress: string, paymasterAddress: string, approveAmount: bigint): string;
}
//#endregion
//#region src/account/Safe/modules/SafeModule.d.ts
declare abstract class SafeModule {
  readonly moduleAddress: string;
  constructor(moduleAddress: string);
  createEnableModuleMetaTransaction(accountAddress: string): MetaTransaction;
  checkForEmptyResultAndRevert(result: string, requestName: string): void;
}
//#endregion
//#region src/account/Safe/modules/AllowanceModule.d.ts
declare const ALLOWANCE_MODULE_V0_1_0_ADDRESS = "0xAA46724893dedD72658219405185Fb0Fc91e091C";
declare class AllowanceModule extends SafeModule {
  static readonly DEFAULT_ALLOWANCE_MODULE_ADDRESS = "0x691f59471Bfd2B7d639DCF74671a2d648ED1E331";
  constructor(moduleAddress?: string);
  createOneTimeAllowanceMetaTransaction(delegate: string, token: string, allowanceAmount: bigint): MetaTransaction;
  createRecurringAllowanceMetaTransaction(delegate: string, token: string, allowanceAmount: bigint, recurringAllowanceValidityPeriodInMinutes: bigint, inThePastPeriodStartBaseTimeStamp?: bigint): MetaTransaction;
  createBaseSetAllowanceMetaTransaction(delegate: string, token: string, allowanceAmount: bigint, resetTimeMin: bigint, resetBaseMin: bigint): MetaTransaction;
  createRenewAllowanceMetaTransaction(delegate: string, token: string): MetaTransaction;
  createDeleteAllowanceMetaTransaction(delegate: string, token: string): MetaTransaction;
  createAllowanceTransferMetaTransaction(allowanceSourceSafeAddress: string, token: string, to: string, amount: bigint, delegate: string, overrides?: {
    delegateSignature?: string;
    paymentToken?: string;
    paymentAmount?: bigint;
  }): MetaTransaction;
  createBaseExecuteAllowanceTransferMetaTransaction(safeAddress: string, token: string, to: string, amount: bigint, paymentToken: string, payment: bigint, delegate: string, delegateSignature: string): MetaTransaction;
  createAddDelegateMetaTransaction(delegate: string): MetaTransaction;
  createRemoveDelegateMetaTransaction(delegate: string, removeAllowances: boolean): MetaTransaction;
  getTokens(nodeRpcUrl: string | Transport | JsonRpcNode, safeAddress: string, delegate: string): Promise<string[]>;
  getTokensAllowance(nodeRpcUrl: string | Transport | JsonRpcNode, safeAddress: string, delegate: string, token: string): Promise<Allowance>;
  getDelegates(nodeRpcUrl: string | Transport | JsonRpcNode, safeAddress: string, overrides?: {
    start?: bigint;
    maxNumberOfResults?: bigint;
  }): Promise<string[]>;
  baseGetDelegates(nodeRpcUrl: string | Transport | JsonRpcNode, safeAddress: string, start: bigint, pageSize: bigint): Promise<{
    results: string[];
    next: bigint;
  }>;
}
type Allowance = {
  amount: bigint;
  spent: bigint;
  resetTimeMin: bigint;
  lastResetMin: bigint;
  nonce: bigint;
};
//#endregion
//#region src/account/Safe/modules/SocialRecoveryModule.d.ts
declare enum SocialRecoveryModuleGracePeriodSelector {
  After3Minutes = "0x949d01d424bE050D09C16025dd007CB59b3A8c66",
  After3Days = "0x38275826E1933303E508433dD5f289315Da2541c",
  After7Days = "0x088f6cfD8BB1dDb1BB069CCb3fc1A98927D233f2",
  After14Days = "0x9BacD92F4687Db306D7ded5d4513a51EA05df25b"
}
declare class SocialRecoveryModule extends SafeModule {
  static readonly DEFAULT_SOCIAL_RECOVERY_ADDRESS = SocialRecoveryModuleGracePeriodSelector.After3Days;
  constructor(moduleAddress?: string);
  createConfirmRecoveryMetaTransaction(accountAddress: string, newOwners: string[], newThreshold: number, execute: boolean): MetaTransaction;
  createMultiConfirmRecoveryMetaTransaction(accountAddress: string, newOwners: string[], newThreshold: number, signaturePairList: RecoverySignaturePair[], execute: boolean): MetaTransaction;
  createExecuteRecoveryMetaTransaction(accountAddress: string, newOwners: string[], newThreshold: number): MetaTransaction;
  createFinalizeRecoveryMetaTransaction(accountAddress: string): MetaTransaction;
  createCancelRecoveryMetaTransaction(): MetaTransaction;
  createAddGuardianWithThresholdMetaTransaction(guardianAddress: string, threshold: bigint): MetaTransaction;
  createRevokeGuardianWithThresholdMetaTransaction(nodeRpcUrl: string | Transport | JsonRpcNode, accountAddress: string, guardianAddress: string, threshold: bigint, overrides?: {
    prevGuardianAddress?: string;
  }): Promise<MetaTransaction>;
  createStandardRevokeGuardianWithThresholdMetaTransaction(prevGuardianAddress: string, guardianAddress: string, threshold: bigint): MetaTransaction;
  createChangeThresholdMetaTransaction(threshold: bigint): MetaTransaction;
  getRecoveryHash(nodeRpcUrl: string | Transport | JsonRpcNode, accountAddress: string, newOwners: string[], newThreshold: number, nonce: bigint): Promise<string>;
  getRecoveryRequest(nodeRpcUrl: string | Transport | JsonRpcNode, accountAddress: string): Promise<RecoveryRequest>;
  getRecoveryApprovals(nodeRpcUrl: string | Transport | JsonRpcNode, accountAddress: string, newOwners: string[], newThreshold: number): Promise<bigint>;
  hasGuardianApproved(nodeRpcUrl: string | Transport | JsonRpcNode, accountAddress: string, guardian: string, newOwners: string[], newThreshold: number): Promise<boolean>;
  isGuardian(nodeRpcUrl: string | Transport | JsonRpcNode, accountAddress: string, guardian: string): Promise<boolean>;
  guardiansCount(nodeRpcUrl: string | Transport | JsonRpcNode, accountAddress: string): Promise<bigint>;
  threshold(nodeRpcUrl: string | Transport | JsonRpcNode, accountAddress: string): Promise<bigint>;
  getGuardians(nodeRpcUrl: string | Transport | JsonRpcNode, accountAddress: string): Promise<string[]>;
  nonce(nodeRpcUrl: string | Transport | JsonRpcNode, accountAddress: string): Promise<bigint>;
  getRecoveryRequestEip712Data(rpcNode: string | Transport | JsonRpcNode, chainId: bigint, accountAddress: string, newOwners: string[], newThreshold: bigint, overrides?: {
    recoveryNonce?: bigint;
  }): Promise<{
    domain: RecoveryRequestTypedDataDomain;
    types: Record<string, {
      name: string;
      type: string;
    }[]>;
    messageValue: RecoveryRequestTypedMessageValue;
  }>;
}
type RecoveryRequest = {
  guardiansApprovalCount: bigint;
  newThreshold: bigint;
  executeAfter: bigint;
  newOwners: string[];
};
type RecoverySignaturePair = {
  signer: string;
  signature: string;
};
declare const EXECUTE_RECOVERY_PRIMARY_TYPE = "ExecuteRecovery";
type RecoveryRequestTypedDataDomain = {
  name: string;
  version: string;
  chainId: number;
  verifyingContract: string;
};
type RecoveryRequestTypedMessageValue = {
  wallet: string;
  newOwners: string[];
  newThreshold: bigint;
  nonce: bigint;
};
declare const EIP712_RECOVERY_MODULE_TYPE: {
  ExecuteRecovery: {
    type: string;
    name: string;
  }[];
};
//#endregion
//#region src/account/Safe/safeMessage.d.ts
declare const SAFE_MESSAGE_PRIMARY_TYPE = "SafeMessage";
declare const SAFE_MESSAGE_MODULE_TYPE: {
  SafeMessage: {
    type: string;
    name: string;
  }[];
};
type SafeMessageTypedDataDomain = {
  chainId: number;
  verifyingContract: string;
};
type SafeMessageTypedMessageValue = {
  message: string;
};
declare function getSafeMessageEip712Data(accountAddress: string, chainId: bigint, message: string): {
  domain: SafeMessageTypedDataDomain;
  types: Record<string, {
    name: string;
    type: string;
  }[]>;
  messageValue: SafeMessageTypedMessageValue;
};
//#endregion
//#region src/account/Safe/types.d.ts
interface CreateBaseUserOperationOverrides {
  nonce?: bigint;
  callData?: string;
  callGasLimit?: bigint;
  verificationGasLimit?: bigint;
  preVerificationGas?: bigint;
  maxFeePerGas?: bigint;
  maxPriorityFeePerGas?: bigint;
  callGasLimitPercentageMultiplier?: number;
  verificationGasLimitPercentageMultiplier?: number;
  preVerificationGasPercentageMultiplier?: number;
  maxFeePerGasPercentageMultiplier?: number;
  maxPriorityFeePerGasPercentageMultiplier?: number;
  state_override_set?: StateOverrideSet;
  skipGasEstimation?: boolean;
  dummySignerSignaturePairs?: SignerSignaturePair[];
  webAuthnSharedSigner?: string;
  webAuthnSignerFactory?: string;
  webAuthnSignerSingleton?: string;
  webAuthnSignerProxyCreationCode?: string;
  eip7212WebAuthnPrecompileVerifier?: string;
  eip7212WebAuthnContractVerifier?: string;
  safeModuleExecutorFunctionSelector?: SafeModuleExecutorFunctionSelector;
  multisendContractAddress?: string;
  gasLevel?: GasOption;
  polygonGasStation?: PolygonChain;
  expectedSigners?: Signer[];
  isMultiChainSignature?: boolean;
  parallelPaymasterInitValues?: {
    paymaster: string;
    paymasterVerificationGasLimit: bigint;
    paymasterPostOpGasLimit: bigint;
    paymasterData: string;
  };
}
interface CreateUserOperationV6Overrides extends CreateBaseUserOperationOverrides {
  initCode?: string;
}
interface CreateUserOperationV7Overrides extends CreateBaseUserOperationOverrides {
  factory?: string;
  factoryData?: string;
}
interface CreateUserOperationV9Overrides extends CreateUserOperationV7Overrides {}
interface SafeAccountSingleton {
  singletonAddress: string;
  singletonInitHash: string;
}
interface InitCodeOverrides {
  threshold?: number;
  c2Nonce?: bigint;
  safe4337ModuleAddress?: string;
  safeModuleSetupAddress?: string;
  entrypointAddress?: string;
  safeAccountSingleton?: SafeAccountSingleton;
  safeAccountFactoryAddress?: string;
  multisendContractAddress?: string;
  webAuthnSharedSigner?: string;
  eip7212WebAuthnPrecompileVerifierForSharedSigner?: string;
  eip7212WebAuthnContractVerifierForSharedSigner?: string;
  onChainIdentifierParams?: OnChainIdentifierParamsType;
  onChainIdentifier?: string;
}
interface BaseInitOverrides {
  threshold?: number;
  c2Nonce?: bigint;
  safeAccountSingleton?: SafeAccountSingleton;
  safeAccountFactoryAddress?: string;
  multisendContractAddress?: string;
  webAuthnSharedSigner?: string;
  eip7212WebAuthnPrecompileVerifierForSharedSigner?: string;
  eip7212WebAuthnContractVerifierForSharedSigner?: string;
}
interface WebAuthnSignatureOverrides {
  isInit?: boolean;
  webAuthnSharedSigner?: string;
  eip7212WebAuthnPrecompileVerifier?: string;
  eip7212WebAuthnContractVerifier?: string;
  webAuthnSignerFactory?: string;
  webAuthnSignerSingleton?: string;
  webAuthnSignerProxyCreationCode?: string;
}
interface SafeSignatureOptions {
  validAfter?: bigint;
  validUntil?: bigint;
  isMultiChainSignature?: boolean;
  multiChainMerkleProof?: string;
  safe4337ModuleAddress?: string;
}
declare enum SafeModuleExecutorFunctionSelector {
  executeUserOpWithErrorString = "0x541d63c8",
  executeUserOp = "0x7bb37428"
}
interface SafeUserOperationTypedDataDomain {
  chainId: number;
  verifyingContract: string;
}
interface SafeUserOperationV6TypedMessageValue {
  safe: string;
  nonce: bigint;
  initCode: string;
  callData: string;
  callGasLimit: bigint;
  verificationGasLimit: bigint;
  preVerificationGas: bigint;
  maxFeePerGas: bigint;
  maxPriorityFeePerGas: bigint;
  paymasterAndData: string;
  validAfter: bigint;
  validUntil: bigint;
  entryPoint: string;
}
interface SafeUserOperationV7TypedMessageValue {
  safe: string;
  nonce: bigint;
  initCode: string;
  callData: string;
  verificationGasLimit: bigint;
  callGasLimit: bigint;
  preVerificationGas: bigint;
  maxPriorityFeePerGas: bigint;
  maxFeePerGas: bigint;
  paymasterAndData: string;
  validAfter: bigint;
  validUntil: bigint;
  entryPoint: string;
}
interface SafeUserOperationV9TypedMessageValue extends SafeUserOperationV7TypedMessageValue {}
type ECDSAPublicAddress = string;
interface WebauthnPublicKey {
  x: bigint;
  y: bigint;
}
type Signer = ECDSAPublicAddress | WebauthnPublicKey;
interface WebauthnSignatureData {
  authenticatorData: ArrayBuffer;
  clientDataFields: string;
  rs: [bigint, bigint];
}
interface SignerSignaturePair {
  signer: Signer;
  signature: string;
  isContractSignature?: boolean;
}
declare const EOADummySignerSignaturePair: SignerSignaturePair;
declare const WebauthnDummySignerSignaturePair: SignerSignaturePair;
interface UserOperationToSign {
  chainId: bigint;
  userOperation: UserOperationV9;
  validAfter?: bigint;
  validUntil?: bigint;
}
interface UserOperationToSignWithOverrides extends UserOperationToSign {
  options?: SafeSignatureOptions;
  webAuthnSignatureOverrides?: WebAuthnSignatureOverrides;
}
interface MultiChainSignatureMerkleTreeRootTypedDataDomain {
  verifyingContract: string;
}
interface MultiChainSignatureMerkleTreeRootTypedMessageValue {
  merkleTreeRoot: string;
}
//#endregion
//#region src/account/Safe/SafeAccount.d.ts
declare class SafeAccount extends SmartAccount {
  static readonly DEFAULT_WEB_AUTHN_SHARED_SIGNER: string;
  static readonly DEFAULT_WEB_AUTHN_SIGNER_SINGLETON: string;
  static readonly DEFAULT_WEB_AUTHN_SIGNER_FACTORY: string;
  static readonly DEFAULT_WEB_AUTHN_CONTRACT_VERIFIER: string;
  static readonly DEFAULT_WEB_AUTHN_PRECOMPILE: string;
  static readonly DEFAULT_WEB_AUTHN_SIGNER_PROXY_CREATION_CODE: string;
  static readonly DEFAULT_MULTISEND_CONTRACT_ADDRESS = "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526";
  static readonly initializerFunctionSelector: string;
  static readonly initializerFunctionInputAbi: string[];
  static readonly DEFAULT_EXECUTOR_FUCNTION_SELECTOR = SafeModuleExecutorFunctionSelector.executeUserOpWithErrorString;
  static readonly executorFunctionInputAbi: string[];
  protected isInitWebAuthn: boolean;
  protected x: bigint | null;
  protected y: bigint | null;
  readonly safeAccountSingleton: SafeAccountSingleton;
  readonly entrypointAddress: string;
  readonly safe4337ModuleAddress: string;
  protected factoryAddress: string | null;
  protected factoryData: string | null;
  readonly onChainIdentifier: string | null;
  constructor(accountAddress: string, safe4337ModuleAddress: string, entrypointAddress: string, overrides?: {
    onChainIdentifierParams?: OnChainIdentifierParamsType;
    onChainIdentifier?: string;
    safeAccountSingleton?: SafeAccountSingleton;
  });
  static createProxyAddress(initializerCallData: string, overrides?: {
    c2Nonce?: bigint;
    safeFactoryAddress?: string;
    singletonInitHash?: string;
  }): string;
  static isDeployed(accountAddress: string, nodeRpcUrl: string | Transport | JsonRpcNode): Promise<boolean>;
  static createAccountCallDataSingleTransaction(metaTransaction: MetaTransaction, overrides?: {
    safeModuleExecutorFunctionSelector?: SafeModuleExecutorFunctionSelector;
  }): string;
  static createAccountCallDataBatchTransactions(metaTransactions: MetaTransaction[], overrides?: {
    safeModuleExecutorFunctionSelector?: SafeModuleExecutorFunctionSelector;
    multisendContractAddress?: string;
  }): string;
  static createAccountCallData(to: string, value: bigint, data: string, operation: Operation, overrides?: {
    safeModuleExecutorFunctionSelector?: SafeModuleExecutorFunctionSelector;
  }): string;
  static decodeAccountCallData(callData: string): [MetaTransaction, SafeModuleExecutorFunctionSelector];
  static prependTokenPaymasterApproveToCallDataStatic(callData: string, tokenAddress: string, paymasterAddress: string, approveAmount: bigint, overrides?: {
    multisendContractAddress?: string;
  }): string;
  static formatEip712SignaturesToUseroperationSignature(signersAddresses: string[], signatures: string[], overrides?: {
    validAfter?: bigint;
    validUntil?: bigint;
    isMultiChainSignature?: boolean;
    merkleProof?: string;
  }): string;
  getUserOperationEip712Data(useroperation: UserOperationV6 | UserOperationV7 | UserOperationV9, chainId: bigint, overrides?: {
    validAfter?: bigint;
    validUntil?: bigint;
    entrypointAddress?: string;
    safe4337ModuleAddress?: string;
  }): {
    domain: SafeUserOperationTypedDataDomain;
    types: Record<string, {
      name: string;
      type: string;
    }[]>;
    messageValue: SafeUserOperationV6TypedMessageValue | SafeUserOperationV7TypedMessageValue | SafeUserOperationV9TypedMessageValue;
  };
  getUserOperationEip712Hash(useroperation: UserOperationV6 | UserOperationV7 | UserOperationV9, chainId: bigint, overrides?: {
    validAfter?: bigint;
    validUntil?: bigint;
    entrypointAddress?: string;
    safe4337ModuleAddress?: string;
  }): string;
  formatUserOperationSignature(signerSignaturePairs: SignerSignaturePair[], options?: SafeSignatureOptions & WebAuthnSignatureOverrides): string;
  protected static getUserOperationEip712Hash(useroperation: UserOperationV6 | UserOperationV7 | UserOperationV9, chainId: bigint, overrides?: {
    validAfter?: bigint;
    validUntil?: bigint;
    entrypointAddress?: string;
    safe4337ModuleAddress?: string;
  }): string;
  protected static getUserOperationEip712Data(useroperation: UserOperationV6 | UserOperationV7 | UserOperationV9, chainId: bigint, overrides?: {
    validAfter?: bigint;
    validUntil?: bigint;
    entrypointAddress?: string;
    safe4337ModuleAddress?: string;
  }): {
    domain: SafeUserOperationTypedDataDomain;
    types: Record<string, {
      name: string;
      type: string;
    }[]>;
    messageValue: SafeUserOperationV6TypedMessageValue | SafeUserOperationV7TypedMessageValue | SafeUserOperationV9TypedMessageValue;
  };
  static getUserOperationEip712Data_V6(useroperation: UserOperationV6, chainId: bigint, overrides?: {
    validAfter?: bigint;
    validUntil?: bigint;
    entrypointAddress?: string;
    safe4337ModuleAddress?: string;
  }): {
    domain: SafeUserOperationTypedDataDomain;
    types: Record<string, {
      name: string;
      type: string;
    }[]>;
    messageValue: SafeUserOperationV6TypedMessageValue;
  };
  static getUserOperationEip712Hash_V6(useroperation: UserOperationV6, chainId: bigint, overrides?: {
    validAfter?: bigint;
    validUntil?: bigint;
    entrypointAddress?: string;
    safe4337ModuleAddress?: string;
  }): string;
  private static baseGetUserOperationEip712DataV7V8V9;
  static getUserOperationEip712Data_V7(useroperation: UserOperationV7, chainId: bigint, overrides?: {
    validAfter?: bigint;
    validUntil?: bigint;
    entrypointAddress?: string;
    safe4337ModuleAddress?: string;
  }): {
    domain: SafeUserOperationTypedDataDomain;
    types: Record<string, {
      name: string;
      type: string;
    }[]>;
    messageValue: SafeUserOperationV6TypedMessageValue;
  };
  static getUserOperationEip712Hash_V7(useroperation: UserOperationV7, chainId: bigint, overrides?: {
    validAfter?: bigint;
    validUntil?: bigint;
    entrypointAddress?: string;
    safe4337ModuleAddress?: string;
  }): string;
  static getUserOperationEip712Data_V9(useroperation: UserOperationV9, chainId: bigint, overrides?: {
    validAfter?: bigint;
    validUntil?: bigint;
    entrypointAddress?: string;
    safe4337ModuleAddress?: string;
  }): {
    domain: SafeUserOperationTypedDataDomain;
    types: Record<string, {
      name: string;
      type: string;
    }[]>;
    messageValue: SafeUserOperationV9TypedMessageValue;
  };
  static getUserOperationEip712Hash_V9(useroperation: UserOperationV9, chainId: bigint, overrides?: {
    validAfter?: bigint;
    validUntil?: bigint;
    entrypointAddress?: string;
    safe4337ModuleAddress?: string;
  }): string;
  static formatEip712SingleSignatureToUseroperationSignature(signature: string, overrides?: {
    validAfter?: bigint;
    validUntil?: bigint;
    isMultiChainSignature?: boolean;
  }): string;
  sendUserOperation(userOperation: UserOperationV6 | UserOperationV7 | UserOperationV9, bundlerRpc: string | Transport | Bundler): Promise<SendUseroperationResponse>;
  protected static createAccountAddressAndFactoryAddressAndData(owners: Signer[], overrides: BaseInitOverrides, safe4337ModuleAddress: string, safeModuleSetupAddress: string): [string, string, string];
  protected static createBaseInitializerCallData(owners: Signer[], threshold: number, safe4337ModuleAddress: string, safeModuleSetupAddress: string, multisendContractAddress?: string, webAuthnSharedSigner?: string, eip7212WebAuthnPrecompileVerifierForSharedSigner?: string, eip7212WebAuthnContractVerifierForSharedSigner?: string): string;
  protected static createFactoryAddressAndData(owners: Signer[], overrides: BaseInitOverrides | undefined, safe4337ModuleAddress: string, safeModuleSetupAddress: string): [string, string];
  prependTokenPaymasterApproveToCallData(callData: string, tokenAddress: string, paymasterAddress: string, approveAmount: bigint, overrides?: {
    multisendContractAddress?: string;
  }): string;
  baseEstimateUserOperationGas(userOperation: UserOperationV6 | UserOperationV7, bundlerRpc: string | Transport | Bundler, overrides?: {
    stateOverrideSet?: StateOverrideSet;
    dummySignerSignaturePairs?: SignerSignaturePair[];
    expectedSigners?: Signer[];
    webAuthnSharedSigner?: string;
    webAuthnSignerFactory?: string;
    webAuthnSignerSingleton?: string;
    webAuthnSignerProxyCreationCode?: string;
    eip7212WebAuthnPrecompileVerifier?: string;
    eip7212WebAuthnContractVerifier?: string;
    isMultiChainSignature?: boolean;
  }): Promise<[bigint, bigint, bigint]>;
  protected createBaseUserOperationAndFactoryAddressAndFactoryData(transactions: MetaTransaction[], isV06: boolean, providerRpc?: string | Transport | JsonRpcNode, bundlerRpc?: string | Transport | Bundler, overrides?: CreateBaseUserOperationOverrides): Promise<[BaseUserOperation, string | null, string | null]>;
  protected static baseSignSingleUserOperation(useroperation: UserOperationV6 | UserOperationV7, privateKeys: string[], chainId: bigint, entrypointAddress: string, safe4337ModuleAddress: string, options?: SafeSignatureOptions): string;
  static readonly ACCEPTED_SIGNING_SCHEMES: readonly SigningScheme[];
  protected static baseSignUserOperationWithSigners<T extends UserOperationV6 | UserOperationV7 | UserOperationV9, C>(useroperation: T, signers: ReadonlyArray<ExternalSigner<C>>, chainId: bigint, params: {
    entrypointAddress: string;
    safe4337ModuleAddress: string;
    context: C;
    options?: SafeSignatureOptions;
  }): Promise<string>;
  static createWebAuthnSignerVerifierAddress(x: bigint, y: bigint, overrides?: {
    eip7212WebAuthnPrecompileVerifier?: string;
    eip7212WebAuthnContractVerifier?: string;
    webAuthnSignerFactory?: string;
    webAuthnSignerSingleton?: string;
    webAuthnSignerProxyCreationCode?: string;
  }): string;
  static formatSignaturesToUseroperationSignature(signerSignaturePairs: SignerSignaturePair[], options?: SafeSignatureOptions & WebAuthnSignatureOverrides): string;
  static getSignerLowerCaseAddress(signer: Signer, overrides?: WebAuthnSignatureOverrides): string;
  static sortSignatures(signerSignaturePairs: SignerSignaturePair[], overrides?: WebAuthnSignatureOverrides): void;
  static buildSignaturesFromSingerSignaturePairs(signerSignaturePairs: SignerSignaturePair[], we