@valve-tech/wallet-adapter 0.4.1 → 0.5.0

package/CHANGELOG.md

@@ -6,6 +6,85 @@ this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.5.0] — 2026-05-05
+
+### Changed — BREAKING
+
+- **All lifecycle event payloads are now rich info bags carrying full
+  `TxContext` (`chainId` + original `request`) plus phase-specific
+  fields.** The previous shapes forced consumers (especially the
+  upcoming `@valve-tech/tx-tracker`) to maintain a side-channel
+  `hash → request` map and re-fetch chainId / block timestamp / block
+  baseFeePerGas from the public client. The lib already has all of
+  that in scope when it fires events, so the consumer should never
+  have to re-gather it.
+
+  Old / new signatures:
+
+  | Hook | Old | New |
+  | ---- | --- | --- |
+  | `onAwaitingSignature` | `() => void` | `(info: TxContext) => void` |
+  | `onTransactionHash` (per-call & global) | `(hash: Hex) => void` | `(info: TxContext<{ hash }>) => void` |
+  | `onConfirmed` | `(receipt: TransactionReceipt) => void` | `(info: TxContext<{ hash, receipt, block? }>) => void` |
+  | `onFailed` | `(error: Error) => void` | `(info: TxContext<{ error, hash?, receipt?, block? }>) => void` |
+  | `onDropped` | `(info: { hash }) => void` | `(info: TxContext<{ hash }>) => void` |
+  | `onReplaced` | `(info: { original, replacement, receipt? }) => void` | `(info: TxContext<{ original, replacement, receipt?, block? }>) => void` |
+
+  The `onPhase` discriminated-union event gains the same enrichment;
+  `WritePhaseEvent` is now derived mechanically from a `WritePhaseSteps`
+  map intersected with `TxContext<Steps[K]>`, so adding a phase or a
+  shared field is a one-line edit instead of seven.
+
+- **`awaitReceiptWithHooks` now requires `request` in its options and
+  fetches the containing `Block` by default.** Signature gained
+  `request: WalletSendTransactionRequest` (used to populate `TxContext`
+  in event payloads) and `includeBlock?: boolean = true`. When
+  `includeBlock` is left at its default, the helper calls
+  `publicClient.getBlock({ blockHash })` once after a successful
+  receipt-await; the resulting `Block` is attached to `confirmed` /
+  receipt-bearing `failed` event payloads. Pass `includeBlock: false`
+  to skip the extra RPC round trip in environments that don't need
+  block-level data.
+
+- **`ReceiptAwaiter` interface gained `getBlock`.** Mocks need to add
+  a `getBlock(args: { blockHash: Hex }): Promise<Block>` field. Real
+  viem `PublicClient` instances satisfy the new shape unchanged.
+
+### Added
+
+- `WritePhaseSteps` interface — phase-name → per-phase delta map.
+  Declared as `interface` (not `type`) so consumers can extend the
+  lifecycle via declaration merging without forking the union.
+- `TxContext<Extra extends object = object>` — generic always-present
+  context (`chainId`, `request`) intersected with `Extra` to derive
+  per-phase event shapes. Defaulting `Extra` keeps `TxContext` usable
+  bare.
+- `WritePhaseEvent` is now derived mechanically as
+  `{ [K in keyof WritePhaseSteps]: { phase: K } & TxContext<WritePhaseSteps[K]> }[keyof WritePhaseSteps]`.
+- `confirmed` and `replaced` events carry an optional `block: Block`.
+  `failed` events carry the receipt-bearing context (hash, receipt,
+  block) when the failure has one (revert), and just the error +
+  context otherwise (wallet rejection, network timeout).
+
+### Migration
+
+```ts
+// before — v0.4.x
+hooks: {
+  onConfirmed: (receipt) => recordTx({ hash: receipt.transactionHash, receipt }),
+  onFailed: (error) => logFailure(error),
+}
+await awaitReceiptWithHooks({ publicClient, hash, hooks })
+
+// after — v0.5.x
+hooks: {
+  onConfirmed: (info) => recordTx(info), // info.chainId, info.request, info.hash, info.receipt, info.block
+  onFailed: (info) => logFailure(info.error, info.chainId, info.request),
+}
+await awaitReceiptWithHooks({ publicClient, hash, request, hooks })
+//                                                  ^^^^^^^ new required field
+```
+
 ## [0.4.1] — 2026-05-04
 
 ### Fixed

package/README.md

@@ -13,21 +13,27 @@ all agree on the same surface:
    named hooks (`onAwaitingSignature`, `onTransactionHash`,
    `onConfirmed`, `onFailed`, `onDropped`, `onReplaced`) plus a
    complementary single-callback shape (`onPhase(event)`) with a
-   discriminated-union payload. Fire-ers fire BOTH shapes for every
-   transition — exactly once each — so wiring named hooks doesn't
-   preclude `onPhase` and vice versa.
+   discriminated-union payload. Every payload is a `TxContext` info
+   bag — `{ chainId, request, ...phase-specific }` — so consumers
+   never have to side-channel the originating chain or the original
+   send request. Fire-ers fire BOTH shapes for every transition —
+   exactly once each — so wiring named hooks doesn't preclude
+   `onPhase` and vice versa.
 3. **`sendTransactionWithHooks(options)`** — wallet-side helper. Fires
    the pre-wallet (`onAwaitingSignature`, `onPhase('awaiting-signature')`)
-   and post-hash (`onTransactionHash`, `onPhase('pending', { hash })`)
+   and post-hash (`onTransactionHash`, `onPhase('pending', { ..., hash })`)
    transitions. Converts wallet rejections to a typed
-   `WalletRejectedError`, fires `onFailed` + `onPhase('failed', { error })`,
+   `WalletRejectedError`, fires `onFailed` + `onPhase('failed', { ..., error })`,
    then throws.
 4. **`awaitReceiptWithHooks(options)`** — chain-side helper. Awaits
-   `waitForTransactionReceipt`, fires `onConfirmed` +
-   `onPhase('confirmed', { hash, receipt })` on success, or `onFailed`
-   + `onPhase('failed', ...)` with a typed `ContractRevertedError` on
-   `status: 'reverted'`. Other receipt-await errors re-thrown unchanged
-   after firing the failure hooks.
+   `waitForTransactionReceipt`, fetches the containing block (so
+   downstream consumers don't re-fetch it for `timestamp` /
+   `baseFeePerGas`), then fires `onConfirmed` +
+   `onPhase('confirmed', { ..., hash, receipt, block })` on success,
+   or `onFailed` + `onPhase('failed', ...)` with a typed
+   `ContractRevertedError` on `status: 'reverted'`. Other receipt-await
+   errors re-thrown unchanged after firing the failure hooks. Pass
+   `includeBlock: false` to skip the block fetch.
 5. **`TX_STATUS` / `TrackedTx`** — vocabulary for "this transaction is
    in flight" UIs (toast strips, inline indicators, history panes) so
    they can sit on top of any tracker without redefining state names.
@@ -93,28 +99,35 @@ export class MyClient {
     private wallet: WalletAdapter,
     private chainId: number,
     private escrow: `0x${string}`,
-    /** Optional global / analytics channel — fires alongside the per-call hook. */
-    private onTransactionHash?: (hash: `0x${string}`) => void,
+    /**
+     * Optional global / analytics channel — fires alongside the per-call hook.
+     * Receives the rich `{ chainId, request, hash }` info bag, so analytics
+     * observers see the originating chain and request without a side channel.
+     */
+    private onTransactionHash?: WriteHookParams['onTransactionHash'],
   ) {}
 
   async deposit(params: MyWriteParams & WriteHookParams) {
+    const request = {
+      to: this.escrow,
+      data: this.encodeDeposit(params),
+      chainId: this.chainId,
+    }
     try {
       const hash = await sendTransactionWithHooks({
         wallet: this.wallet,
-        request: {
-          to: this.escrow,
-          data: this.encodeDeposit(params),
-          chainId: this.chainId,
-        },
+        request,
         hooks: params,
         onTransactionHash: this.onTransactionHash,
       })
       const receipt = await awaitReceiptWithHooks({
         publicClient: this.publicClient,
         hash,
+        request,                 // carried into every phase event as part of TxContext
         hooks: params,
       })
       // protocol-specific work here (decode logs, etc.) — onConfirmed already fired
+      // with { chainId, request, hash, receipt, block } in scope
       return { hash, receipt }
     } catch (err) {
       if (err instanceof WalletRejectedError) {
@@ -131,28 +144,33 @@ export class MyClient {
 
 `sendTransactionWithHooks` guarantees:
 
-- `onAwaitingSignature` fires **once**, **immediately before**
-  `wallet.sendTransaction`.
-- `onTransactionHash` (per-call **and** global) fires **once each**,
-  **after** `sendTransaction` resolves and **before** any receipt-await.
+- `onAwaitingSignature` fires **once** with `{ chainId, request }`,
+  **immediately before** `wallet.sendTransaction`.
+- `onTransactionHash` (per-call **and** global) fires **once each**
+  with `{ chainId, request, hash }`, **after** `sendTransaction`
+  resolves and **before** any receipt-await.
 - Wallet rejections — detected via the three-signal check in
   `@valve-tech/viem-errors` (EIP-1193 `code === 4001`, viem class name,
   message regex, anywhere in the cause chain) — are thrown as
-  `WalletRejectedError`. `onFailed` fires with the rejection error
-  before the throw.
-- Any other thrown error fires `onFailed` and re-throws unchanged so
-  the SDK keeps control of its error mapping.
+  `WalletRejectedError`. `onFailed` fires with
+  `{ chainId, request, error: <WalletRejectedError> }` before the throw.
+- Any other thrown error fires `onFailed` (with `error: <thrown>`) and
+  re-throws unchanged so the SDK keeps control of its error mapping.
 
 `awaitReceiptWithHooks` guarantees:
 
-- On `receipt.status === 'success'`: fires `onConfirmed(receipt)` and
+- On `receipt.status === 'success'`: fetches the containing block
+  (unless `includeBlock: false`), then fires
+  `onConfirmed({ chainId, request, hash, receipt, block? })` and
   resolves with the receipt.
-- On `receipt.status === 'reverted'`: fires `onFailed` with a
-  `ContractRevertedError` (carrying `hash` + the full `receipt` for
-  log inspection) and throws it.
+- On `receipt.status === 'reverted'`: fetches the block, then fires
+  `onFailed({ chainId, request, hash, receipt, block?, error: <ContractRevertedError> })`
+  and throws the error. `ContractRevertedError` carries `hash` + the
+  full `receipt` for log inspection.
 - On any thrown error during the receipt-await (network / RPC /
-  abort): fires `onFailed` with the original error and re-throws
-  unchanged.
+  abort): fires `onFailed({ chainId, request, error })` (no
+  `hash`/`receipt`/`block`) and re-throws unchanged. The block fetch
+  is skipped when the receipt itself fails to arrive.
 
 A `WriteHookParams` consumer (toast strip, inline indicator, etc.)
 that wires all four hooks can drive its full state machine — pre-wallet
@@ -184,11 +202,13 @@ function subtitle(tx: TrackedTx): string {
 | `WalletAdapter` | type | `{ address?, sendTransaction(req), readContract?(req) }` |
 | `WalletSendTransactionRequest` | type | EIP-1559 send shape — `{ to, data, value?, chainId, maxFeePerGas?, maxPriorityFeePerGas? }` |
 | `WalletReadContractRequest` | type | `{ address, abi, functionName, args?, chainId? }` |
-| `WriteHookParams` | type | six named hooks (`onAwaitingSignature`, `onTransactionHash`, `onConfirmed`, `onFailed`, `onDropped`, `onReplaced`) + `onPhase(event)` |
+| `WriteHookParams` | type | six named hooks (`onAwaitingSignature`, `onTransactionHash`, `onConfirmed`, `onFailed`, `onDropped`, `onReplaced`) + `onPhase(event)`. Every callback receives a `TxContext<Steps[K]>` info bag. |
 | `WritePhase` | type | `'preparing' \| 'awaiting-signature' \| 'pending' \| 'confirmed' \| 'failed' \| 'dropped' \| 'replaced'` |
-| `WritePhaseEvent` | type | discriminated union of phase + payload |
+| `WritePhaseSteps` | interface | per-phase data delta map. `pending: { hash }`, `confirmed: { hash, receipt, block? }`, etc. Open to declaration merging. |
+| `TxContext<Extra>` | type | `{ chainId, request } & Extra`. The always-present context intersected with the per-phase delta. Defaults `Extra` to `object`. |
+| `WritePhaseEvent` | type | derived `{ [K in keyof WritePhaseSteps]: { phase: K } & TxContext<WritePhaseSteps[K]> }[keyof WritePhaseSteps]`. |
 | `sendTransactionWithHooks(opts)` | function | `{ wallet, request, hooks?, onTransactionHash? } → Promise<Hex>`. Wallet-side helper. |
-| `awaitReceiptWithHooks(opts)` | function | `{ publicClient, hash, hooks? } → Promise<TransactionReceipt>`. Chain-side helper. |
+| `awaitReceiptWithHooks(opts)` | function | `{ publicClient, hash, request, includeBlock?, hooks? } → Promise<TransactionReceipt>`. Chain-side helper; fetches the containing block by default. |
 | `WalletRejectedError` | class | `Error` subclass with `cause: Error`. Thrown by `sendTransactionWithHooks` on user rejection. |
 | `ContractRevertedError` | class | `Error` subclass with `hash` + `receipt`. Thrown by `awaitReceiptWithHooks` on `status: reverted`. |
 | `SendTransactionWithHooksOptions` / `AwaitReceiptWithHooksOptions` / `ReceiptAwaiter` | type | options + minimal client shape |
@@ -206,6 +226,22 @@ function subtitle(tx: TrackedTx): string {
   state-machine consumers. Fire-ers fire BOTH shapes for every
   transition — exactly once each. Wiring named hooks doesn't preclude
   `onPhase` and vice versa.
+- **Rich payloads, not bare arguments.** Every event carries
+  `TxContext` (`chainId` + the original `request`) on top of its
+  phase-specific fields. The lib already has all of that in scope
+  when it fires events; the alternative — `(receipt) => void` and
+  `(hash) => void` — forces every consumer to maintain a side-channel
+  `hash → request` map and call `client.chain.id` from inside their
+  callbacks. `awaitReceiptWithHooks` also fetches the containing
+  block once and includes it on `confirmed` / receipt-bearing
+  `failed` events, so downstream consumers (notably
+  `@valve-tech/tx-tracker`) skip the round trip.
+- **`WritePhaseSteps` is the single source of truth for phase
+  shapes.** `WritePhaseEvent` is derived mechanically as
+  `{ [K in keyof WritePhaseSteps]: { phase: K } & TxContext<WritePhaseSteps[K]> }`,
+  so adding a phase is one entry in the map plus a fire-er. Adding a
+  shared field is one entry in `TxContext`. Both stay in lockstep
+  with the named hook signatures.
 - **`onFailed` is the unified failure callback for revert / rejection /
   network errors.** Wallet rejection, on-chain revert, and network
   errors all flow through it. `instanceof` against

package/dist/hooks.d.ts

@@ -29,8 +29,17 @@
  *
  * Fire-ers fire BOTH shapes for every transition — exactly once each —
  * so consumers can choose which to wire without affecting the other.
+ *
+ * Every payload carries a `TxContext` (`chainId` + `request`) so
+ * consumers never have to side-channel the originating chain or the
+ * original send request to use the events. `confirmed` and
+ * receipt-bearing `failed` events also carry the containing `Block` so
+ * downstream trackers don't have to re-fetch it for timestamp / fee
+ * analytics — that's the "don't make consumers re-gather what we
+ * already have" rule the events are designed around.
  */
-import type { Hex, TransactionReceipt } from 'viem';
+import type { Block, Hex, TransactionReceipt } from 'viem';
+import type { WalletSendTransactionRequest } from './wallet.js';
 /**
  * Every lifecycle phase a tracked transaction can be in, from intent
  * through terminal observation. Carriers (helpers, trackers, SDKs)
@@ -39,45 +48,98 @@ import type { Hex, TransactionReceipt } from 'viem';
  */
 export type WritePhase = 'preparing' | 'awaiting-signature' | 'pending' | 'confirmed' | 'failed' | 'dropped' | 'replaced';
 /**
- * Discriminated-union event payload for the `onPhase` callback. Switch
- * on `event.phase` and TypeScript narrows the rest of the fields
- * automatically — no `event.context?.receipt` indirection.
+ * Per-phase data delta. Each entry is exactly the fields available at
+ * that phase BEYOND the always-present `TxContext` (`chainId`,
+ * `request`).
+ *
+ * Adding a new phase is one entry here plus a fire-er; adding a new
+ * shared field is one entry in `TxContext`. The `WritePhaseEvent`
+ * union is derived from this map, so variants stay in lockstep
+ * mechanically.
+ *
+ * Declared as an `interface` (not a `type`) so consumers can use
+ * declaration merging to extend the map with their own phases — useful
+ * for trackers that surface implementation-specific transitions
+ * without forking the union.
+ *
+ * `block` is optional on `confirmed` / `failed` / `replaced` because
+ * `awaitReceiptWithHooks` allows opting out of the block fetch via
+ * `includeBlock: false`. Trackers that observe `replaced` from the
+ * mempool may also fire it without a receipt.
+ */
+export interface WritePhaseSteps {
+    preparing: object;
+    'awaiting-signature': object;
+    pending: {
+        hash: Hex;
+    };
+    confirmed: {
+        hash: Hex;
+        receipt: TransactionReceipt;
+        block?: Block;
+    };
+    failed: {
+        error: Error;
+        hash?: Hex;
+        receipt?: TransactionReceipt;
+        block?: Block;
+    };
+    dropped: {
+        hash: Hex;
+    };
+    replaced: {
+        original: Hex;
+        replacement: Hex;
+        receipt?: TransactionReceipt;
+        block?: Block;
+    };
+}
+/**
+ * Always-present transaction context surrounding every phase event.
+ * Carries the chain identity and the original send request so
+ * consumers don't have to maintain a side-channel `hash → request` map
+ * or call `client.chain.id` from inside their callbacks.
+ *
+ * `Extra` is the per-phase delta from `WritePhaseSteps[K]`. Defaulting
+ * `Extra` to `object` lets the bare `TxContext` describe phases with
+ * no extra fields (`preparing`, `awaiting-signature`).
+ */
+export type TxContext<Extra extends object = object> = {
+    /** Chain id this transaction targets. Pulled off `request.chainId`. */
+    chainId: number;
+    /**
+     * The fully-formed wallet send request as passed into the SDK
+     * (`to`, `data`, `value`, `chainId`, gas inputs). Carried verbatim
+     * so consumers can construct a tracked-tx record or replay the
+     * input without extra plumbing.
+     */
+    request: WalletSendTransactionRequest;
+} & Extra;
+/**
+ * Discriminated-union event payload for the `onPhase` callback.
+ * Switch on `event.phase` and TypeScript narrows the rest of the
+ * fields automatically — no `event.context?.receipt` indirection.
+ *
+ * Derived mechanically from `WritePhaseSteps` × `TxContext` so adding
+ * a phase to the map is the only edit needed to extend the union.
  */
 export type WritePhaseEvent = {
-    phase: 'preparing';
-} | {
-    phase: 'awaiting-signature';
-} | {
-    phase: 'pending';
-    hash: Hex;
-} | {
-    phase: 'confirmed';
-    hash: Hex;
-    receipt: TransactionReceipt;
-} | {
-    phase: 'failed';
-    error: Error;
-    hash?: Hex;
-    receipt?: TransactionReceipt;
-} | {
-    phase: 'dropped';
-    hash: Hex;
-} | {
-    phase: 'replaced';
-    original: Hex;
-    replacement: Hex;
-    receipt?: TransactionReceipt;
-};
+    [K in keyof WritePhaseSteps]: {
+        phase: K;
+    } & TxContext<WritePhaseSteps[K]>;
+}[keyof WritePhaseSteps];
 /**
  * Per-call hooks fired at real boundaries during a tracked tx's
  * lifecycle. Every field is optional. SDKs and trackers fire whichever
  * subset corresponds to phases they actually observe; consumers wire
  * only the ones their UI needs.
  *
- * Named hooks vs `onPhase`: complementary, not alternatives. A
- * fire-er fires both for every transition — the named hook (if a
- * consumer wired it) and `onPhase` (if a consumer wired it) — so no
- * transition is observable from one shape but not the other.
+ * Each named hook receives a `TxContext<WritePhaseSteps[K]>` info bag
+ * matching the phase. The `onPhase` complement receives the full
+ * discriminated union. Fire-ers fire both for every transition — the
+ * named hook (if a consumer wired it) and `onPhase` (if a consumer
+ * wired it) — so no transition is observable from one shape but not
+ * the other.
  */
 export interface WriteHookParams {
     /**
@@ -85,34 +147,42 @@ export interface WriteHookParams {
      * from "preparing" to "awaiting wallet signature" at the precise
      * boundary, regardless of how much pre-wallet work the SDK did.
      */
-    onAwaitingSignature?: () => void;
+    onAwaitingSignature?: (info: TxContext<WritePhaseSteps['awaiting-signature']>) => void;
     /**
-     * Called once with the on-chain tx hash, immediately after
-     * `sendTransaction` resolves and *before* any receipt-await. UI flips
-     * from "awaiting" to "pending" the moment the hash exists.
+     * Called once with the on-chain tx hash plus full context,
+     * immediately after `sendTransaction` resolves and *before* any
+     * receipt-await. UI flips from "awaiting" to "pending" the moment
+     * the hash exists.
      *
      * Per-call vs constructor-level: SDKs may also expose a separate
      * constructor-level `onTransactionHash` channel for analytics /
-     * global observers — they're complementary, fire on the same line.
+     * global observers — they're complementary, fire on the same line
+     * with the same payload.
      */
-    onTransactionHash?: (hash: Hex) => void;
+    onTransactionHash?: (info: TxContext<WritePhaseSteps['pending']>) => void;
     /**
-     * Called once with the mined receipt when `receipt.status === 'success'`.
-     * UI flips to a terminal "confirmed" state. Receives the full receipt
-     * so consumers can extract block number, gas used, decoded events.
+     * Called once when `receipt.status === 'success'`. Receives the full
+     * info bag — `hash`, `receipt`, optional `block` (present unless
+     * `includeBlock: false` was passed), plus `chainId` and `request` —
+     * so consumers don't re-fetch the block for timestamp / baseFee
+     * UI.
      */
-    onConfirmed?: (receipt: TransactionReceipt) => void;
+    onConfirmed?: (info: TxContext<WritePhaseSteps['confirmed']>) => void;
     /**
-     * Called once with the underlying error on any terminal failure that
-     * is NOT a replacement or a drop:
+     * Called once with the underlying error (and any context available
+     * at the failure point) on any terminal failure that is NOT a
+     * replacement or a drop:
      *   - wallet rejection (`WalletRejectedError`)
      *   - on-chain revert (`ContractRevertedError`)
      *   - any other thrown error from the wallet or RPC.
      *
-     * Use `instanceof` against `WalletRejectedError` / `ContractRevertedError`
-     * to discriminate; everything else is a plain `Error`.
+     * Use `instanceof` against `WalletRejectedError` /
+     * `ContractRevertedError` to discriminate; everything else is a
+     * plain `Error`. Wallet-side failures carry no `hash` / `receipt`;
+     * receipt-bearing failures (revert) carry both, plus the block
+     * (unless `includeBlock: false`).
      */
-    onFailed?: (error: Error) => void;
+    onFailed?: (info: TxContext<WritePhaseSteps['failed']>) => void;
     /**
      * Called once when a tracker has determined the tx will not be
      * included — typically: not seen in mempool for N consecutive blocks
@@ -124,24 +194,18 @@ export interface WriteHookParams {
      * observation. Wire this against a `tx-tracker` instance, not against
      * `awaitReceiptWithHooks`.
      */
-    onDropped?: (info: {
-        hash: Hex;
-    }) => void;
+    onDropped?: (info: TxContext<WritePhaseSteps['dropped']>) => void;
     /**
      * Called once when a tracker observes that a *different* tx with the
      * same nonce mined in place of the one we were watching — typically
      * the user's own speed-up / cancel from their wallet, or a
      * fee-replacement broadcast separately.
      *
-     * `replacement.receipt` is included when the replacement has been
-     * mined; trackers may emit `replaced` with no receipt if they only
-     * saw the replacement in the mempool.
+     * `info.receipt` and `info.block` are populated when the replacement
+     * has been mined; trackers may emit `replaced` without them if they
+     * only saw the replacement in the mempool.
      */
-    onReplaced?: (info: {
-        original: Hex;
-        replacement: Hex;
-        receipt?: TransactionReceipt;
-    }) => void;
+    onReplaced?: (info: TxContext<WritePhaseSteps['replaced']>) => void;
     /**
      * Single-callback complement to the named hooks. Fires for every
      * lifecycle transition with a discriminated-union payload. Useful

package/dist/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,kBAAkB,EAAE,MAAM,MAAM,CAAA;AAEnD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAClB,WAAW,GACX,oBAAoB,GACpB,SAAS,GACT,WAAW,GACX,QAAQ,GACR,SAAS,GACT,UAAU,CAAA;AAEd;;;;GAIG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,KAAK,EAAE,WAAW,CAAA;CAAE,GACtB;IAAE,KAAK,EAAE,oBAAoB,CAAA;CAAE,GAC/B;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAE,GAC/B;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,GAAG,CAAC;IAAC,OAAO,EAAE,kBAAkB,CAAA;CAAE,GAC9D;IAAE,KAAK,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC;IAAC,IAAI,CAAC,EAAE,GAAG,CAAC;IAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;CAAE,GAC3E;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAE,GAC/B;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,GAAG,CAAC;IAAC,WAAW,EAAE,GAAG,CAAC;IAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;CAAE,CAAA;AAExF;;;;;;;;;;GAUG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,IAAI,CAAA;IAChC;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;IACvC;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,IAAI,CAAA;IACnD;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IACjC;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,GAAG,CAAA;KAAE,KAAK,IAAI,CAAA;IACzC;;;;;;;;;OASG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,GAAG,CAAC;QAAC,WAAW,EAAE,GAAG,CAAC;QAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;KAAE,KAAK,IAAI,CAAA;IAC9F;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAA;CAC3C"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,kBAAkB,EAAE,MAAM,MAAM,CAAA;AAC1D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAA;AAE/D;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAClB,WAAW,GACX,oBAAoB,GACpB,SAAS,GACT,WAAW,GACX,QAAQ,GACR,SAAS,GACT,UAAU,CAAA;AAEd;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,OAAO,EAAE;QAAE,IAAI,EAAE,GAAG,CAAA;KAAE,CAAA;IACtB,SAAS,EAAE;QAAE,IAAI,EAAE,GAAG,CAAC;QAAC,OAAO,EAAE,kBAAkB,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,CAAA;IACpE,MAAM,EAAE;QAAE,KAAK,EAAE,KAAK,CAAC;QAAC,IAAI,CAAC,EAAE,GAAG,CAAC;QAAC,OAAO,CAAC,EAAE,kBAAkB,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,CAAA;IACjF,OAAO,EAAE;QAAE,IAAI,EAAE,GAAG,CAAA;KAAE,CAAA;IACtB,QAAQ,EAAE;QAAE,QAAQ,EAAE,GAAG,CAAC;QAAC,WAAW,EAAE,GAAG,CAAC;QAAC,OAAO,CAAC,EAAE,kBAAkB,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,CAAA;CAC3F;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,IAAI;IACrD,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAA;IACf;;;;;OAKG;IACH,OAAO,EAAE,4BAA4B,CAAA;CACtC,GAAG,KAAK,CAAA;AAET;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG;KAC3B,CAAC,IAAI,MAAM,eAAe,GAAG;QAAE,KAAK,EAAE,CAAC,CAAA;KAAE,GAAG,SAAS,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;CAC3E,CAAC,MAAM,eAAe,CAAC,CAAA;AAExB;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,eAAe,CAAC,oBAAoB,CAAC,CAAC,KAAK,IAAI,CAAA;IACtF;;;;;;;;;;OAUG;IACH,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,KAAK,IAAI,CAAA;IACzE;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC,KAAK,IAAI,CAAA;IACrE;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,KAAK,IAAI,CAAA;IAC/D;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,KAAK,IAAI,CAAA;IACjE;;;;;;;;;OASG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,KAAK,IAAI,CAAA;IACnE;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAA;CAC3C"}

package/dist/hooks.js

@@ -29,6 +29,14 @@
  *
  * Fire-ers fire BOTH shapes for every transition — exactly once each —
  * so consumers can choose which to wire without affecting the other.
+ *
+ * Every payload carries a `TxContext` (`chainId` + `request`) so
+ * consumers never have to side-channel the originating chain or the
+ * original send request to use the events. `confirmed` and
+ * receipt-bearing `failed` events also carry the containing `Block` so
+ * downstream trackers don't have to re-fetch it for timestamp / fee
+ * analytics — that's the "don't make consumers re-gather what we
+ * already have" rule the events are designed around.
  */
 export {};
 //# sourceMappingURL=hooks.js.map

package/dist/hooks.js.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG"}
+{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG"}

package/dist/index.d.ts

@@ -2,7 +2,7 @@
  * @fileoverview Public API of `@valve-tech/wallet-adapter`.
  */
 export type { WalletAdapter, WalletSendTransactionRequest, WalletReadContractRequest, } from './wallet.js';
-export type { WriteHookParams, WritePhase, WritePhaseEvent, } from './hooks.js';
+export type { TxContext, WriteHookParams, WritePhase, WritePhaseEvent, WritePhaseSteps, } from './hooks.js';
 export { TX_STATUS, TX_FLOW, STALE_TX_AGE_MS, CONFIRMED_DISPLAY_MS, FAILED_DISPLAY_MS, } from './tx-status.js';
 export type { TrackedTx, TrackedTxGas, TrackedTxStatus, TxFlow, TxConfirmedCallback, } from './tx-status.js';
 export { sendTransactionWithHooks, WalletRejectedError, type SendTransactionWithHooksOptions, } from './send.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,YAAY,EACV,aAAa,EACb,4BAA4B,EAC5B,yBAAyB,GAC1B,MAAM,aAAa,CAAA;AAEpB,YAAY,EACV,eAAe,EACf,UAAU,EACV,eAAe,GAChB,MAAM,YAAY,CAAA;AAEnB,OAAO,EACL,SAAS,EACT,OAAO,EACP,eAAe,EACf,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EACV,SAAS,EACT,YAAY,EACZ,eAAe,EACf,MAAM,EACN,mBAAmB,GACpB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,wBAAwB,EACxB,mBAAmB,EACnB,KAAK,+BAA+B,GACrC,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,4BAA4B,EACjC,KAAK,cAAc,GACpB,MAAM,cAAc,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,YAAY,EACV,aAAa,EACb,4BAA4B,EAC5B,yBAAyB,GAC1B,MAAM,aAAa,CAAA;AAEpB,YAAY,EACV,SAAS,EACT,eAAe,EACf,UAAU,EACV,eAAe,EACf,eAAe,GAChB,MAAM,YAAY,CAAA;AAEnB,OAAO,EACL,SAAS,EACT,OAAO,EACP,eAAe,EACf,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EACV,SAAS,EACT,YAAY,EACZ,eAAe,EACf,MAAM,EACN,mBAAmB,GACpB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,wBAAwB,EACxB,mBAAmB,EACnB,KAAK,+BAA+B,GACrC,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,4BAA4B,EACjC,KAAK,cAAc,GACpB,MAAM,cAAc,CAAA"}

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAcH,OAAO,EACL,SAAS,EACT,OAAO,EACP,eAAe,EACf,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,gBAAgB,CAAA;AAUvB,OAAO,EACL,wBAAwB,EACxB,mBAAmB,GAEpB,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,qBAAqB,EACrB,qBAAqB,GAGtB,MAAM,cAAc,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAgBH,OAAO,EACL,SAAS,EACT,OAAO,EACP,eAAe,EACf,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,gBAAgB,CAAA;AAUvB,OAAO,EACL,wBAAwB,EACxB,mBAAmB,GAEpB,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,qBAAqB,EACrB,qBAAqB,GAGtB,MAAM,cAAc,CAAA"}

package/dist/receipt.d.ts

@@ -3,14 +3,19 @@
  *
  * After the wallet returns a hash, an SDK has to:
  *   1. Await the receipt.
- *   2. Distinguish `success` from `reverted`.
- *   3. Fire `onConfirmed` (success) or `onFailed` with a typed revert
+ *   2. Pull the containing block (so consumers don't re-fetch it just
+ *      for `timestamp` / `baseFeePerGas`).
+ *   3. Distinguish `success` from `reverted`.
+ *   4. Fire `onConfirmed` (success) or `onFailed` with a typed revert
  *      error (reverted), plus `onPhase` for the same transition, so any
  *      UI wired against `WriteHookParams` flips to a terminal state.
  *
- * Without a helper for this, every SDK re-implements the receipt-await +
- * status-check + typed-error-throw block — the same drift trap
- * `sendTransactionWithHooks` was added to fix on the wallet side.
+ * Without a helper for this, every SDK re-implements: the receipt-await
+ * + block-fetch + status-check + typed-error-throw block — and worse,
+ * every SDK either re-fetches the block in its own callbacks or skips
+ * it and forces every consumer to fetch it. The amortization here is
+ * the whole point: one `getBlock` call inside this helper, every
+ * downstream consumer skips it.
  *
  * Drop detection (tx vanished from mempool without inclusion) and
  * replacement detection are deliberately NOT in this helper. They
@@ -20,8 +25,9 @@
  * defines `onDropped` / `onReplaced` so consumers can wire them once;
  * this helper just doesn't fire them.
  */
-import type { Hex, TransactionReceipt } from 'viem';
+import type { Block, Hex, TransactionReceipt } from 'viem';
 import type { WriteHookParams } from './hooks.js';
+import type { WalletSendTransactionRequest } from './wallet.js';
 /**
  * Thrown by `awaitReceiptWithHooks` when the receipt arrives with
  * `status === 'reverted'`. The full receipt is preserved so consumers
@@ -42,30 +48,60 @@ export declare class ContractRevertedError extends Error {
  * Minimal viem `PublicClient` slice the helper needs. Defining it
  * locally lets consumers pass a viem client OR a hand-rolled mock
  * without depending on the full `PublicClient` surface.
+ *
+ * `getBlock` is invoked once on receipt success / revert (when
+ * `includeBlock` is left at its default of `true`) so the resulting
+ * `confirmed` / `failed` event payload carries the block timestamp,
+ * baseFeePerGas, etc. without forcing every consumer to fetch it.
  */
 export interface ReceiptAwaiter {
     waitForTransactionReceipt(args: {
         hash: Hex;
     }): Promise<TransactionReceipt>;
+    getBlock(args: {
+        blockHash: Hex;
+    }): Promise<Block>;
 }
 export interface AwaitReceiptWithHooksOptions {
-    /** A viem `PublicClient` (or anything with the same `waitForTransactionReceipt` shape). */
+    /** A viem `PublicClient` (or anything with the same shape). */
     publicClient: ReceiptAwaiter;
     /** The hash returned by `sendTransactionWithHooks` (or any other broadcast path). */
     hash: Hex;
-    /** Per-call hooks. `onMined` and `onFailed` fire from this helper. */
+    /**
+     * The original send request. Carried into all phase events as part
+     * of the always-present `TxContext` so consumers don't have to
+     * maintain a side-channel `hash → request` map.
+     */
+    request: WalletSendTransactionRequest;
+    /**
+     * Whether to fetch and attach the containing `Block` to `confirmed`
+     * and revert-`failed` event payloads. Defaults to `true` — the
+     * helper is the right place to amortize the block fetch on behalf of
+     * every downstream consumer. Pass `false` to skip the extra RPC
+     * round trip when no consumer needs block-level data.
+     */
+    includeBlock?: boolean;
+    /** Per-call hooks. `onConfirmed` and `onFailed` fire from this helper. */
     hooks?: WriteHookParams;
 }
 /**
- * Await a transaction receipt and fire the post-hash lifecycle hooks.
+ * Await a transaction receipt and fire the post-hash lifecycle hooks
+ * with rich payloads (chainId, request, hash, receipt, block).
+ *
  * Throws `ContractRevertedError` on revert. Other errors during the
  * receipt-await are re-thrown unchanged after `onFailed` fires.
  *
  * @example
  * ```ts
  * const hash = await sendTransactionWithHooks({ wallet, request, hooks })
- * const receipt = await awaitReceiptWithHooks({ publicClient, hash, hooks })
- * // Both onMined / onFailed have fired by the time we get here.
+ * const receipt = await awaitReceiptWithHooks({
+ *   publicClient,
+ *   hash,
+ *   request,        // same shape passed to sendTransactionWithHooks
+ *   hooks,
+ * })
+ * // onConfirmed / onFailed have fired by the time we get here, with
+ * // chainId + request + hash + receipt + block in scope.
  * ```
  */
 export declare function awaitReceiptWithHooks(options: AwaitReceiptWithHooksOptions): Promise<TransactionReceipt>;

package/dist/receipt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"receipt.d.ts","sourceRoot":"","sources":["../src/receipt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,kBAAkB,EAAE,MAAM,MAAM,CAAA;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAA;IAClB,qDAAqD;IACrD,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAA;gBAExB,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,kBAAkB;CAMnD;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,yBAAyB,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,GAAG,CAAA;KAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAA;CAC5E;AAED,MAAM,WAAW,4BAA4B;IAC3C,2FAA2F;IAC3F,YAAY,EAAE,cAAc,CAAA;IAC5B,qFAAqF;IACrF,IAAI,EAAE,GAAG,CAAA;IACT,sEAAsE;IACtE,KAAK,CAAC,EAAE,eAAe,CAAA;CACxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,kBAAkB,CAAC,CAuB7B"}
+{"version":3,"file":"receipt.d.ts","sourceRoot":"","sources":["../src/receipt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,kBAAkB,EAAE,MAAM,MAAM,CAAA;AAC1D,OAAO,KAAK,EAAa,eAAe,EAAmB,MAAM,YAAY,CAAA;AAC7E,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAA;AAE/D;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAA;IAClB,qDAAqD;IACrD,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAA;gBAExB,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,kBAAkB;CAMnD;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc;IAC7B,yBAAyB,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,GAAG,CAAA;KAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAA;IAC3E,QAAQ,CAAC,IAAI,EAAE;QAAE,SAAS,EAAE,GAAG,CAAA;KAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAA;CACnD;AAED,MAAM,WAAW,4BAA4B;IAC3C,+DAA+D;IAC/D,YAAY,EAAE,cAAc,CAAA;IAC5B,qFAAqF;IACrF,IAAI,EAAE,GAAG,CAAA;IACT;;;;OAIG;IACH,OAAO,EAAE,4BAA4B,CAAA;IACrC;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,eAAe,CAAA;CACxB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,kBAAkB,CAAC,CA0C7B"}

package/dist/receipt.js

@@ -3,14 +3,19 @@
  *
  * After the wallet returns a hash, an SDK has to:
  *   1. Await the receipt.
- *   2. Distinguish `success` from `reverted`.
- *   3. Fire `onConfirmed` (success) or `onFailed` with a typed revert
+ *   2. Pull the containing block (so consumers don't re-fetch it just
+ *      for `timestamp` / `baseFeePerGas`).
+ *   3. Distinguish `success` from `reverted`.
+ *   4. Fire `onConfirmed` (success) or `onFailed` with a typed revert
  *      error (reverted), plus `onPhase` for the same transition, so any
  *      UI wired against `WriteHookParams` flips to a terminal state.
  *
- * Without a helper for this, every SDK re-implements the receipt-await +
- * status-check + typed-error-throw block — the same drift trap
- * `sendTransactionWithHooks` was added to fix on the wallet side.
+ * Without a helper for this, every SDK re-implements: the receipt-await
+ * + block-fetch + status-check + typed-error-throw block — and worse,
+ * every SDK either re-fetches the block in its own callbacks or skips
+ * it and forces every consumer to fetch it. The amortization here is
+ * the whole point: one `getBlock` call inside this helper, every
+ * downstream consumer skips it.
  *
  * Drop detection (tx vanished from mempool without inclusion) and
  * replacement detection are deliberately NOT in this helper. They
@@ -38,37 +43,63 @@ export class ContractRevertedError extends Error {
     }
 }
 /**
- * Await a transaction receipt and fire the post-hash lifecycle hooks.
+ * Await a transaction receipt and fire the post-hash lifecycle hooks
+ * with rich payloads (chainId, request, hash, receipt, block).
+ *
  * Throws `ContractRevertedError` on revert. Other errors during the
  * receipt-await are re-thrown unchanged after `onFailed` fires.
  *
  * @example
  * ```ts
  * const hash = await sendTransactionWithHooks({ wallet, request, hooks })
- * const receipt = await awaitReceiptWithHooks({ publicClient, hash, hooks })
- * // Both onMined / onFailed have fired by the time we get here.
+ * const receipt = await awaitReceiptWithHooks({
+ *   publicClient,
+ *   hash,
+ *   request,        // same shape passed to sendTransactionWithHooks
+ *   hooks,
+ * })
+ * // onConfirmed / onFailed have fired by the time we get here, with
+ * // chainId + request + hash + receipt + block in scope.
  * ```
  */
 export async function awaitReceiptWithHooks(options) {
-    const { publicClient, hash, hooks } = options;
+    const { publicClient, hash, request, includeBlock = true, hooks } = options;
+    const ctx = { chainId: request.chainId, request };
     let receipt;
     try {
         receipt = await publicClient.waitForTransactionReceipt({ hash });
     }
     catch (err) {
         const failure = err instanceof Error ? err : new Error(String(err));
-        hooks?.onFailed?.(failure);
-        hooks?.onPhase?.({ phase: 'failed', error: failure, hash });
+        const failedInfo = { ...ctx, error: failure };
+        hooks?.onFailed?.(failedInfo);
+        hooks?.onPhase?.({ phase: 'failed', ...failedInfo });
         throw failure;
     }
+    const block = includeBlock
+        ? await publicClient.getBlock({ blockHash: receipt.blockHash })
+        : undefined;
     if (receipt.status === 'reverted') {
         const revert = new ContractRevertedError(hash, receipt);
-        hooks?.onFailed?.(revert);
-        hooks?.onPhase?.({ phase: 'failed', error: revert, hash, receipt });
+        const failedInfo = {
+            ...ctx,
+            error: revert,
+            hash,
+            receipt,
+            ...(block ? { block } : {}),
+        };
+        hooks?.onFailed?.(failedInfo);
+        hooks?.onPhase?.({ phase: 'failed', ...failedInfo });
         throw revert;
     }
-    hooks?.onConfirmed?.(receipt);
-    hooks?.onPhase?.({ phase: 'confirmed', hash, receipt });
+    const confirmedInfo = {
+        ...ctx,
+        hash,
+        receipt,
+        ...(block ? { block } : {}),
+    };
+    hooks?.onConfirmed?.(confirmedInfo);
+    hooks?.onPhase?.({ phase: 'confirmed', ...confirmedInfo });
     return receipt;
 }
 //# sourceMappingURL=receipt.js.map

package/dist/receipt.js.map

@@ -1 +1 @@
-{"version":3,"file":"receipt.js","sourceRoot":"","sources":["../src/receipt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH;;;;;;;;GAQG;AACH,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IAM9C,YAAY,IAAS,EAAE,OAA2B;QAChD,KAAK,CAAC,gCAAgC,CAAC,CAAA;QACvC,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAA;QACnC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;IACxB,CAAC;CACF;AAoBD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,OAAqC;IAErC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,OAAO,CAAA;IAE7C,IAAI,OAA2B,CAAA;IAC/B,IAAI,CAAC;QACH,OAAO,GAAG,MAAM,YAAY,CAAC,yBAAyB,CAAC,EAAE,IAAI,EAAE,CAAC,CAAA;IAClE,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAA;QACnE,KAAK,EAAE,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAA;QAC1B,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAA;QAC3D,MAAM,OAAO,CAAA;IACf,CAAC;IAED,IAAI,OAAO,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;QAClC,MAAM,MAAM,GAAG,IAAI,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;QACvD,KAAK,EAAE,QAAQ,EAAE,CAAC,MAAM,CAAC,CAAA;QACzB,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAA;QACnE,MAAM,MAAM,CAAA;IACd,CAAC;IAED,KAAK,EAAE,WAAW,EAAE,CAAC,OAAO,CAAC,CAAA;IAC7B,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAA;IACvD,OAAO,OAAO,CAAA;AAChB,CAAC"}
+{"version":3,"file":"receipt.js","sourceRoot":"","sources":["../src/receipt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAMH;;;;;;;;GAQG;AACH,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IAM9C,YAAY,IAAS,EAAE,OAA2B;QAChD,KAAK,CAAC,gCAAgC,CAAC,CAAA;QACvC,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAA;QACnC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;IACxB,CAAC;CACF;AAwCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,OAAqC;IAErC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,GAAG,IAAI,EAAE,KAAK,EAAE,GAAG,OAAO,CAAA;IAC3E,MAAM,GAAG,GAAc,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,CAAA;IAE5D,IAAI,OAA2B,CAAA;IAC/B,IAAI,CAAC;QACH,OAAO,GAAG,MAAM,YAAY,CAAC,yBAAyB,CAAC,EAAE,IAAI,EAAE,CAAC,CAAA;IAClE,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAA;QACnE,MAAM,UAAU,GAAyC,EAAE,GAAG,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,CAAA;QACnF,KAAK,EAAE,QAAQ,EAAE,CAAC,UAAU,CAAC,CAAA;QAC7B,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,UAAU,EAAE,CAAC,CAAA;QACpD,MAAM,OAAO,CAAA;IACf,CAAC;IAED,MAAM,KAAK,GAAG,YAAY;QACxB,CAAC,CAAC,MAAM,YAAY,CAAC,QAAQ,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,CAAC;QAC/D,CAAC,CAAC,SAAS,CAAA;IAEb,IAAI,OAAO,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;QAClC,MAAM,MAAM,GAAG,IAAI,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;QACvD,MAAM,UAAU,GAAyC;YACvD,GAAG,GAAG;YACN,KAAK,EAAE,MAAM;YACb,IAAI;YACJ,OAAO;YACP,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAC5B,CAAA;QACD,KAAK,EAAE,QAAQ,EAAE,CAAC,UAAU,CAAC,CAAA;QAC7B,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,UAAU,EAAE,CAAC,CAAA;QACpD,MAAM,MAAM,CAAA;IACd,CAAC;IAED,MAAM,aAAa,GAA4C;QAC7D,GAAG,GAAG;QACN,IAAI;QACJ,OAAO;QACP,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC5B,CAAA;IACD,KAAK,EAAE,WAAW,EAAE,CAAC,aAAa,CAAC,CAAA;IACnC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,GAAG,aAAa,EAAE,CAAC,CAAA;IAC1D,OAAO,OAAO,CAAA;AAChB,CAAC"}

package/dist/send.d.ts

@@ -5,13 +5,14 @@
  * This is the runtime piece of the lifecycle contract. SDK authors call
  * this from inside any write method that opens a wallet popup; it
  * guarantees:
- *   - `onAwaitingSignature` fires exactly once, immediately before
- *     `wallet.sendTransaction(...)`.
+ *   - `onAwaitingSignature` fires exactly once with `TxContext` (chainId
+ *     + request), immediately before `wallet.sendTransaction(...)`.
  *   - `onTransactionHash` (per-call) and the global `onTransactionHash`
- *     channel fire exactly once each, after `sendTransaction` resolves
- *     and BEFORE the SDK awaits any receipt — so callers can flip their
- *     UI from `awaiting-signature` to `pending` the moment a hash exists
- *     instead of stalling for the full inclusion window.
+ *     channel fire exactly once each with `TxContext + hash`, after
+ *     `sendTransaction` resolves and BEFORE the SDK awaits any receipt
+ *     — so callers can flip their UI from `awaiting-signature` to
+ *     `pending` the moment a hash exists instead of stalling for the
+ *     full inclusion window.
  *   - Wallet rejections (EIP-1193 `code === 4001`, viem's
  *     `UserRejectedRequestError`, or matching message text — see
  *     `@valve-tech/viem-errors` for the detection signals) are converted
@@ -19,14 +20,13 @@
  *     them. Non-rejection errors are re-thrown unchanged so the SDK
  *     can map them to its own typed error vocabulary.
  *
- * Without this helper, every SDK that wants the contract has to
- * re-implement: the error-mapping `try/catch` block (with the
- * three-signal rejection check), the constructor-vs-per-call hook
- * fan-out, and the precise ordering relative to `sendTransaction`.
+ * Every payload carries `chainId` and the original `request`, so
+ * analytics observers and tx-tracker consumers don't need to keep a
+ * side-channel `hash → request` map or read chainId off the client.
  */
 import type { Hex } from 'viem';
 import type { WalletAdapter, WalletSendTransactionRequest } from './wallet.js';
-import type { WriteHookParams } from './hooks.js';
+import type { TxContext, WriteHookParams, WritePhaseSteps } from './hooks.js';
 /**
  * Thrown by `sendTransactionWithHooks` when the wallet rejection is
  * detected at any level of the cause chain. The original error is
@@ -47,16 +47,16 @@ export interface SendTransactionWithHooksOptions {
     wallet: WalletAdapter;
     /** The fully-formed send request (calldata, gas inputs, chainId). */
     request: WalletSendTransactionRequest;
-    /** Per-call lifecycle hooks. Both fields are optional. */
+    /** Per-call lifecycle hooks. All fields are optional. */
     hooks?: WriteHookParams;
     /**
      * Optional global / constructor-level `onTransactionHash` channel.
      * Fires alongside `hooks.onTransactionHash` on the same line —
-     * complementary, not alternatives. Use this for analytics or
-     * debug-logging that should observe every write regardless of which
-     * caller fired it.
+     * complementary, not alternatives. Receives the same rich
+     * `TxContext + hash` payload so analytics observers don't have to
+     * resolve chainId / request from a side channel.
      */
-    onTransactionHash?: (hash: Hex) => void;
+    onTransactionHash?: (info: TxContext<WritePhaseSteps['pending']>) => void;
 }
 /**
  * Submit a transaction through the wallet adapter, firing lifecycle
@@ -72,7 +72,12 @@ export interface SendTransactionWithHooksOptions {
  *     hooks: params,                     // user-supplied per-call hooks
  *     onTransactionHash: this.onHash,    // constructor-level / analytics
  *   })
- *   const receipt = await this.publicClient.waitForTransactionReceipt({ hash })
+ *   const receipt = await awaitReceiptWithHooks({
+ *     publicClient,
+ *     hash,
+ *     request: { ...prepared, ...gasInputs },
+ *     hooks: params,
+ *   })
  *   return { hash, receipt }
  * } catch (err) {
  *   if (err instanceof WalletRejectedError) {

package/dist/send.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../src/send.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAE/B,OAAO,KAAK,EAAE,aAAa,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAA;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD;;;;;;GAMG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;gBAET,KAAK,EAAE,KAAK;CAKzB;AAED;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC9C,iEAAiE;IACjE,MAAM,EAAE,aAAa,CAAA;IACrB,qEAAqE;IACrE,OAAO,EAAE,4BAA4B,CAAA;IACrC,0DAA0D;IAC1D,KAAK,CAAC,EAAE,eAAe,CAAA;IACvB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;CACxC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,GAAG,CAAC,CAuBd"}
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../src/send.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAE/B,OAAO,KAAK,EAAE,aAAa,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAA;AAC9E,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAE7E;;;;;;GAMG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;gBAET,KAAK,EAAE,KAAK;CAKzB;AAED;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC9C,iEAAiE;IACjE,MAAM,EAAE,aAAa,CAAA;IACrB,qEAAqE;IACrE,OAAO,EAAE,4BAA4B,CAAA;IACrC,yDAAyD;IACzD,KAAK,CAAC,EAAE,eAAe,CAAA;IACvB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,KAAK,IAAI,CAAA;CAC1E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,GAAG,CAAC,CA0Bd"}

package/dist/send.js

@@ -5,13 +5,14 @@
  * This is the runtime piece of the lifecycle contract. SDK authors call
  * this from inside any write method that opens a wallet popup; it
  * guarantees:
- *   - `onAwaitingSignature` fires exactly once, immediately before
- *     `wallet.sendTransaction(...)`.
+ *   - `onAwaitingSignature` fires exactly once with `TxContext` (chainId
+ *     + request), immediately before `wallet.sendTransaction(...)`.
  *   - `onTransactionHash` (per-call) and the global `onTransactionHash`
- *     channel fire exactly once each, after `sendTransaction` resolves
- *     and BEFORE the SDK awaits any receipt — so callers can flip their
- *     UI from `awaiting-signature` to `pending` the moment a hash exists
- *     instead of stalling for the full inclusion window.
+ *     channel fire exactly once each with `TxContext + hash`, after
+ *     `sendTransaction` resolves and BEFORE the SDK awaits any receipt
+ *     — so callers can flip their UI from `awaiting-signature` to
+ *     `pending` the moment a hash exists instead of stalling for the
+ *     full inclusion window.
  *   - Wallet rejections (EIP-1193 `code === 4001`, viem's
  *     `UserRejectedRequestError`, or matching message text — see
  *     `@valve-tech/viem-errors` for the detection signals) are converted
@@ -19,10 +20,9 @@
  *     them. Non-rejection errors are re-thrown unchanged so the SDK
  *     can map them to its own typed error vocabulary.
  *
- * Without this helper, every SDK that wants the contract has to
- * re-implement: the error-mapping `try/catch` block (with the
- * three-signal rejection check), the constructor-vs-per-call hook
- * fan-out, and the precise ordering relative to `sendTransaction`.
+ * Every payload carries `chainId` and the original `request`, so
+ * analytics observers and tx-tracker consumers don't need to keep a
+ * side-channel `hash → request` map or read chainId off the client.
  */
 import { isUserRejectionError } from '@valve-tech/viem-errors';
 /**
@@ -53,7 +53,12 @@ export class WalletRejectedError extends Error {
  *     hooks: params,                     // user-supplied per-call hooks
  *     onTransactionHash: this.onHash,    // constructor-level / analytics
  *   })
- *   const receipt = await this.publicClient.waitForTransactionReceipt({ hash })
+ *   const receipt = await awaitReceiptWithHooks({
+ *     publicClient,
+ *     hash,
+ *     request: { ...prepared, ...gasInputs },
+ *     hooks: params,
+ *   })
  *   return { hash, receipt }
  * } catch (err) {
  *   if (err instanceof WalletRejectedError) {
@@ -65,10 +70,11 @@ export class WalletRejectedError extends Error {
  */
 export async function sendTransactionWithHooks(options) {
     const { wallet, request, hooks, onTransactionHash } = options;
+    const ctx = { chainId: request.chainId, request };
     let hash;
     try {
-        hooks?.onAwaitingSignature?.();
-        hooks?.onPhase?.({ phase: 'awaiting-signature' });
+        hooks?.onAwaitingSignature?.(ctx);
+        hooks?.onPhase?.({ phase: 'awaiting-signature', ...ctx });
         hash = await wallet.sendTransaction(request);
     }
     catch (err) {
@@ -77,13 +83,15 @@ export async function sendTransactionWithHooks(options) {
             : err instanceof Error
                 ? err
                 : new Error(String(err));
-        hooks?.onFailed?.(failure);
-        hooks?.onPhase?.({ phase: 'failed', error: failure });
+        const failedInfo = { ...ctx, error: failure };
+        hooks?.onFailed?.(failedInfo);
+        hooks?.onPhase?.({ phase: 'failed', ...failedInfo });
         throw failure;
     }
-    onTransactionHash?.(hash);
-    hooks?.onTransactionHash?.(hash);
-    hooks?.onPhase?.({ phase: 'pending', hash });
+    const pendingInfo = { ...ctx, hash };
+    onTransactionHash?.(pendingInfo);
+    hooks?.onTransactionHash?.(pendingInfo);
+    hooks?.onPhase?.({ phase: 'pending', ...pendingInfo });
     return hash;
 }
 //# sourceMappingURL=send.js.map

package/dist/send.js.map

@@ -1 +1 @@
-{"version":3,"file":"send.js","sourceRoot":"","sources":["../src/send.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAI9D;;;;;;GAMG;AACH,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IAI5C,YAAY,KAAY;QACtB,KAAK,CAAC,qCAAqC,CAAC,CAAA;QAC5C,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAA;QACjC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;IACpB,CAAC;CACF;AAsBD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,OAAwC;IAExC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAAA;IAE7D,IAAI,IAAS,CAAA;IACb,IAAI,CAAC;QACH,KAAK,EAAE,mBAAmB,EAAE,EAAE,CAAA;QAC9B,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,oBAAoB,EAAE,CAAC,CAAA;QACjD,IAAI,GAAG,MAAM,MAAM,CAAC,eAAe,CAAC,OAAO,CAAC,CAAA;IAC9C,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,OAAO,GAAG,oBAAoB,CAAC,GAAG,CAAC;YACvC,CAAC,CAAC,IAAI,mBAAmB,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YAC9E,CAAC,CAAC,GAAG,YAAY,KAAK;gBACpB,CAAC,CAAC,GAAG;gBACL,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAA;QAC5B,KAAK,EAAE,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAA;QAC1B,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAA;QACrD,MAAM,OAAO,CAAA;IACf,CAAC;IAED,iBAAiB,EAAE,CAAC,IAAI,CAAC,CAAA;IACzB,KAAK,EAAE,iBAAiB,EAAE,CAAC,IAAI,CAAC,CAAA;IAChC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;IAC5C,OAAO,IAAI,CAAA;AACb,CAAC"}
+{"version":3,"file":"send.js","sourceRoot":"","sources":["../src/send.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAI9D;;;;;;GAMG;AACH,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IAI5C,YAAY,KAAY;QACtB,KAAK,CAAC,qCAAqC,CAAC,CAAA;QAC5C,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAA;QACjC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;IACpB,CAAC;CACF;AAsBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,OAAwC;IAExC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAAA;IAC7D,MAAM,GAAG,GAAc,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,CAAA;IAE5D,IAAI,IAAS,CAAA;IACb,IAAI,CAAC;QACH,KAAK,EAAE,mBAAmB,EAAE,CAAC,GAAG,CAAC,CAAA;QACjC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,oBAAoB,EAAE,GAAG,GAAG,EAAE,CAAC,CAAA;QACzD,IAAI,GAAG,MAAM,MAAM,CAAC,eAAe,CAAC,OAAO,CAAC,CAAA;IAC9C,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,OAAO,GAAG,oBAAoB,CAAC,GAAG,CAAC;YACvC,CAAC,CAAC,IAAI,mBAAmB,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YAC9E,CAAC,CAAC,GAAG,YAAY,KAAK;gBACpB,CAAC,CAAC,GAAG;gBACL,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAA;QAC5B,MAAM,UAAU,GAAyC,EAAE,GAAG,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,CAAA;QACnF,KAAK,EAAE,QAAQ,EAAE,CAAC,UAAU,CAAC,CAAA;QAC7B,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,UAAU,EAAE,CAAC,CAAA;QACpD,MAAM,OAAO,CAAA;IACf,CAAC;IAED,MAAM,WAAW,GAA0C,EAAE,GAAG,GAAG,EAAE,IAAI,EAAE,CAAA;IAC3E,iBAAiB,EAAE,CAAC,WAAW,CAAC,CAAA;IAChC,KAAK,EAAE,iBAAiB,EAAE,CAAC,WAAW,CAAC,CAAA;IACvC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,WAAW,EAAE,CAAC,CAAA;IACtD,OAAO,IAAI,CAAA;AACb,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valve-tech/wallet-adapter",
-  "version": "0.4.1",
-  "description": "Framework-agnostic vocabulary + runtime helpers for EVM dapp wallet integration. WalletAdapter interface (sign + send), WriteHookParams full lifecycle (onAwaitingSignature, onTransactionHash, onConfirmed, onFailed, onDropped, onReplaced) plus complementary onPhase(event) discriminated-union shape, sendTransactionWithHooks + awaitReceiptWithHooks helpers that fire the hooks at real boundaries, typed WalletRejectedError + ContractRevertedError for instanceof-discriminated catch, plus TX_STATUS / TX_FLOW / TrackedTx for tx-state UI. Lets SDKs and dapps share one contract instead of each redefining it. Part of the valve-tech/evm-toolkit synchronized release line.",
+  "version": "0.5.0",
+  "description": "Framework-agnostic vocabulary + runtime helpers for EVM dapp wallet integration. WalletAdapter interface (sign + send), WriteHookParams full lifecycle with rich TxContext payloads (chainId + original request) on every event so consumers don't side-channel; six named hooks (onAwaitingSignature, onTransactionHash, onConfirmed, onFailed, onDropped, onReplaced) plus complementary onPhase(event) discriminated-union shape derived from the WritePhaseSteps phase-map; sendTransactionWithHooks + awaitReceiptWithHooks helpers that fire the hooks at real boundaries (with awaitReceiptWithHooks fetching the containing block once on behalf of all downstream consumers); typed WalletRejectedError + ContractRevertedError for instanceof-discriminated catch; plus TX_STATUS / TX_FLOW / TrackedTx for tx-state UI. Lets SDKs and dapps share one contract instead of each redefining it. Part of the valve-tech/evm-toolkit synchronized release line.",
   "license": "MIT",
   "homepage": "https://github.com/valve-tech/evm-toolkit/tree/main/packages/wallet-adapter#readme",
   "repository": {
@@ -46,7 +46,7 @@
     "prepare": "yarn build"
   },
   "dependencies": {
-    "@valve-tech/viem-errors": "^0.4.1"
+    "@valve-tech/viem-errors": "^0.5.0"
   },
   "peerDependencies": {
     "viem": "^2.0.0"