@w3lib/evm-batch-call 0.7.0 → 0.8.0

package/src/smartAccount/eip5792.ts

@@ -0,0 +1,187 @@
+import type { BatchCallOptions, NormalizedCall } from '../write/batch.js'
+import { sendEach } from '../write/batch.js'
+import { WriteRpc, failureText } from '../write/rpc.js'
+import { quantity } from './userOp.js'
+import { emptyOutcome, toWriteResult, type TxOutcome, type WriteResult } from '../write/send.js'
+
+/**
+ * 浏览器钱包的提供者，三种都可以：EIP-1193 provider（`window.ethereum`，有 request）、
+ * ethers 的 BrowserProvider（有 send）、ethers 的 JsonRpcSigner（用它背后的 provider）
+ */
+export type Eip1193Like =
+  | { request(args: { method: string; params?: unknown[] | object }): Promise<unknown> }
+  | { send(method: string, params: unknown[]): Promise<unknown> }
+  | { provider: { send(method: string, params: unknown[]): Promise<unknown> } | { request(args: { method: string; params?: unknown[] | object }): Promise<unknown> } }
+
+export type RequestFn = (method: string, params: unknown[]) => Promise<unknown>
+
+/** 统一成 (method, params) => Promise */
+export function toRequest(p: Eip1193Like): RequestFn {
+  const direct = p as { request?: unknown; send?: unknown; provider?: unknown }
+  if (typeof direct.request === 'function') {
+    return (method, params) => (p as { request(args: { method: string; params: unknown[] }): Promise<unknown> }).request({ method, params })
+  }
+  if (typeof direct.send === 'function') {
+    return (method, params) => (p as { send(method: string, params: unknown[]): Promise<unknown> }).send(method, params)
+  }
+  if (direct.provider) {
+    return toRequest(direct.provider as Eip1193Like)
+  }
+  throw new Error('Expected an EIP-1193 provider, an ethers BrowserProvider or a JsonRpcSigner')
+}
+
+/** 钱包对某条链的能力（wallet_getCapabilities） */
+export interface WalletCapabilities {
+  /** 'supported'：能原子批量；'ready'：钱包会在用户同意后升级账户；'unsupported'：不支持 */
+  atomic: 'supported' | 'ready' | 'unsupported'
+  /** 钱包是否支持 paymasterService（代付 gas）能力 */
+  paymasterService: boolean
+  /** 钱包返回的原始能力 */
+  raw: Record<string, unknown>
+}
+
+const chainHex = (chainId: number) => quantity(chainId)
+
+/** 查询钱包能力；钱包不支持 EIP-5792（报错）时返回 null */
+export async function getWalletCapabilities(provider: Eip1193Like, address: string, chainId: number): Promise<WalletCapabilities | null> {
+  let all: Record<string, Record<string, any>> | null
+  try {
+    all = (await toRequest(provider)('wallet_getCapabilities', [address, [chainHex(chainId)]])) as Record<string, Record<string, any>> | null
+  } catch {
+    return null
+  }
+  const raw = all?.[chainHex(chainId)] ?? all?.[String(chainId)] ?? Object.entries(all ?? {}).find(([k]) => k.toLowerCase() === chainHex(chainId).toLowerCase())?.[1] ?? {}
+  const status = raw.atomic?.status ?? (raw.atomicBatch?.supported ? 'supported' : 'unsupported')
+  return { atomic: status === 'supported' || status === 'ready' ? status : 'unsupported', paymasterService: Boolean(raw.paymasterService?.supported), raw }
+}
+
+export interface SendCallsRequest {
+  from: string
+  chainId: number
+  calls: ReadonlyArray<{ to: string; value?: bigint; data?: string }>
+  /** 必须原子执行（钱包不能原子就拒绝）。默认 true */
+  atomicRequired?: boolean
+  /** 钱包能力扩展（如 `{ paymasterService: { url } }` 让钱包找 paymaster 代付 gas） */
+  capabilities?: Record<string, unknown>
+}
+
+/** wallet_sendCalls：返回调用批次的 id（用 getCallsStatus 查询） */
+export async function sendCalls(provider: Eip1193Like, req: SendCallsRequest): Promise<string> {
+  const result = (await toRequest(provider)('wallet_sendCalls', [
+    {
+      version: '2.0.0',
+      from: req.from,
+      chainId: chainHex(req.chainId),
+      atomicRequired: req.atomicRequired ?? true,
+      calls: req.calls.map((c) => ({ to: c.to, ...(c.value ? { value: quantity(c.value) } : {}), data: c.data ?? '0x' })),
+      ...(req.capabilities ? { capabilities: req.capabilities } : {}),
+    },
+  ])) as string | { id: string }
+  return typeof result === 'string' ? result : result.id
+}
+
+export interface CallsStatus {
+  status: 'pending' | 'confirmed' | 'failed' | 'reverted' | 'partial'
+  atomic: boolean
+  receipts: Array<{ transactionHash: string; blockNumber: number | null; gasUsed: bigint | null; success: boolean }>
+}
+
+/** wallet_getCallsStatus（兼容 v1 的字符串状态和 v2 的 100 / 200 / 400 / 500 / 600 状态码） */
+export async function getCallsStatus(provider: Eip1193Like, id: string): Promise<CallsStatus> {
+  const r = (await toRequest(provider)('wallet_getCallsStatus', [id])) as { status: number | string; atomic?: boolean; receipts?: Array<{ transactionHash: string; blockNumber?: string; gasUsed?: string; status?: string }> }
+  const code = typeof r.status === 'number' ? r.status : r.status === 'CONFIRMED' ? 200 : r.status === 'PENDING' ? 100 : 400
+  const status = code < 200 ? 'pending' : code < 300 ? 'confirmed' : code < 500 ? 'failed' : code === 500 ? 'reverted' : 'partial'
+  const receipts = (r.receipts ?? []).map((x) => ({
+    transactionHash: x.transactionHash,
+    blockNumber: x.blockNumber ? Number(x.blockNumber) : null,
+    gasUsed: x.gasUsed ? BigInt(x.gasUsed) : null,
+    success: x.status === undefined || Number(x.status) === 1,
+  }))
+  return { status, atomic: r.atomic ?? true, receipts }
+}
+
+/** 轮询到有结果；超时返回最后一次的 pending */
+export async function waitForCalls(provider: Eip1193Like, id: string, options: { timeout?: number; pollInterval?: number; signal?: AbortSignal } = {}): Promise<CallsStatus> {
+  const { timeout = 180_000, pollInterval = 2_000, signal } = options
+  const deadline = Date.now() + timeout
+  let last: CallsStatus = { status: 'pending', atomic: true, receipts: [] }
+  while (!signal?.aborted) {
+    try {
+      last = await getCallsStatus(provider, id)
+      if (last.status !== 'pending') return last
+    } catch {
+      // 钱包暂时没有这个 id 的状态：下次再查
+    }
+    if (Date.now() >= deadline) break
+    await new Promise((resolve) => setTimeout(resolve, Math.min(pollInterval, Math.max(0, deadline - Date.now()))))
+  }
+  return last
+}
+
+/**
+ * '5792' 模式：钱包支持原子批量就用 wallet_sendCalls（一次确认、一笔交易原子执行）；
+ * 不支持（钱包不实现 EIP-5792，或链上账户不能原子批量）时退回逐笔发送（每笔一次确认），除非 atomicRequired
+ */
+export async function send5792(rpc: WriteRpc, calls: readonly NormalizedCall[], options: BatchCallOptions): Promise<WriteResult[]> {
+  const first = calls[0]
+  if (!first) return []
+  if (calls.some((c) => c.signer.address !== first.signer.address)) {
+    throw new Error("mode '5792' sends from one browser wallet; split calls per wallet")
+  }
+  const provider = options.eip1193 ?? (first.signer.signer as { provider?: Eip1193Like }).provider
+  if (!provider) {
+    throw new Error("mode '5792' requires a browser wallet signer (ethers JsonRpcSigner) or the eip1193 option")
+  }
+  const caps = await getWalletCapabilities(provider, first.signer.address, rpc.chainId)
+  const atomic = caps !== null && caps.atomic !== 'unsupported'
+  if (!atomic) {
+    if (options.atomicRequired) {
+      return calls.map((c, i) => toWriteResult(i, c.signer.address, c.to, emptyOutcome('failed', caps ? 'the wallet cannot execute batches atomically on this chain' : 'the wallet does not support EIP-5792 (wallet_getCapabilities)')))
+    }
+    // 退回逐笔发送：钱包要能直接发送交易
+    const results = await sendEach(rpc, calls, options)
+    return results.map((r) => ({ ...r, atomic: false }))
+  }
+  const results = calls.map((c, i) => toWriteResult(i, c.signer.address, c.to, emptyOutcome('skipped')))
+  const report = (outcome: TxOutcome, perCall?: (i: number) => Partial<TxOutcome>) => {
+    calls.forEach((c, i) => {
+      results[i] = { ...toWriteResult(i, c.signer.address, c.to, { ...outcome, ...perCall?.(i) }), atomic: true }
+      options.onUpdate?.(results[i] as WriteResult)
+    })
+  }
+  if (options.dryRun) {
+    report(emptyOutcome('simulated'))
+    return results
+  }
+  try {
+    const id = await sendCalls(provider, {
+      from: first.signer.address,
+      chainId: rpc.chainId,
+      calls: calls.map((c) => ({ to: c.to, value: c.value, data: c.data })),
+      atomicRequired: true,
+      capabilities: options.capabilities,
+    })
+    report({ ...emptyOutcome('sent'), hash: null })
+    if (options.wait === false) return results
+    const status = await waitForCalls(provider, id, options)
+    const receipt = status.receipts[0]
+    const base: TxOutcome = { ...emptyOutcome('pending', 'not confirmed in time; query wallet_getCallsStatus with the id later'), hash: receipt?.transactionHash ?? null }
+    if (status.status === 'confirmed' || status.status === 'reverted' || status.status === 'partial') {
+      report({
+        ...base,
+        status: status.status === 'confirmed' && receipt?.success !== false ? 'confirmed' : 'reverted',
+        error: status.status === 'confirmed' ? null : 'execution reverted',
+        blockNumber: receipt?.blockNumber ?? null,
+        gasUsed: receipt?.gasUsed ?? null,
+      })
+    } else if (status.status === 'failed') {
+      report({ ...base, status: 'failed', error: 'the wallet reported that the batch failed' })
+    } else {
+      report(base)
+    }
+  } catch (err) {
+    const rejected = (err as { code?: number } | null)?.code === 4001 || (err as { code?: string } | null)?.code === 'ACTION_REJECTED'
+    report(emptyOutcome('failed', rejected ? 'rejected by user' : failureText(err)))
+  }
+  return results
+}

package/src/smartAccount/send.ts

@@ -0,0 +1,341 @@
+import { Interface, getAddress, getBytes, type Authorization } from 'ethers'
+
+import { decodeRevertReason } from '../errors.js'
+import { SIMPLE_7702_ACCOUNT, delegationOf, failedIndex, type BatchCallOptions, type NormalizedCall } from '../write/batch.js'
+import { WriteRpc, failureText } from '../write/rpc.js'
+import { FeeSource, emptyOutcome, mapPool, sendJobs, toWriteResult, type TxJob, type TxOutcome, type WriteResult } from '../write/send.js'
+import { resolveSigner, type ResolvedSigner, type SignerInput } from '../write/signer.js'
+import { encodeExecuteBatch, resolveSimpleAccount, type SmartAccountKind } from './account.js'
+import { BundlerClient, PaymasterClient, type GasEstimate, type PaymasterHook } from './clients.js'
+import {
+  DUMMY_SIGNATURE,
+  EIP7702_MARKER,
+  entryPointAddress,
+  entryPointInterface,
+  getUserOpHash,
+  packUserOp,
+  userOpTypedData,
+  type EntryPointVersion,
+  type UserOperation,
+} from './userOp.js'
+
+export interface SmartAccountOptions {
+  /** 账户类型，默认 'simple'（见 SmartAccountKind）；7702 模式固定为 'simple7702' */
+  account?: SmartAccountKind
+  /** EntryPoint 版本：'simple' 默认 '0.7'，'simple7702' 只能 '0.8' */
+  entryPoint?: EntryPointVersion
+  /** 'simple' 账户的 salt，默认 0（同一个 owner 可以有多个账户） */
+  salt?: bigint | number | string
+  /** 'simple' 账户的工厂，默认 eth-infinitism 的 SimpleAccountFactory */
+  factory?: string
+  /** bundler：URL 或 BundlerClient。UserOperation 交给它打包上链 */
+  bundler?: string | BundlerClient
+  /** paymaster（代付 gas）：ERC-7677 客户端，或自定义函数 */
+  paymaster?: PaymasterClient | PaymasterHook
+  /**
+   * 不用 bundler，自己发 EntryPoint.handleOps 交易：true 表示用账户的 owner 钱包发（owner 付交易 gas），
+   * 或传另一个钱包 / 私钥（它付 gas，即 sponsor）。这种方式 UserOperation 的 maxFeePerGas 为 0，账户本身不扣 gas
+   */
+  selfBundle?: SignerInput | true
+  /** 覆盖 gas 预估（自己打包时的 callGasLimit 等） */
+  gas?: Partial<GasEstimate>
+  /** 把 7702 授权交给 bundler 时的委托合约、是否替换已有委托，同 BatchCallOptions.delegate / redelegate（由调用方填） */
+  delegate?: string
+  redelegate?: boolean
+}
+
+export interface SmartSendOptions extends BatchCallOptions {
+  smartAccount?: SmartAccountOptions
+}
+
+const FALLBACK_CALL_GAS = 300_000n
+const PER_CALL_OVERHEAD = 15_000n
+const VERIFICATION_GAS = 200_000n
+const DEPLOY_VERIFICATION_GAS = 700_000n
+const PRE_VERIFICATION_GAS = 100_000n
+
+type Ctx = {
+  rpc: WriteRpc
+  options: SmartSendOptions
+  so: SmartAccountOptions
+  kind: SmartAccountKind
+  version: EntryPointVersion
+  entryPoint: string
+  delegate: string
+  fees: FeeSource
+  bundler: BundlerClient | null
+  paymaster: PaymasterHook | null
+}
+
+/** 一笔 UserOperation 的结果（对应一批调用） */
+interface OpOutcome extends TxOutcome {
+  userOpHash: string | null
+  /** 账户（sender）地址 */
+  sender: string
+}
+
+function paymasterHook(p: SmartAccountOptions['paymaster']): PaymasterHook | null {
+  if (!p) return null
+  return typeof p === 'function' ? p : p.hook
+}
+
+/**
+ * 智能账户批量执行：同一钱包的调用打成一个（按 batchSize 拆分）UserOperation，由 bundler 或自己（handleOps）打包上链，一个 UserOperation 里的调用原子执行。
+ * 结果的 gasUsed / fee 是 UserOperation 的 actualGasUsed / actualGasCost（账户或 paymaster 付的），不含打包交易其余部分
+ */
+export async function sendSmartBatch(rpc: WriteRpc, calls: readonly NormalizedCall[], options: SmartSendOptions): Promise<WriteResult[]> {
+  const so = options.smartAccount ?? {}
+  const kind = so.account ?? 'simple'
+  const version = so.entryPoint ?? (kind === 'simple7702' ? '0.8' : '0.7')
+  if (kind === 'simple7702' && version !== '0.8') {
+    throw new Error("The 7702 account (Simple7702Account) only works with EntryPoint v0.8")
+  }
+  if (!so.bundler && !so.selfBundle) {
+    throw new Error('smartAccount.bundler (a bundler URL) or smartAccount.selfBundle is required')
+  }
+  const ctx: Ctx = {
+    rpc,
+    options,
+    so,
+    kind,
+    version,
+    entryPoint: entryPointAddress(version),
+    delegate: getAddress(so.delegate ?? options.delegate ?? SIMPLE_7702_ACCOUNT),
+    fees: new FeeSource(rpc, options),
+    bundler: so.selfBundle ? null : typeof so.bundler === 'string' ? new BundlerClient(so.bundler) : (so.bundler ?? null),
+    paymaster: paymasterHook(so.paymaster),
+  }
+  const results: WriteResult[] = calls.map((c, i) => toWriteResult(i, c.signer.address, c.to, emptyOutcome('skipped')))
+  const report = (indexes: readonly number[], outcome: OpOutcome, failed?: { index: number; reason: string }) => {
+    indexes.forEach((i, k) => {
+      const c = calls[i] as NormalizedCall
+      const o = failed ? (k === failed.index ? { ...outcome, error: failed.reason } : outcome) : outcome
+      results[i] = { ...toWriteResult(i, outcome.sender, c.to, o), userOpHash: outcome.userOpHash, atomic: true }
+      options.onUpdate?.(results[i] as WriteResult)
+    })
+  }
+
+  const byWallet = new Map<string, number[]>()
+  calls.forEach((c, i) => byWallet.set(c.signer.address.toLowerCase(), [...(byWallet.get(c.signer.address.toLowerCase()) ?? []), i]))
+  const batchSize = Math.max(1, options.batchSize ?? 50)
+  // 同一个 sponsor 钱包发所有 handleOps：并发会抢 nonce，按顺序发
+  await mapPool([...byWallet.values()], so.selfBundle && so.selfBundle !== true ? 1 : (options.concurrency ?? 8), async (indexes) => {
+    const signer = (calls[indexes[0] as number] as NormalizedCall).signer
+    let stopped = false
+    for (let start = 0; start < indexes.length; start += batchSize) {
+      const chunk = indexes.slice(start, start + batchSize)
+      if (stopped || options.signal?.aborted) {
+        report(chunk, { ...emptyOutcome('skipped', options.signal?.aborted ? 'aborted' : 'skipped: a previous batch from this wallet failed'), userOpHash: null, sender: signer.address })
+        continue
+      }
+      const last = start + batchSize >= indexes.length
+      let outcome: OpOutcome
+      try {
+        outcome = await sendOp(ctx, signer, chunk.map((i) => calls[i] as NormalizedCall), last ? options.wait !== false : true)
+      } catch (err) {
+        outcome = { ...emptyOutcome('failed', failureText(err)), userOpHash: null, sender: signer.address }
+      }
+      report(chunk, outcome, outcome.status === 'reverted' && outcome.revertData ? (failedIndex(outcome.revertData, chunk.length) ?? undefined) : undefined)
+      if (outcome.status !== 'confirmed' && outcome.status !== 'simulated' && !options.continueOnError) stopped = true
+    }
+  })
+  return results
+}
+
+/** 账户信息：sender、是否要部署 / 授权 */
+interface AccountInfo {
+  sender: string
+  factory?: string
+  factoryData?: string
+  /** 账户上已经有代码（可以估算整批的 gas） */
+  live: boolean
+  /** 需要带 7702 授权 */
+  needsAuth: boolean
+}
+
+async function accountInfo(ctx: Ctx, signer: ResolvedSigner): Promise<AccountInfo> {
+  const { rpc } = ctx
+  if (ctx.kind === 'simple') {
+    const a = await resolveSimpleAccount(rpc, signer.address, ctx.version, ctx.so.salt, ctx.so.factory)
+    return { sender: a.address, live: a.deployed, needsAuth: false, ...(a.deployed ? {} : { factory: a.factory, factoryData: a.factoryData }) }
+  }
+  if (!signer.local || typeof signer.signer.authorize !== 'function') {
+    throw new Error('The 7702 account requires a signer that can sign EIP-7702 authorizations locally (a private key or an ethers Wallet)')
+  }
+  if ((await rpc.code(ctx.delegate)) === '0x') {
+    throw new Error(`The delegate contract ${ctx.delegate} is not deployed on chain ${rpc.chainId}`)
+  }
+  const { delegated, to } = await delegationOf(rpc, signer.address)
+  if (delegated && to !== ctx.delegate && !(ctx.so.redelegate ?? ctx.options.redelegate)) {
+    throw new Error(`${signer.address} is already delegated to ${to}; pass redelegate: true to replace it`)
+  }
+  const needsAuth = !delegated || to !== ctx.delegate
+  return { sender: signer.address, live: !needsAuth, needsAuth, ...(needsAuth ? { factory: EIP7702_MARKER, factoryData: '0x' } : {}) }
+}
+
+async function readNonce(ctx: Ctx, sender: string): Promise<bigint> {
+  const data = await ctx.rpc.call({ to: ctx.entryPoint, data: entryPointInterface.encodeFunctionData('getNonce', [sender, 0]) })
+  return entryPointInterface.decodeFunctionResult('getNonce', data)[0] as bigint
+}
+
+/** 没有 bundler 时估算 gas：整批能执行时估整批（从 EntryPoint 调账户），否则逐个调用估算后相加 */
+async function estimateCallGas(ctx: Ctx, info: AccountInfo, callData: string, items: readonly NormalizedCall[]): Promise<bigint> {
+  const multiplier = BigInt(Math.round((ctx.options.gasMultiplier ?? 1.2) * 1000))
+  if (info.live) {
+    return (await ctx.rpc.estimateGas({ from: ctx.entryPoint, to: info.sender, data: callData })) * multiplier / 1000n + PER_CALL_OVERHEAD
+  }
+  let total = 0n
+  for (const [i, c] of items.entries()) {
+    try {
+      total += await ctx.rpc.estimateGas({ from: info.sender, to: c.to, data: c.data, value: c.value })
+    } catch (err) {
+      // 依赖前面调用结果的（先 approve 再兑换）单独估算会失败；第一个调用失败说明批量本身就会失败
+      if (i === 0) throw err
+      total += FALLBACK_CALL_GAS
+    }
+    total += PER_CALL_OVERHEAD
+  }
+  return (total * multiplier) / 1000n
+}
+
+async function signOp(ctx: Ctx, signer: ResolvedSigner, op: UserOperation, hash: string): Promise<string> {
+  if (ctx.version === '0.8') {
+    if (typeof signer.signer.signTypedData !== 'function') throw new Error('The signer does not support signTypedData')
+    const { domain, types, message } = userOpTypedData(op, ctx.entryPoint, ctx.rpc.chainId, ctx.delegate)
+    return signer.signer.signTypedData(domain, types, message)
+  }
+  if (typeof signer.signer.signMessage !== 'function') throw new Error('The signer does not support signMessage')
+  return signer.signer.signMessage(getBytes(hash))
+}
+
+async function signAuth(ctx: Ctx, signer: ResolvedSigner, nonce: number): Promise<Authorization> {
+  return (signer.signer.authorize as NonNullable<typeof signer.signer.authorize>)({ address: ctx.delegate, nonce, chainId: ctx.rpc.chainId })
+}
+
+async function sendOp(ctx: Ctx, signer: ResolvedSigner, items: readonly NormalizedCall[], wait: boolean): Promise<OpOutcome> {
+  const { rpc, options } = ctx
+  const info = await accountInfo(ctx, signer)
+  const callData = encodeExecuteBatch(ctx.version, items)
+  const selfBundle = Boolean(ctx.so.selfBundle)
+  const fee = selfBundle ? null : await ctx.fees.get()
+  const op: UserOperation = {
+    sender: info.sender,
+    nonce: await readNonce(ctx, info.sender),
+    ...(info.factory ? { factory: info.factory, factoryData: info.factoryData } : {}),
+    callData,
+    callGasLimit: 0n,
+    verificationGasLimit: 0n,
+    preVerificationGas: 0n,
+    maxFeePerGas: fee?.perGas ?? 0n,
+    maxPriorityFeePerGas: fee ? (fee.type === 2 ? (fee.maxPriorityFeePerGas as bigint) : fee.perGas) : 0n,
+    signature: DUMMY_SIGNATURE,
+  }
+  const pmContext = { entryPoint: ctx.entryPoint, chainId: rpc.chainId }
+  const hook = ctx.paymaster
+
+  // gas：bundler 估算，或本地估算
+  if (ctx.bundler) {
+    if (info.needsAuth) {
+      // bundler 是别人：授权 nonce 就是钱包当前的 nonce
+      op.eip7702Auth = await signAuth(ctx, signer, await rpc.nonce(signer.address))
+    }
+    if (hook) Object.assign(op, await hook(op, { ...pmContext, stage: 'stub' }))
+    Object.assign(op, await ctx.bundler.estimateUserOperationGas(op, ctx.entryPoint))
+  } else {
+    if (hook) Object.assign(op, await hook(op, { ...pmContext, stage: 'stub' }))
+    op.callGasLimit = await estimateCallGas(ctx, info, callData, items)
+    op.verificationGasLimit = info.factory ? DEPLOY_VERIFICATION_GAS : VERIFICATION_GAS
+    op.preVerificationGas = PRE_VERIFICATION_GAS
+  }
+  Object.assign(op, ctx.so.gas)
+  if (hook) Object.assign(op, await hook({ ...op, signature: DUMMY_SIGNATURE }, { ...pmContext, stage: 'final' }))
+
+  const delegate = info.needsAuth || ctx.kind === 'simple7702' ? ctx.delegate : undefined
+  const hash = getUserOpHash(op, ctx.entryPoint, rpc.chainId, ctx.version, delegate)
+  op.signature = await signOp(ctx, signer, op, hash)
+
+  if (ctx.bundler) {
+    if (options.dryRun) return { ...emptyOutcome('simulated'), gasLimit: op.callGasLimit + op.verificationGasLimit + op.preVerificationGas, userOpHash: hash, sender: info.sender }
+    const sent = await ctx.bundler.sendUserOperation(op, ctx.entryPoint)
+    if (sent.toLowerCase() !== hash.toLowerCase()) {
+      throw new Error(`The bundler returned a different userOpHash (${sent}) than computed locally (${hash}); not tracking it`)
+    }
+    if (!wait) return { ...emptyOutcome('sent'), userOpHash: hash, sender: info.sender }
+    const receipt = await ctx.bundler.waitForUserOperation(hash, options)
+    if (!receipt) return { ...emptyOutcome('pending', 'not confirmed in time; the UserOperation may still be included'), userOpHash: hash, sender: info.sender }
+    return {
+      ...emptyOutcome(receipt.success ? 'confirmed' : 'reverted', receipt.success ? null : 'execution reverted'),
+      hash: receipt.transactionHash,
+      blockNumber: receipt.blockNumber,
+      gasUsed: receipt.actualGasUsed,
+      fee: receipt.actualGasCost,
+      revertData: receipt.reason && receipt.reason.startsWith('0x') ? receipt.reason : null,
+      userOpHash: hash,
+      sender: info.sender,
+    }
+  }
+
+  // 自己打包：bundler 钱包发一笔 handleOps（带 7702 授权时一起带上）
+  const bundlerSigner = ctx.so.selfBundle === true ? signer : await resolveSigner(ctx.so.selfBundle as SignerInput)
+  if (!bundlerSigner.local) throw new Error('selfBundle requires a signer that can sign transactions locally (a private key or an ethers Wallet)')
+  const packed = packUserOp(op)
+  const data = entryPointInterface.encodeFunctionData('handleOps', [[packed], bundlerSigner.address])
+  const job: TxJob = {
+    signer: bundlerSigner,
+    build: async (nonce) => {
+      let authorizationList: Authorization[] | undefined
+      if (info.needsAuth) {
+        // 钱包自己发这笔交易时，交易先把 nonce 加一再处理授权
+        const authNonce = bundlerSigner.address === signer.address ? (nonce as number) + 1 : await rpc.nonce(signer.address)
+        authorizationList = [await signAuth(ctx, signer, authNonce)]
+      }
+      return { to: ctx.entryPoint, data, value: 0n, authorizationList }
+    },
+  }
+  const [txOutcome] = await sendJobs(rpc, [job], { ...options, wait }, ctx.fees)
+  const outcome = txOutcome as TxOutcome
+  if (outcome.status === 'failed' && outcome.revertData) {
+    outcome.error = decodeFailedOp(outcome.revertData) ?? outcome.error
+  }
+  const result: OpOutcome = { ...outcome, userOpHash: hash, sender: info.sender }
+  if (outcome.status === 'confirmed' && outcome.hash) {
+    // 交易成功不代表 UserOperation 成功：看 UserOperationEvent
+    const receipt = await rpc.receipt(outcome.hash)
+    const event = receipt?.logs.map((l) => parseLog(l)).find((e) => e?.name === 'UserOperationEvent' && String(e.args[0]).toLowerCase() === hash.toLowerCase())
+    if (!event) {
+      return { ...result, status: 'reverted', error: 'the UserOperation was not executed by the EntryPoint' }
+    }
+    const reason = receipt?.logs.map((l) => parseLog(l)).find((e) => e?.name === 'UserOperationRevertReason' && String(e.args[0]).toLowerCase() === hash.toLowerCase())
+    result.gasUsed = event.args[6] as bigint
+    result.fee = event.args[5] as bigint
+    if (event.args[4] !== true) {
+      const revert = reason ? String(reason.args[3]) : null
+      return { ...result, status: 'reverted', error: 'execution reverted', revertData: revert }
+    }
+  }
+  return result
+}
+
+const logInterface = new Interface(entryPointInterface.fragments)
+
+function parseLog(log: { topics: readonly string[]; data: string }) {
+  try {
+    return logInterface.parseLog({ topics: [...log.topics], data: log.data })
+  } catch {
+    return null
+  }
+}
+
+/** EntryPoint 的 FailedOp(opIndex, reason)：reason 形如 'AA24 signature error' */
+function decodeFailedOp(data: string): string | null {
+  try {
+    const e = entryPointInterface.parseError(data)
+    if (e?.name === 'FailedOp' || e?.name === 'FailedOpWithRevert') {
+      const inner = e.name === 'FailedOpWithRevert' ? decodeRevertReason(String(e.args[2])) : null
+      return `EntryPoint rejected the UserOperation: ${e.args[1]}${inner ? ` (${inner})` : ''}`
+    }
+  } catch {
+    // 不是 EntryPoint 的错误
+  }
+  return null
+}