gate-evm-tools 1.0.27 → 1.0.31

package/runtime/delivery/safe-observation.ts

@@ -0,0 +1,626 @@
+/** Owned finite Geth 1.15.11 collector. Evidence is fetched for the original hash;
+ * serialized caller evidence, custom tracers and weaker fallback are not accepted. */
+import { id, keccak256 } from "ethers";
+import { deepFreeze, canonicalJson } from "../workflow/lib/canonicalData";
+import { immutableDeliveryPlan } from "./export";
+import { EoaRpcFailure, rpcQuantity, type EoaRpc } from "./eoa-observation";
+import { hash32, type TransactionObservation } from "./observations";
+import {
+  parseSafeEnvelope,
+  verifySafeExec,
+  SAFE_INTERFACE,
+  safeBytes,
+  type SafeEnvelope
+} from "./safe";
+import { SAFE_RUNTIME_HASHES } from "./safe-manifest";
+export const SAFE_PRESTATE_OPTIONS = deepFreeze({
+  tracer: "prestateTracer",
+  tracerConfig: { diffMode: false, disableCode: false, disableStorage: false },
+  timeout: "20s",
+  reexec: 128
+});
+export const SAFE_OPCODE_OPTIONS = deepFreeze({
+  enableMemory: true,
+  disableStack: false,
+  disableStorage: false,
+  enableReturnData: true,
+  limit: 0,
+  timeout: "20s",
+  reexec: 128
+});
+export const SAFE_TRACE_MAX_BYTES = 64 * 1024 * 1024;
+const SAFE_EXECUTION_SELECTORS = new Set(
+  [
+    "execTransaction(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,bytes)",
+    "execTransactionFromModule(address,uint256,bytes,uint8)",
+    "execTransactionFromModuleReturnData(address,uint256,bytes,uint8)"
+  ].map((signature) => id(signature).slice(0, 10))
+);
+// View/pure entries from the pinned official Safe 1.4.1 ABI. Unknown selectors
+// (including fallback paths) are not promoted to query execution.
+const SAFE_QUERY_SELECTORS = new Set(
+  [
+    "VERSION()",
+    "approvedHashes(address,bytes32)",
+    "checkNSignatures(bytes32,bytes,bytes,uint256)",
+    "checkSignatures(bytes32,bytes,bytes)",
+    "domainSeparator()",
+    "encodeTransactionData(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,uint256)",
+    "getChainId()",
+    "getModulesPaginated(address,uint256)",
+    "getOwners()",
+    "getStorageAt(uint256,uint256)",
+    "getThreshold()",
+    "getTransactionHash(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,uint256)",
+    "isModuleEnabled(address)",
+    "isOwner(address)",
+    "nonce()",
+    "signedMessages(bytes32)"
+  ].map((signature) => id(signature).slice(0, 10))
+);
+const tag = (n: string) => "0x" + BigInt(n).toString(16);
+function obj(v: unknown, label: string): Record<string, any> {
+  if (!v || typeof v !== "object" || Array.isArray(v))
+    throw Error(`Invalid Safe ${label}`);
+  return v as Record<string, any>;
+}
+function hex(v: unknown): string {
+  if (typeof v !== "string" || !/^0x(?:[a-fA-F0-9]{2})*$/.test(v))
+    throw Error("Invalid Safe RPC hex");
+  return v.toLowerCase();
+}
+function hash(v: unknown): string {
+  return hash32(hex(v), "Safe RPC hash");
+}
+function address(v: unknown): string {
+  const x = hex(v);
+  if (x.length !== 42) throw Error("Invalid Safe RPC address");
+  return x;
+}
+function word(v: unknown): bigint {
+  if (typeof v !== "string" || !/^(?:0x)?[0-9a-fA-F]{1,64}$/.test(v))
+    throw Error("Missing/malformed Safe trace stack word");
+  return BigInt("0x" + v.replace(/^0x/, ""));
+}
+const addr = (v: bigint) =>
+  "0x" + (v & ((1n << 160n) - 1n)).toString(16).padStart(40, "0");
+function budget(v: unknown, max = SAFE_TRACE_MAX_BYTES): void {
+  const encoded = JSON.stringify(v);
+  if (!encoded || Buffer.byteLength(encoded) > max)
+    throw Error("Safe trace evidence exceeds bounded budget");
+}
+interface Frame {
+  code: string;
+  storage: string;
+  role:
+    | "proxy"
+    | "singleton"
+    | "batch"
+    | "other"
+    | "query-proxy"
+    | "query-singleton";
+  query?: {
+    input: string;
+    singleton?: string;
+    loaded?: boolean;
+    delegated?: boolean;
+  };
+}
+function executionTrace(
+  preRaw: unknown,
+  traceRaw: unknown,
+  e: SafeEnvelope,
+  input: string,
+  status: string
+): void {
+  budget(preRaw, 2 * 1024 * 1024);
+  budget(traceRaw);
+  const pre = obj(preRaw, "prestate"),
+    trace = obj(traceRaw, "opcode trace");
+  const accounts = new Map(
+    Object.entries(pre).map(([a, v]) => [
+      address(a),
+      obj(v, "prestate account")
+    ])
+  );
+  const runtimeHashes = new Map<string, string>();
+  const runtimeHash = (target: string): string => {
+    if (!runtimeHashes.has(target)) {
+      const code = accounts.get(target)?.code;
+      runtimeHashes.set(
+        target,
+        typeof code === "string" ? keccak256(hex(code)) : ""
+      );
+    }
+    return runtimeHashes.get(target)!;
+  };
+  for (const [a, name] of [
+    [e.safe, "SafeProxy"],
+    [e.singleton, "Safe"],
+    ...(e.operation === 1 ? [[e.multiSend, "MultiSendCallOnly"]] : [])
+  ] as [string, keyof typeof SAFE_RUNTIME_HASHES][]) {
+    const rawCode = accounts.get(a)?.code;
+    if (typeof rawCode !== "string")
+      throw Error(`Missing Safe execution-time ${name} identity`);
+    const code = hex(rawCode);
+    if (
+      code === "0x" ||
+      code.startsWith("0xef0100") ||
+      keccak256(code) !== SAFE_RUNTIME_HASHES[name]
+    )
+      throw Error(`Unsupported Safe execution-time ${name} identity`);
+  }
+  const storage = obj(accounts.get(e.safe)?.storage, "prestate storage");
+  const slot = storage["0x" + "0".repeat(64)];
+  if (addr(word(slot)) !== e.singleton)
+    throw Error("Safe prestate singleton slot mismatch");
+  const logs = trace.structLogs;
+  if (
+    !Array.isArray(logs) ||
+    logs.length < 5 ||
+    logs.length > 100000 ||
+    typeof trace.failed !== "boolean" ||
+    trace.failed !== (status === "0") ||
+    !Number.isSafeInteger(trace.gas) ||
+    trace.gas < 0 ||
+    typeof trace.returnValue !== "string" ||
+    !/^(?:0x)?(?:[a-fA-F0-9]{2})*$/.test(trace.returnValue)
+  )
+    throw Error("Malformed/truncated Safe opcode trace");
+  if (logs[0].pc !== 0 || logs[0].depth !== 1)
+    throw Error("Truncated Safe root trace");
+  const frames: Frame[] = [{ code: e.safe, storage: e.safe, role: "proxy" }];
+  let pending:
+      | { frame: Frame; required: boolean; nestedSafe?: boolean }
+      | undefined,
+    rootLoad = false,
+    rootDelegate = false,
+    batch = false,
+    inner = 0;
+  let prior: any;
+  const expectedCalls = verifySafeExecData(e);
+  for (let i = 0; i < logs.length; i++) {
+    const l = obj(logs[i], "opcode");
+    if (
+      !Number.isSafeInteger(l.pc) ||
+      l.pc < 0 ||
+      !Number.isSafeInteger(l.depth) ||
+      l.depth < 1 ||
+      typeof l.op !== "string" ||
+      !Array.isArray(l.stack) ||
+      l.stack.length > 1024 ||
+      l.error
+    )
+      throw Error("Malformed Safe opcode fields");
+    l.stack.forEach(word);
+    if (l.depth === frames.length + 1) {
+      if (!pending) throw Error("Unbound Safe child frame");
+      if (pending.nestedSafe)
+        throw Error("Unsupported nested/reentrant Safe execution");
+      frames.push(pending.frame);
+    } else {
+      if (pending?.required) throw Error("Missing Safe execution child frame");
+      if (l.depth > frames.length || l.depth < frames.length - 1)
+        throw Error("Truncated Safe frame transition");
+      if (l.depth < frames.length) {
+        if (
+          !prior ||
+          !["STOP", "RETURN", "REVERT", "SELFDESTRUCT", "INVALID"].includes(
+            prior.op
+          )
+        )
+          throw Error("Incomplete Safe child execution");
+        const child = frames.at(-1)!;
+        if (
+          child.role === "query-proxy" &&
+          (!child.query?.loaded || !child.query.delegated)
+        )
+          throw Error("Incomplete Safe query proxy execution");
+        frames.pop();
+      }
+    }
+    pending = undefined;
+    const f = frames[l.depth - 1];
+    if (!f) throw Error("Missing Safe storage context");
+    const top = (n: number) => {
+      if (l.stack.length < n) throw Error("Missing Safe trace stack");
+      return word(l.stack[l.stack.length - n]);
+    };
+    if (f.storage === e.safe && l.op === "SSTORE" && top(1) === 0n)
+      throw Error("Unsupported Safe slot0 write");
+    if (f.query && l.op === "SSTORE")
+      throw Error("Unsupported Safe query storage write");
+    if (f.role === "query-proxy" && l.op === "SLOAD") {
+      if (f.query!.loaded || l.pc !== 28 || top(1) !== 0n)
+        throw Error("Unsupported Safe query proxy SLOAD path");
+      const next = obj(logs[i + 1], "query loaded singleton");
+      if (
+        next.pc !== 29 ||
+        next.depth !== l.depth ||
+        next.op !== "AND" ||
+        !Array.isArray(next.stack) ||
+        addr(word(next.stack.at(-1))) !== f.query!.singleton
+      )
+        throw Error("Safe query actual singleton load mismatch");
+      f.query!.loaded = true;
+    }
+    if (f.role === "proxy" && l.op === "SLOAD") {
+      if (rootLoad || l.depth !== 1 || l.pc !== 28 || top(1) !== 0n)
+        throw Error("Unsupported Safe proxy SLOAD path");
+      rootLoad = true;
+      const next = obj(logs[i + 1], "loaded singleton");
+      if (
+        next.pc !== 29 ||
+        next.depth !== 1 ||
+        next.op !== "AND" ||
+        !Array.isArray(next.stack) ||
+        addr(word(next.stack.at(-1))) !== e.singleton
+      )
+        throw Error("Safe actual singleton load mismatch");
+    }
+    if (["CALL", "STATICCALL", "DELEGATECALL", "CALLCODE"].includes(l.op)) {
+      const target = addr(top(2)),
+        delegate = ["DELEGATECALL", "CALLCODE"].includes(l.op),
+        offset = top(delegate || l.op === "STATICCALL" ? 3 : 4),
+        length = top(delegate || l.op === "STATICCALL" ? 4 : 5);
+      let role: Frame["role"] = "other",
+        required = false;
+      let query: Frame["query"];
+      const memory = () => {
+        if (
+          !Array.isArray(l.memory) ||
+          l.memory.some(
+            (v: unknown) =>
+              typeof v !== "string" || !/^[0-9a-fA-F]{1,64}$/.test(v)
+          )
+        )
+          throw Error("Missing/malformed Safe trace memory");
+        const mem = l.memory.join("").toLowerCase();
+        if (length > 262144n || offset + length > BigInt(mem.length / 2))
+          throw Error("Truncated Safe calldata frame memory");
+        return (
+          "0x" + mem.slice(Number(offset) * 2, Number(offset + length) * 2)
+        );
+      };
+      if (f.role === "proxy") {
+        if (
+          rootDelegate ||
+          l.depth !== 1 ||
+          l.pc !== 94 ||
+          l.op !== "DELEGATECALL" ||
+          target !== e.singleton ||
+          !rootLoad ||
+          memory() !== input
+        )
+          throw Error("Unsupported Safe root delegate path");
+        rootDelegate = true;
+        role = "singleton";
+        required = true;
+      } else if (f.role === "query-proxy") {
+        if (
+          !f.query!.loaded ||
+          f.query!.delegated ||
+          l.pc !== 94 ||
+          l.op !== "DELEGATECALL" ||
+          target !== f.query!.singleton ||
+          runtimeHash(target) !== SAFE_RUNTIME_HASHES.Safe ||
+          memory() !== f.query!.input
+        )
+          throw Error("Unsupported Safe query delegate path");
+        f.query!.delegated = true;
+        role = "query-singleton";
+        query = { input: f.query!.input };
+        required = true;
+      } else if (f.role === "query-singleton" && l.op !== "STATICCALL") {
+        throw Error("Unsupported Safe query execution boundary");
+      } else if (f.role === "singleton" && l.op === "DELEGATECALL") {
+        if (
+          e.operation !== 1 ||
+          batch ||
+          target !== e.multiSend ||
+          memory() !== e.data
+        )
+          throw Error("Unsupported Safe singleton delegatecall");
+        batch = true;
+        role = "batch";
+        required = true;
+      } else if (
+        (f.role === "singleton" && l.op === "CALL") ||
+        (f.role === "batch" && l.op === "CALL")
+      ) {
+        const c = expectedCalls[inner++];
+        if (
+          !c ||
+          target !== c.to ||
+          top(3).toString() !== c.value ||
+          memory() !== c.data ||
+          (f.role === "singleton" && e.operation !== 0)
+        )
+          throw Error("Safe execution calls do not match full range");
+      } else if (
+        f.storage === e.safe &&
+        ["DELEGATECALL", "CALLCODE", "CALL"].includes(l.op)
+      )
+        throw Error("Unsupported extra Safe execution boundary");
+      if (role === "other" && target === e.multiSend)
+        throw Error("Unsupported nested/reentrant Safe execution");
+      const identity = role === "other" ? runtimeHash(target) : "";
+      const official =
+        identity === SAFE_RUNTIME_HASHES.SafeProxy ||
+        identity === SAFE_RUNTIME_HASHES.Safe;
+      const nestedSafe =
+        official && SAFE_EXECUTION_SELECTORS.has(memory().slice(0, 10));
+      if (official && !nestedSafe) {
+        const calldata = memory();
+        if (delegate || !SAFE_QUERY_SELECTORS.has(calldata.slice(0, 10)))
+          throw Error("Unsupported non-query Safe execution entry");
+        role =
+          identity === SAFE_RUNTIME_HASHES.SafeProxy
+            ? "query-proxy"
+            : "query-singleton";
+        query = { input: calldata };
+        if (role === "query-proxy") {
+          const storage = obj(
+            accounts.get(target)?.storage,
+            "query prestate storage"
+          );
+          query.singleton = addr(word(storage["0x" + "0".repeat(64)]));
+          if (runtimeHash(query.singleton) !== SAFE_RUNTIME_HASHES.Safe)
+            throw Error("Unsupported Safe query singleton identity");
+        }
+      }
+      pending = {
+        frame: {
+          code: target,
+          storage: delegate ? f.storage : target,
+          role,
+          query
+        },
+        required,
+        // Bind refusal to an entered official execution frame, not merely a
+        // Safe address: ordinary queries keep their business-call semantics.
+        nestedSafe
+      };
+    }
+    if (["CREATE", "CREATE2"].includes(l.op))
+      pending = {
+        frame: { code: "created", storage: "created", role: "other" },
+        required: false
+      };
+    prior = l;
+  }
+  if (
+    pending?.required ||
+    frames.length !== 1 ||
+    logs.at(-1).depth !== 1 ||
+    !["RETURN", "REVERT", "STOP"].includes(logs.at(-1).op) ||
+    !rootLoad ||
+    !rootDelegate ||
+    (e.operation === 1 && !batch) ||
+    (status === "1" && inner !== expectedCalls.length)
+  )
+    throw Error("Incomplete Safe execution trace");
+}
+import { Interface } from "ethers";
+import { decodeSafeCalls } from "./safe";
+function verifySafeExecData(e: SafeEnvelope) {
+  return e.operation === 0
+    ? [{ to: e.to, value: e.value, data: e.data, operation: 0 }]
+    : decodeSafeCalls(
+        new Interface(["function multiSend(bytes)"]).decodeFunctionData(
+          "multiSend",
+          e.data
+        )[0]
+      );
+}
+export interface SafeObservationRequest {
+  plan: unknown;
+  envelope: unknown;
+  provider: EoaRpc;
+  transactionHash: string;
+}
+/** Null/pending chain records do not advance. Reorgs during evidence collection fail closed. */
+export async function observeSafeTransaction(
+  input: SafeObservationRequest
+): Promise<TransactionObservation[] | undefined> {
+  const plan = immutableDeliveryPlan(input.plan),
+    e = parseSafeEnvelope(input.envelope, plan),
+    txHash = hash(input.transactionHash),
+    request = input.provider.request.bind(input.provider);
+  const rpc = async (m: string, p: readonly unknown[]) => {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      return await Promise.race([
+        request(m, p),
+        new Promise<never>((_, reject) => {
+          timer = setTimeout(
+            () => reject(Error("Safe evidence RPC deadline exceeded")),
+            25000
+          );
+        })
+      ]);
+    } catch (err) {
+      throw new EoaRpcFailure(err);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  };
+  if (rpcQuantity(await rpc("eth_chainId", [])) !== e.chainId)
+    throw Error("Safe chain mismatch");
+  const client = await rpc("web3_clientVersion", []);
+  if (typeof client !== "string" || !/^Geth\/v1\.15\.11(?:-|\/)/.test(client))
+    throw Error("Unsupported Safe evidence client; Geth 1.15.11 required");
+  const txRaw = await rpc("eth_getTransactionByHash", [txHash]),
+    receiptRaw = await rpc("eth_getTransactionReceipt", [txHash]);
+  if (txRaw === null || receiptRaw === null) return;
+  const tx = obj(txRaw, "transaction"),
+    receipt = obj(receiptRaw, "receipt");
+  if (
+    tx.blockHash === null ||
+    tx.blockNumber === null ||
+    tx.transactionIndex === null
+  )
+    return;
+  const type = rpcQuantity(tx.type);
+  if (!["0", "1", "2"].includes(type) || tx.authorizationList != null)
+    throw Error("Unsupported Safe outer transaction authorization/type");
+  const chain =
+    type === "0"
+      ? (BigInt(rpcQuantity(tx.v)) - 35n) / 2n
+      : BigInt(rpcQuantity(tx.chainId));
+  if (
+    chain.toString() !== e.chainId ||
+    (tx.chainId !== undefined && rpcQuantity(tx.chainId) !== e.chainId)
+  )
+    throw Error("Safe outer chain mismatch");
+  const from = address(tx.from),
+    calldata = safeBytes(hex(tx.input));
+  verifySafeExec(plan, e, calldata);
+  if (
+    hash(tx.hash) !== txHash ||
+    hash(receipt.transactionHash) !== txHash ||
+    address(tx.to) !== e.safe ||
+    address(receipt.to) !== e.safe ||
+    address(receipt.from) !== from ||
+    rpcQuantity(tx.value) !== "0" ||
+    (e.submitter.kind === "address" && from !== e.submitter.address)
+  )
+    throw Error("Safe outer envelope identity mismatch");
+  const blockHash = hash(tx.blockHash),
+    blockNumber = rpcQuantity(tx.blockNumber),
+    transactionIndex = rpcQuantity(tx.transactionIndex),
+    status = rpcQuantity(receipt.status);
+  if (
+    !["0", "1"].includes(status) ||
+    hash(receipt.blockHash) !== blockHash ||
+    rpcQuantity(receipt.blockNumber) !== blockNumber ||
+    rpcQuantity(receipt.transactionIndex) !== transactionIndex
+  )
+    throw Error("Safe receipt/inclusion mismatch");
+  const anchor = async () => {
+    if (rpcQuantity(await rpc("eth_chainId", [])) !== e.chainId)
+      throw Error("Safe chain changed");
+    const b = obj(
+      await rpc("eth_getBlockByNumber", [tag(blockNumber), false]),
+      "canonical block"
+    );
+    if (
+      hash(b.hash) !== blockHash ||
+      rpcQuantity(b.number) !== blockNumber ||
+      !Array.isArray(b.transactions) ||
+      BigInt(transactionIndex) >= BigInt(b.transactions.length) ||
+      hash(b.transactions[Number(transactionIndex)]) !== txHash
+    )
+      throw Error("Safe canonical inclusion changed");
+    const h = obj(
+      await rpc("eth_getBlockByNumber", [
+        e.finality.kind === "rpc_finalized" ? "finalized" : "latest",
+        false
+      ]),
+      "finality block"
+    );
+    const hn = rpcQuantity(h.number),
+      hh = hash(h.hash),
+      c = obj(
+        await rpc("eth_getBlockByNumber", [tag(hn), false]),
+        "canonical finality"
+      );
+    if (hash(c.hash) !== hh || rpcQuantity(c.number) !== hn)
+      throw Error("Safe finality anchor changed");
+    return e.finality.kind === "rpc_finalized"
+      ? BigInt(hn) >= BigInt(blockNumber)
+      : BigInt(hn) - BigInt(blockNumber) + 1n >= BigInt(e.finality.depth);
+  };
+  const before = await anchor();
+  const pre = await rpc("debug_traceTransaction", [
+    txHash,
+    SAFE_PRESTATE_OPTIONS
+  ]);
+  budget(pre, 2 * 1024 * 1024);
+  const trace = await rpc("debug_traceTransaction", [
+    txHash,
+    SAFE_OPCODE_OPTIONS
+  ]);
+  executionTrace(pre, trace, e, calldata, status);
+  if (
+    BigInt(obj(trace, "trace").gas).toString() !== rpcQuantity(receipt.gasUsed)
+  )
+    throw Error("Safe trace/receipt gas mismatch");
+  const after = await anchor();
+  const endTx = await rpc("eth_getTransactionByHash", [txHash]),
+    endReceipt = await rpc("eth_getTransactionReceipt", [txHash]);
+  if (
+    canonicalJson(tx) !== canonicalJson(endTx) ||
+    canonicalJson(receipt) !== canonicalJson(endReceipt)
+  )
+    throw Error("Safe transaction/receipt changed during observation");
+  if (!Array.isArray(receipt.logs)) throw Error("Missing Safe receipt logs");
+  const topics = ["ExecutionSuccess", "ExecutionFailure"].map(
+    (n) => SAFE_INTERFACE.getEvent(n)!.topicHash
+  );
+  const events = receipt.logs.filter(
+    (l: any) =>
+      address(l.address) === e.safe &&
+      Array.isArray(l.topics) &&
+      topics.includes(l.topics[0])
+  );
+  let success = false;
+  if (status === "1") {
+    if (events.length !== 1)
+      throw Error("Missing/ambiguous Safe execution result");
+    const l = events[0];
+    if (
+      l.removed === true ||
+      hash(l.transactionHash) !== txHash ||
+      hash(l.blockHash) !== blockHash ||
+      rpcQuantity(l.transactionIndex) !== transactionIndex ||
+      rpcQuantity(l.blockNumber) !== blockNumber
+    )
+      throw Error("Safe event inclusion mismatch");
+    const event = SAFE_INTERFACE.parseLog(l);
+    if (
+      !event ||
+      l.topics.length !== 2 ||
+      hex(l.data) !==
+        SAFE_INTERFACE.encodeEventLog(
+          SAFE_INTERFACE.getEvent(event.name)!,
+          event.args
+        ).data ||
+      event.args[0] !== e.expectedSafeTxHash ||
+      event.args[1] !== 0n
+    )
+      throw Error("SafeTxHash/payment event mismatch");
+    success = event.name === "ExecutionSuccess";
+  } else if (events.length)
+    throw Error("Reverted Safe receipt contains execution logs");
+  if (
+    status === "1" &&
+    hex("0x" + obj(trace, "trace").returnValue.replace(/^0x/, "")) !==
+      SAFE_INTERFACE.encodeFunctionResult("execTransaction", [success])
+  )
+    throw Error("Safe trace return/result mismatch");
+  const closed = await anchor();
+  const state =
+    before && after && closed
+      ? success
+        ? "finalized-success"
+        : "finalized-reverted"
+      : "included-unfinalized";
+  return deepFreeze(
+    plan.transactions
+      .slice(e.start, e.start + e.count)
+      .map((transaction, i) => ({
+        observationId: `${e.envelopeId}@${txHash}/${i}`,
+        executionId: plan.executionId,
+        planHash: plan.planHash,
+        chainId: plan.chainId,
+        target: plan.target,
+        transaction,
+        transactionHash: txHash,
+        state,
+        blockNumber,
+        blockHash,
+        safe: { envelopeId: e.envelopeId, innerCallIndex: i, transactionIndex }
+      })) as TransactionObservation[]
+  );
+}