@valve-tech/wallet-adapter 0.3.1

package/CHANGELOG.md

@@ -0,0 +1,55 @@
+# Changelog
+
+All notable changes to `@valve-tech/wallet-adapter` are documented in
+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/).
+
+## [Unreleased]
+
+### Added
+
+- Initial implementation. Vocabulary lifted from a real-world dapp
+  (Provex) where SDK / UI / tx-tracker each redefined the same shapes
+  separately; this is the first upstream packaging.
+  - `WalletAdapter` interface plus `WalletSendTransactionRequest` and
+    `WalletReadContractRequest` request shapes.
+  - `WriteHookParams` — full lifecycle contract. Six named callbacks
+    (`onAwaitingSignature`, `onTransactionHash`, `onConfirmed`,
+    `onFailed`, `onDropped`, `onReplaced`) plus a complementary
+    single-callback `onPhase(event)` shape with a discriminated-union
+    payload. Fire-ers fire BOTH shapes for every transition.
+  - `WritePhase` (`'preparing' | 'awaiting-signature' | 'pending' |
+    'confirmed' | 'failed' | 'dropped' | 'replaced'`) and
+    `WritePhaseEvent` discriminated union for `onPhase` consumers.
+  - `TX_STATUS` lifecycle const, `TrackedTxStatus` type, `TrackedTx`
+    shape, `TrackedTxGas`, `TxConfirmedCallback`.
+  - `TX_FLOW` extension point (ships empty), `TxFlow = string`.
+  - `STALE_TX_AGE_MS` / `CONFIRMED_DISPLAY_MS` / `FAILED_DISPLAY_MS`
+    display-window defaults.
+- Unit tests covering the runtime constants and type-level shape
+  guarantees (status-value uniqueness, phase literal union, hook
+  parameter typing, `TrackedTx` pre-hash and post-hash construction).
+- `sendTransactionWithHooks(options)` — wallet-side runtime helper.
+  Fires `onAwaitingSignature` + `onPhase('awaiting-signature')`
+  immediately before `sendTransaction`; fires per-call + global
+  `onTransactionHash` and `onPhase('pending', { hash })` after the
+  wallet returns; fires `onFailed` + `onPhase('failed', ...)` on any
+  thrown error before re-throwing.
+- `awaitReceiptWithHooks(options)` — chain-side runtime helper.
+  Awaits `waitForTransactionReceipt`; fires `onConfirmed` +
+  `onPhase('confirmed', { hash, receipt })` on success; fires
+  `onFailed` with a `ContractRevertedError` + `onPhase('failed', ...)`
+  on `status: reverted`; fires `onFailed` with the original error +
+  `onPhase('failed', ...)` on any other receipt-await failure.
+- `WalletRejectedError` — `Error` subclass thrown by
+  `sendTransactionWithHooks` on user rejection; preserves the original
+  error as `cause`.
+- `ContractRevertedError` — `Error` subclass thrown by
+  `awaitReceiptWithHooks` on `status: reverted`; carries the `hash`
+  and full `receipt` so consumers can extract revert reasons / log
+  data without re-fetching.
+- Runtime dependency on `@valve-tech/viem-errors` for the
+  three-signal rejection detection (EIP-1193 `code === 4001`, viem
+  class name, message regex — anywhere in the cause chain).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Valve Tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,234 @@
+# `@valve-tech/wallet-adapter`
+
+Framework-agnostic vocabulary for EVM dapp wallet integration. Pure
+types + a few `as const` lifecycle constants — no runtime
+implementation, no opinion about which wallet library you use.
+
+Five concerns under one package so SDK authors, UI authors, and apps
+all agree on the same surface:
+
+1. **`WalletAdapter`** — the contract an SDK accepts in lieu of
+   coupling to wagmi / ethers / viem direct / a smart account.
+2. **`WriteHookParams`** — every phase a tracked tx can be in. Six
+   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.
+3. **`sendTransactionWithHooks(options)`** — wallet-side helper. Fires
+   the pre-wallet (`onAwaitingSignature`, `onPhase('awaiting-signature')`)
+   and post-hash (`onTransactionHash`, `onPhase('pending', { hash })`)
+   transitions. Converts wallet rejections to a typed
+   `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.
+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.
+
+The two helpers split by concern: the wallet side and the chain side.
+SDKs chain them with whatever protocol-specific work goes in the
+middle (gating-service signatures, log decoding, indexer sync). The
+only runtime dependency is `@valve-tech/viem-errors` for the
+rejection-detection check; viem is a peer dependency for the `Hex`
+and `TransactionReceipt` types.
+
+**`onDropped` and `onReplaced` are part of the contract; the helpers
+in this package don't fire them.** Honestly distinguishing "still
+propagating" from "permanently dropped" requires observing the tx
+across many blocks with a configurable timeout policy, and detecting
+replacement requires nonce-watching across the same nonce — that's
+`@valve-tech/tx-tracker`'s job (per-tx state machine). The contract
+defines the hooks here so consumers wire one set of callbacks; the
+tracker fires them when it ships. Wiring `onDropped` / `onReplaced`
+against `awaitReceiptWithHooks` is harmless but they will not fire
+from this package.
+
+## Why
+
+Every SDK invents its own wallet shape; every dapp invents its own
+"awaiting signature" state machine; every UI invents its own list of
+status names. The result is a small ecosystem where the same word
+means slightly different things at every boundary, and dapps end up
+writing translation glue between them.
+
+This package is the shared vocabulary. Use `WalletAdapter` so a single
+wagmi/ethers/smart-account adapter works across every SDK. Use
+`WriteHookParams` so the UI sees consistent transitions across every
+SDK write. Use `TX_STATUS` so the in-flight strip and the receipt-poll
+agree on what `'pending'` means.
+
+## Install
+
+```sh
+npm install @valve-tech/wallet-adapter viem
+# or
+yarn add @valve-tech/wallet-adapter viem
+```
+
+## Quick start
+
+### Defining an SDK that accepts any wallet
+
+```ts
+import {
+  sendTransactionWithHooks,
+  awaitReceiptWithHooks,
+  WalletRejectedError,
+  ContractRevertedError,
+  type WalletAdapter,
+  type WriteHookParams,
+} from '@valve-tech/wallet-adapter'
+
+export interface MyWriteParams { depositId: bigint; amount: bigint }
+
+export class MyClient {
+  constructor(
+    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,
+  ) {}
+
+  async deposit(params: MyWriteParams & WriteHookParams) {
+    try {
+      const hash = await sendTransactionWithHooks({
+        wallet: this.wallet,
+        request: {
+          to: this.escrow,
+          data: this.encodeDeposit(params),
+          chainId: this.chainId,
+        },
+        hooks: params,
+        onTransactionHash: this.onTransactionHash,
+      })
+      const receipt = await awaitReceiptWithHooks({
+        publicClient: this.publicClient,
+        hash,
+        hooks: params,
+      })
+      // protocol-specific work here (decode logs, etc.) — onConfirmed already fired
+      return { hash, receipt }
+    } catch (err) {
+      if (err instanceof WalletRejectedError) {
+        throw new MySdkError('WALLET_REJECTED', err.message, err.cause)
+      }
+      if (err instanceof ContractRevertedError) {
+        throw new MySdkError('TX_REVERTED', err.message, err)
+      }
+      throw new MySdkError('CONTRACT_ERROR', (err as Error).message, err as Error)
+    }
+  }
+}
+```
+
+`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.
+- 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.
+
+`awaitReceiptWithHooks` guarantees:
+
+- On `receipt.status === 'success'`: fires `onConfirmed(receipt)` 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 any thrown error during the receipt-await (network / RPC /
+  abort): fires `onFailed` with the original error and re-throws
+  unchanged.
+
+A `WriteHookParams` consumer (toast strip, inline indicator, etc.)
+that wires all four hooks can drive its full state machine — pre-wallet
+"preparing", post-wallet "pending", terminal "confirmed" or "failed" —
+purely from the contract, without any SDK-specific glue.
+
+### A tx-flight UI built on `TX_STATUS`
+
+```ts
+import { TX_STATUS, type TrackedTx } from '@valve-tech/wallet-adapter'
+
+function subtitle(tx: TrackedTx): string {
+  switch (tx.status) {
+    case TX_STATUS.preparing:         return 'preparing transaction'
+    case TX_STATUS.awaitingSignature: return 'awaiting wallet signature'
+    case TX_STATUS.pending:           return 'waiting for inclusion'
+    case TX_STATUS.mined:             return 'confirmed on-chain'
+    case TX_STATUS.failed:            return tx.notes ?? 'transaction failed'
+    case TX_STATUS.dropped:           return 'dropped from mempool'
+    case TX_STATUS.replaced:          return 'replaced by speed-up'
+  }
+}
+```
+
+## Exports
+
+| Export | Kind | Shape |
+| --- | --- | --- |
+| `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)` |
+| `WritePhase` | type | `'preparing' \| 'awaiting-signature' \| 'pending' \| 'confirmed' \| 'failed' \| 'dropped' \| 'replaced'` |
+| `WritePhaseEvent` | type | discriminated union of phase + payload |
+| `sendTransactionWithHooks(opts)` | function | `{ wallet, request, hooks?, onTransactionHash? } → Promise<Hex>`. Wallet-side helper. |
+| `awaitReceiptWithHooks(opts)` | function | `{ publicClient, hash, hooks? } → Promise<TransactionReceipt>`. Chain-side helper. |
+| `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 |
+| `TX_STATUS` | const | lifecycle states |
+| `TX_FLOW` | const | empty by design — protocols extend |
+| `TrackedTx` | type | `{ id, hash?, chainId, flow, submittedAt, ... status, notes? }` |
+| `STALE_TX_AGE_MS` / `CONFIRMED_DISPLAY_MS` / `FAILED_DISPLAY_MS` | const | window defaults |
+
+## Design notes
+
+- **One hook contract, two complementary shapes.** `WriteHookParams`
+  describes every phase a tracked tx can be in. Six named callbacks
+  cover the common transitions; `onPhase(event)` provides the same
+  information as a discriminated-union single-callback shape for
+  state-machine consumers. Fire-ers fire BOTH shapes for every
+  transition — exactly once each. Wiring named hooks doesn't preclude
+  `onPhase` and vice versa.
+- **`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
+  `WalletRejectedError` / `ContractRevertedError` discriminates the
+  source. Distinct from `onDropped` (no inclusion observed) and
+  `onReplaced` (different tx mined for the same nonce) — those are
+  their own terminal states with their own typed payloads.
+- **`onDropped` and `onReplaced` are part of the contract; this
+  package's helpers don't fire them.** Detecting drop vs replacement
+  requires multi-block observation with nonce-watching — that's
+  `@valve-tech/tx-tracker`'s job. The hooks live in `WriteHookParams`
+  so consumers wire one set of callbacks; the tracker fires them when
+  it ships.
+- **`TX_FLOW` is intentionally empty.** Every protocol's flow names
+  (`fulfillIntent`, `addFunds`, `mintNFT`, etc.) are its own concern.
+  Extend the `TxFlow` type via your own union.
+- **Pre-hash states are first-class.** `preparing` and
+  `awaiting-signature` carry no `hash` — they exist so the UI has
+  something to show during the wallet-sign window.
+- **`id` is stable, `hash` is not.** Registries assign `id` at
+  `beginTx` time and attach `hash` later. This lets pre-hash UI render
+  before the wallet returns.
+
+## License
+
+MIT

package/dist/hooks.d.ts

@@ -0,0 +1,157 @@
+/**
+ * @fileoverview Per-call lifecycle hooks for any SDK method that opens a
+ * wallet popup, awaits inclusion, and may later observe replacement or
+ * mempool drop.
+ *
+ * The contract describes EVERY phase a tracked tx can be in. Different
+ * fire-ers cover different slices:
+ *
+ *   - `sendTransactionWithHooks` fires the wallet-side phases
+ *     (`awaiting-signature`, `pending`, plus `failed` on rejection /
+ *     wallet-side network error).
+ *   - `awaitReceiptWithHooks` fires the chain-side terminal phases
+ *     (`confirmed` or `failed` on revert / receipt-await error).
+ *   - `@valve-tech/tx-tracker` (per-tx state machine, observes across
+ *     blocks) fires `dropped` and `replaced` once it ships, plus may
+ *     re-emit transitions if a tx surfaces / vanishes / surfaces again
+ *     across reorgs.
+ *   - The SDK itself may fire `preparing` at the very start of its
+ *     write method, before any pre-wallet work begins.
+ *
+ * Two shapes are available — complementary, not alternatives:
+ *
+ *   - **Named hooks** (`onAwaitingSignature`, `onConfirmed`, etc.) —
+ *     ergonomic, easy to wire from a hook-like API, narrow types per
+ *     callback.
+ *   - **`onPhase(event)`** — single-callback discriminated union.
+ *     Better for state-machine consumers that need a single transition
+ *     point and exhaustive `switch`-coverage on the phase name.
+ *
+ * Fire-ers fire BOTH shapes for every transition — exactly once each —
+ * so consumers can choose which to wire without affecting the other.
+ */
+import type { Hex, TransactionReceipt } from 'viem';
+/**
+ * Every lifecycle phase a tracked transaction can be in, from intent
+ * through terminal observation. Carriers (helpers, trackers, SDKs)
+ * fire transitions in roughly this order, though `dropped` and
+ * `replaced` may arrive late or interleave with re-emissions on reorg.
+ */
+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.
+ */
+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;
+};
+/**
+ * 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.
+ */
+export interface WriteHookParams {
+    /**
+     * Called once, immediately before `wallet.sendTransaction`. UI flips
+     * from "preparing" to "awaiting wallet signature" at the precise
+     * boundary, regardless of how much pre-wallet work the SDK did.
+     */
+    onAwaitingSignature?: () => 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.
+     *
+     * 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.
+     */
+    onTransactionHash?: (hash: Hex) => 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.
+     */
+    onConfirmed?: (receipt: TransactionReceipt) => void;
+    /**
+     * Called once with the underlying error 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`.
+     */
+    onFailed?: (error: Error) => void;
+    /**
+     * Called once when a tracker has determined the tx will not be
+     * included — typically: not seen in mempool for N consecutive blocks
+     * AND no receipt arrived AND no replacement nonce mined. The exact
+     * timeout policy is the tracker's call (configurable per consumer).
+     *
+     * Helpers in THIS package never fire `onDropped` — distinguishing
+     * "still propagating" from "permanently dropped" requires multi-block
+     * observation. Wire this against a `tx-tracker` instance, not against
+     * `awaitReceiptWithHooks`.
+     */
+    onDropped?: (info: {
+        hash: Hex;
+    }) => 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.
+     */
+    onReplaced?: (info: {
+        original: Hex;
+        replacement: Hex;
+        receipt?: TransactionReceipt;
+    }) => void;
+    /**
+     * Single-callback complement to the named hooks. Fires for every
+     * lifecycle transition with a discriminated-union payload. Useful
+     * for state-machine consumers that prefer one transition point and
+     * exhaustive `switch`-coverage over wiring six separate callbacks.
+     *
+     * Fire-ers fire BOTH `onPhase` and the matching named hook on each
+     * transition — exactly once each — so wiring one shape doesn't
+     * preclude the other.
+     */
+    onPhase?: (event: WritePhaseEvent) => void;
+}
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -0,0 +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"}

package/dist/hooks.js

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview Per-call lifecycle hooks for any SDK method that opens a
+ * wallet popup, awaits inclusion, and may later observe replacement or
+ * mempool drop.
+ *
+ * The contract describes EVERY phase a tracked tx can be in. Different
+ * fire-ers cover different slices:
+ *
+ *   - `sendTransactionWithHooks` fires the wallet-side phases
+ *     (`awaiting-signature`, `pending`, plus `failed` on rejection /
+ *     wallet-side network error).
+ *   - `awaitReceiptWithHooks` fires the chain-side terminal phases
+ *     (`confirmed` or `failed` on revert / receipt-await error).
+ *   - `@valve-tech/tx-tracker` (per-tx state machine, observes across
+ *     blocks) fires `dropped` and `replaced` once it ships, plus may
+ *     re-emit transitions if a tx surfaces / vanishes / surfaces again
+ *     across reorgs.
+ *   - The SDK itself may fire `preparing` at the very start of its
+ *     write method, before any pre-wallet work begins.
+ *
+ * Two shapes are available — complementary, not alternatives:
+ *
+ *   - **Named hooks** (`onAwaitingSignature`, `onConfirmed`, etc.) —
+ *     ergonomic, easy to wire from a hook-like API, narrow types per
+ *     callback.
+ *   - **`onPhase(event)`** — single-callback discriminated union.
+ *     Better for state-machine consumers that need a single transition
+ *     point and exhaustive `switch`-coverage on the phase name.
+ *
+ * Fire-ers fire BOTH shapes for every transition — exactly once each —
+ * so consumers can choose which to wire without affecting the other.
+ */
+export {};
+//# sourceMappingURL=hooks.js.map

package/dist/hooks.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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 { 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';
+export { awaitReceiptWithHooks, ContractRevertedError, type AwaitReceiptWithHooksOptions, type ReceiptAwaiter, } from './receipt.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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"}

package/dist/index.js

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Public API of `@valve-tech/wallet-adapter`.
+ */
+export { TX_STATUS, TX_FLOW, STALE_TX_AGE_MS, CONFIRMED_DISPLAY_MS, FAILED_DISPLAY_MS, } from './tx-status.js';
+export { sendTransactionWithHooks, WalletRejectedError, } from './send.js';
+export { awaitReceiptWithHooks, ContractRevertedError, } from './receipt.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +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"}

package/dist/receipt.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @fileoverview The chain-side complement of `sendTransactionWithHooks`.
+ *
+ * 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
+ *      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.
+ *
+ * Drop detection (tx vanished from mempool without inclusion) and
+ * replacement detection are deliberately NOT in this helper. They
+ * require observing the tx across many blocks with a configurable
+ * timeout policy and nonce-watching — that's
+ * `@valve-tech/tx-tracker`'s job. The `WriteHookParams` contract
+ * defines `onDropped` / `onReplaced` so consumers can wire them once;
+ * this helper just doesn't fire them.
+ */
+import type { Hex, TransactionReceipt } from 'viem';
+import type { WriteHookParams } from './hooks.js';
+/**
+ * Thrown by `awaitReceiptWithHooks` when the receipt arrives with
+ * `status === 'reverted'`. The full receipt is preserved so consumers
+ * can extract revert reasons from logs, gas usage, etc.
+ *
+ * Distinct from a thrown error during the receipt-await itself
+ * (network / RPC issues, timeouts) — those are re-thrown unchanged so
+ * the SDK can map them to its own error vocabulary.
+ */
+export declare class ContractRevertedError extends Error {
+    /** The hash of the reverted transaction. */
+    readonly hash: Hex;
+    /** The full receipt with `status === 'reverted'`. */
+    readonly receipt: TransactionReceipt;
+    constructor(hash: Hex, receipt: TransactionReceipt);
+}
+/**
+ * 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.
+ */
+export interface ReceiptAwaiter {
+    waitForTransactionReceipt(args: {
+        hash: Hex;
+    }): Promise<TransactionReceipt>;
+}
+export interface AwaitReceiptWithHooksOptions {
+    /** A viem `PublicClient` (or anything with the same `waitForTransactionReceipt` 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. */
+    hooks?: WriteHookParams;
+}
+/**
+ * Await a transaction receipt and fire the post-hash lifecycle hooks.
+ * 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.
+ * ```
+ */
+export declare function awaitReceiptWithHooks(options: AwaitReceiptWithHooksOptions): Promise<TransactionReceipt>;
+//# sourceMappingURL=receipt.d.ts.map

package/dist/receipt.d.ts.map

@@ -0,0 +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"}

package/dist/receipt.js

@@ -0,0 +1,74 @@
+/**
+ * @fileoverview The chain-side complement of `sendTransactionWithHooks`.
+ *
+ * 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
+ *      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.
+ *
+ * Drop detection (tx vanished from mempool without inclusion) and
+ * replacement detection are deliberately NOT in this helper. They
+ * require observing the tx across many blocks with a configurable
+ * timeout policy and nonce-watching — that's
+ * `@valve-tech/tx-tracker`'s job. The `WriteHookParams` contract
+ * defines `onDropped` / `onReplaced` so consumers can wire them once;
+ * this helper just doesn't fire them.
+ */
+/**
+ * Thrown by `awaitReceiptWithHooks` when the receipt arrives with
+ * `status === 'reverted'`. The full receipt is preserved so consumers
+ * can extract revert reasons from logs, gas usage, etc.
+ *
+ * Distinct from a thrown error during the receipt-await itself
+ * (network / RPC issues, timeouts) — those are re-thrown unchanged so
+ * the SDK can map them to its own error vocabulary.
+ */
+export class ContractRevertedError extends Error {
+    constructor(hash, receipt) {
+        super('Transaction reverted on-chain.');
+        this.name = 'ContractRevertedError';
+        this.hash = hash;
+        this.receipt = receipt;
+    }
+}
+/**
+ * Await a transaction receipt and fire the post-hash lifecycle hooks.
+ * 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.
+ * ```
+ */
+export async function awaitReceiptWithHooks(options) {
+    const { publicClient, hash, hooks } = options;
+    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 });
+        throw failure;
+    }
+    if (receipt.status === 'reverted') {
+        const revert = new ContractRevertedError(hash, receipt);
+        hooks?.onFailed?.(revert);
+        hooks?.onPhase?.({ phase: 'failed', error: revert, hash, receipt });
+        throw revert;
+    }
+    hooks?.onConfirmed?.(receipt);
+    hooks?.onPhase?.({ phase: 'confirmed', hash, receipt });
+    return receipt;
+}
+//# sourceMappingURL=receipt.js.map

package/dist/receipt.js.map

@@ -0,0 +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"}

package/dist/send.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @fileoverview The single SDK helper for sending a transaction with
+ * lifecycle hooks fired at the real boundaries.
+ *
+ * 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(...)`.
+ *   - `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.
+ *   - Wallet rejections (EIP-1193 `code === 4001`, viem's
+ *     `UserRejectedRequestError`, or matching message text — see
+ *     `@valve-tech/viem-errors` for the detection signals) are converted
+ *     to a `WalletRejectedError` so consumers can `instanceof`-check
+ *     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`.
+ */
+import type { Hex } from 'viem';
+import type { WalletAdapter, WalletSendTransactionRequest } from './wallet.js';
+import type { WriteHookParams } from './hooks.js';
+/**
+ * Thrown by `sendTransactionWithHooks` when the wallet rejection is
+ * detected at any level of the cause chain. The original error is
+ * preserved as `cause` so consumers can still inspect it (locale
+ * details, exact wallet phrasing, etc.) when they map this to their
+ * own typed error vocabulary.
+ */
+export declare class WalletRejectedError extends Error {
+    /** The original rejection thrown by the wallet adapter. */
+    readonly cause: Error;
+    constructor(cause: Error);
+}
+/**
+ * Options accepted by `sendTransactionWithHooks`.
+ */
+export interface SendTransactionWithHooksOptions {
+    /** The wallet adapter that will sign + broadcast the request. */
+    wallet: WalletAdapter;
+    /** The fully-formed send request (calldata, gas inputs, chainId). */
+    request: WalletSendTransactionRequest;
+    /** Per-call lifecycle hooks. Both 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.
+     */
+    onTransactionHash?: (hash: Hex) => void;
+}
+/**
+ * Submit a transaction through the wallet adapter, firing lifecycle
+ * hooks at the real boundaries and converting wallet rejections to a
+ * typed `WalletRejectedError`.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   const hash = await sendTransactionWithHooks({
+ *     wallet: this.wallet,
+ *     request: { ...prepared, ...gasInputs },
+ *     hooks: params,                     // user-supplied per-call hooks
+ *     onTransactionHash: this.onHash,    // constructor-level / analytics
+ *   })
+ *   const receipt = await this.publicClient.waitForTransactionReceipt({ hash })
+ *   return { hash, receipt }
+ * } catch (err) {
+ *   if (err instanceof WalletRejectedError) {
+ *     throw new MySdkError('WALLET_REJECTED', err.message, err.cause)
+ *   }
+ *   throw new MySdkError('CONTRACT_ERROR', (err as Error).message, err as Error)
+ * }
+ * ```
+ */
+export declare function sendTransactionWithHooks(options: SendTransactionWithHooksOptions): Promise<Hex>;
+//# sourceMappingURL=send.d.ts.map

package/dist/send.d.ts.map

@@ -0,0 +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"}

package/dist/send.js

@@ -0,0 +1,89 @@
+/**
+ * @fileoverview The single SDK helper for sending a transaction with
+ * lifecycle hooks fired at the real boundaries.
+ *
+ * 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(...)`.
+ *   - `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.
+ *   - Wallet rejections (EIP-1193 `code === 4001`, viem's
+ *     `UserRejectedRequestError`, or matching message text — see
+ *     `@valve-tech/viem-errors` for the detection signals) are converted
+ *     to a `WalletRejectedError` so consumers can `instanceof`-check
+ *     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`.
+ */
+import { isUserRejectionError } from '@valve-tech/viem-errors';
+/**
+ * Thrown by `sendTransactionWithHooks` when the wallet rejection is
+ * detected at any level of the cause chain. The original error is
+ * preserved as `cause` so consumers can still inspect it (locale
+ * details, exact wallet phrasing, etc.) when they map this to their
+ * own typed error vocabulary.
+ */
+export class WalletRejectedError extends Error {
+    constructor(cause) {
+        super('Transaction was rejected in wallet.');
+        this.name = 'WalletRejectedError';
+        this.cause = cause;
+    }
+}
+/**
+ * Submit a transaction through the wallet adapter, firing lifecycle
+ * hooks at the real boundaries and converting wallet rejections to a
+ * typed `WalletRejectedError`.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   const hash = await sendTransactionWithHooks({
+ *     wallet: this.wallet,
+ *     request: { ...prepared, ...gasInputs },
+ *     hooks: params,                     // user-supplied per-call hooks
+ *     onTransactionHash: this.onHash,    // constructor-level / analytics
+ *   })
+ *   const receipt = await this.publicClient.waitForTransactionReceipt({ hash })
+ *   return { hash, receipt }
+ * } catch (err) {
+ *   if (err instanceof WalletRejectedError) {
+ *     throw new MySdkError('WALLET_REJECTED', err.message, err.cause)
+ *   }
+ *   throw new MySdkError('CONTRACT_ERROR', (err as Error).message, err as Error)
+ * }
+ * ```
+ */
+export async function sendTransactionWithHooks(options) {
+    const { wallet, request, hooks, onTransactionHash } = options;
+    let hash;
+    try {
+        hooks?.onAwaitingSignature?.();
+        hooks?.onPhase?.({ phase: 'awaiting-signature' });
+        hash = await wallet.sendTransaction(request);
+    }
+    catch (err) {
+        const failure = isUserRejectionError(err)
+            ? new WalletRejectedError(err instanceof Error ? err : new Error(String(err)))
+            : err instanceof Error
+                ? err
+                : new Error(String(err));
+        hooks?.onFailed?.(failure);
+        hooks?.onPhase?.({ phase: 'failed', error: failure });
+        throw failure;
+    }
+    onTransactionHash?.(hash);
+    hooks?.onTransactionHash?.(hash);
+    hooks?.onPhase?.({ phase: 'pending', hash });
+    return hash;
+}
+//# sourceMappingURL=send.js.map

package/dist/send.js.map

@@ -0,0 +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"}

package/dist/tx-status.d.ts

@@ -0,0 +1,113 @@
+/**
+ * @fileoverview Lifecycle vocabulary for tracked transactions.
+ *
+ * Defines the shared status / flow constants and the `TrackedTx` shape
+ * so any SDK or UI can speak the same vocabulary about a transaction
+ * in flight. This is the **opinion** layer that an in-flight UI sits on
+ * top of `@valve-tech/tx-tracker`'s neutral observations.
+ *
+ * Why constants instead of plain string types: consumers MUST reference
+ * via `TX_STATUS.preparing` / `TX_FLOW.signalIntent` rather than
+ * writing raw strings, so a rename here propagates through the type
+ * system instead of leaving stale literals at call sites.
+ */
+import type { Hex } from 'viem';
+/**
+ * Canonical lifecycle states for a tracked transaction.
+ *
+ * Lifecycle:
+ *   preparing → awaiting-signature → pending → confirmed | failed | dropped
+ *                                            ↘ replaced (on speed-up)
+ *
+ * The two pre-hash states (`preparing`, `awaitingSignature`) carry no
+ * `hash` and cannot be receipt-polled. They exist so the UI has
+ * something to show during gas-estimation + wallet-sign — without them
+ * the strip would stay blank until after the wallet returns.
+ *
+ * Naming: `confirmed` (not `mined`) matches the user-facing UI label
+ * and the `WritePhase` / `onConfirmed` hook surface. The receipt has
+ * arrived and the tx succeeded; consumers that need block-confirmation
+ * counts can layer that on top.
+ */
+export declare const TX_STATUS: {
+    readonly preparing: "preparing";
+    readonly awaitingSignature: "awaiting-signature";
+    readonly pending: "pending";
+    readonly confirmed: "confirmed";
+    readonly failed: "failed";
+    readonly replaced: "replaced";
+    readonly dropped: "dropped";
+};
+export type TrackedTxStatus = typeof TX_STATUS[keyof typeof TX_STATUS];
+/**
+ * The "what is the user doing" label for a tracked transaction. Distinct
+ * from `status` (which is the lifecycle phase): `flow` describes the
+ * action and stays constant for the whole lifecycle, while `status`
+ * advances over time.
+ *
+ * This is a generic / extensible enum — protocols add their own flow
+ * names by extending the type. The base set ships none of its own,
+ * intentionally: every protocol's flow vocabulary is its own.
+ */
+export declare const TX_FLOW: {};
+export type TxFlow = string;
+/**
+ * Gas the wallet actually sent the transaction with. Captured at submit
+ * time so a speed-up replacement can compute the EIP-1559 ≥10% bump
+ * relative to what's actually in the mempool, not what the oracle
+ * estimated when the user clicked.
+ */
+export interface TrackedTxGas {
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+}
+/**
+ * One in-flight (or recently-terminal) transaction the UI is showing.
+ *
+ * `id` is the stable identifier — assigned at the registry's `beginTx`
+ * time, before any hash exists. `hash` is attached later (when
+ * `wallet.sendTransaction` resolves). For post-hash callers using a
+ * legacy `trackTx({ hash, ... })` API, registries SHOULD default `id`
+ * to `hash` so existing code keeps working unchanged.
+ *
+ * `submittedTier` is a string so this type doesn't need to depend on
+ * `@valve-tech/gas-oracle`'s `TierName`. Consumers using the oracle
+ * can refine it locally.
+ */
+export interface TrackedTx {
+    id: string;
+    hash?: Hex;
+    chainId: number;
+    flow: TxFlow;
+    submittedAt: number;
+    confirmedAt?: number;
+    submittedGas?: TrackedTxGas;
+    submittedTier: string;
+    status: TrackedTxStatus;
+    replacedBy?: Hex;
+    replaces?: Hex;
+    /**
+     * Human-readable note for terminal-with-detail states. UIs SHOULD
+     * prefer `notes` over generic copy when rendering `failed` /
+     * `dropped` so a "cancelled in wallet" or decoded error name surfaces
+     * instead of a flat "transaction failed".
+     */
+    notes?: string;
+}
+/**
+ * How long a stale (older than this) tracked tx may be ignored by
+ * receipt-polling logic. Default mirrors the chosen UX in tx-flight
+ * surfaces: 10 minutes is long enough for a slow inclusion, short
+ * enough to garbage-collect zombie entries.
+ */
+export declare const STALE_TX_AGE_MS: number;
+/**
+ * Symmetric linger windows for terminal-with-detail states. These let
+ * confirmed/failed states stay on screen long enough for the user to
+ * read the outcome without permanently occupying the UI surface.
+ */
+export declare const CONFIRMED_DISPLAY_MS = 10000;
+export declare const FAILED_DISPLAY_MS = 10000;
+/** Fired once when a tracked tx becomes `mined`. */
+export type TxConfirmedCallback = (tx: TrackedTx) => void | Promise<void>;
+//# sourceMappingURL=tx-status.d.ts.map

package/dist/tx-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx-status.d.ts","sourceRoot":"","sources":["../src/tx-status.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAI/B;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,SAAS;;;;;;;;CAQZ,CAAA;AAEV,MAAM,MAAM,eAAe,GAAG,OAAO,SAAS,CAAC,MAAM,OAAO,SAAS,CAAC,CAAA;AAItE;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,IAAc,CAAA;AAElC,MAAM,MAAM,MAAM,GAAG,MAAM,CAAA;AAI3B;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,MAAM,CAAA;IACpB,oBAAoB,EAAE,MAAM,CAAA;CAC7B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,CAAC,EAAE,GAAG,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,aAAa,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,eAAe,CAAA;IACvB,UAAU,CAAC,EAAE,GAAG,CAAA;IAChB,QAAQ,CAAC,EAAE,GAAG,CAAA;IACd;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAID;;;;;GAKG;AACH,eAAO,MAAM,eAAe,QAAiB,CAAA;AAE7C;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAAS,CAAA;AAC1C,eAAO,MAAM,iBAAiB,QAAS,CAAA;AAIvC,oDAAoD;AACpD,MAAM,MAAM,mBAAmB,GAAG,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA"}

package/dist/tx-status.js

@@ -0,0 +1,68 @@
+/**
+ * @fileoverview Lifecycle vocabulary for tracked transactions.
+ *
+ * Defines the shared status / flow constants and the `TrackedTx` shape
+ * so any SDK or UI can speak the same vocabulary about a transaction
+ * in flight. This is the **opinion** layer that an in-flight UI sits on
+ * top of `@valve-tech/tx-tracker`'s neutral observations.
+ *
+ * Why constants instead of plain string types: consumers MUST reference
+ * via `TX_STATUS.preparing` / `TX_FLOW.signalIntent` rather than
+ * writing raw strings, so a rename here propagates through the type
+ * system instead of leaving stale literals at call sites.
+ */
+// ─── Status ────────────────────────────────────────────────────────────────
+/**
+ * Canonical lifecycle states for a tracked transaction.
+ *
+ * Lifecycle:
+ *   preparing → awaiting-signature → pending → confirmed | failed | dropped
+ *                                            ↘ replaced (on speed-up)
+ *
+ * The two pre-hash states (`preparing`, `awaitingSignature`) carry no
+ * `hash` and cannot be receipt-polled. They exist so the UI has
+ * something to show during gas-estimation + wallet-sign — without them
+ * the strip would stay blank until after the wallet returns.
+ *
+ * Naming: `confirmed` (not `mined`) matches the user-facing UI label
+ * and the `WritePhase` / `onConfirmed` hook surface. The receipt has
+ * arrived and the tx succeeded; consumers that need block-confirmation
+ * counts can layer that on top.
+ */
+export const TX_STATUS = {
+    preparing: 'preparing',
+    awaitingSignature: 'awaiting-signature',
+    pending: 'pending',
+    confirmed: 'confirmed',
+    failed: 'failed',
+    replaced: 'replaced',
+    dropped: 'dropped',
+};
+// ─── Flow ──────────────────────────────────────────────────────────────────
+/**
+ * The "what is the user doing" label for a tracked transaction. Distinct
+ * from `status` (which is the lifecycle phase): `flow` describes the
+ * action and stays constant for the whole lifecycle, while `status`
+ * advances over time.
+ *
+ * This is a generic / extensible enum — protocols add their own flow
+ * names by extending the type. The base set ships none of its own,
+ * intentionally: every protocol's flow vocabulary is its own.
+ */
+export const TX_FLOW = {};
+// ─── Display windows ───────────────────────────────────────────────────────
+/**
+ * How long a stale (older than this) tracked tx may be ignored by
+ * receipt-polling logic. Default mirrors the chosen UX in tx-flight
+ * surfaces: 10 minutes is long enough for a slow inclusion, short
+ * enough to garbage-collect zombie entries.
+ */
+export const STALE_TX_AGE_MS = 10 * 60 * 1000; // 10 minutes
+/**
+ * Symmetric linger windows for terminal-with-detail states. These let
+ * confirmed/failed states stay on screen long enough for the user to
+ * read the outcome without permanently occupying the UI surface.
+ */
+export const CONFIRMED_DISPLAY_MS = 10000;
+export const FAILED_DISPLAY_MS = 10000;
+//# sourceMappingURL=tx-status.js.map

package/dist/tx-status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx-status.js","sourceRoot":"","sources":["../src/tx-status.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,8EAA8E;AAE9E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,SAAS,EAAU,WAAW;IAC9B,iBAAiB,EAAE,oBAAoB;IACvC,OAAO,EAAY,SAAS;IAC5B,SAAS,EAAU,WAAW;IAC9B,MAAM,EAAa,QAAQ;IAC3B,QAAQ,EAAW,UAAU;IAC7B,OAAO,EAAY,SAAS;CACpB,CAAA;AAIV,8EAA8E;AAE9E;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,EAAW,CAAA;AAmDlC,8EAA8E;AAE9E;;;;;GAKG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAA,CAAC,aAAa;AAE3D;;;;GAIG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,KAAM,CAAA;AAC1C,MAAM,CAAC,MAAM,iBAAiB,GAAG,KAAM,CAAA"}

package/dist/wallet.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @fileoverview The framework-agnostic wallet contract.
+ *
+ * Decouples SDKs from any specific wallet library. A `WalletAdapter` is
+ * the only seam an SDK needs to sign and send a transaction; the dapp
+ * decides whether that backend is wagmi, ethers, viem direct, a smart
+ * account, a multisig, or a relayer.
+ */
+import type { Hex } from 'viem';
+/**
+ * The minimal request shape an SDK passes to a wallet for sign + send.
+ *
+ * Fields:
+ * - `to`        — destination address.
+ * - `data`      — encoded calldata (`0x...`).
+ * - `value`     — native-token amount in wei. Defaults to 0 if omitted.
+ * - `chainId`   — chain to sign for. Wallets MUST validate this against
+ *                 the connected chain and throw rather than silently
+ *                 sign for the wrong network.
+ * - `maxFeePerGas` / `maxPriorityFeePerGas` — EIP-1559 gas pricing in
+ *                 wei. Optional so a wallet can defer to its own gas
+ *                 logic; if both are present, the wallet should honour
+ *                 them.
+ */
+export interface WalletSendTransactionRequest {
+    to: Hex;
+    data: Hex;
+    value?: bigint;
+    chainId: number;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+}
+/**
+ * Optional read-from-contract escape hatch. Wallets that proxy reads
+ * (e.g. account abstraction with custom RPC) implement this; the SDK
+ * falls back to a public RPC when omitted.
+ */
+export interface WalletReadContractRequest {
+    address: Hex;
+    abi: readonly unknown[];
+    functionName: string;
+    args?: readonly unknown[];
+    chainId?: number;
+}
+/**
+ * Framework-agnostic wallet interface. Works with wagmi, viem direct,
+ * ethers, smart accounts, and relayers — anything that can sign and
+ * send a transaction.
+ *
+ * SDKs should accept a `WalletAdapter` rather than tying themselves to
+ * a specific wallet library, so the same SDK works across the whole
+ * downstream landscape without per-wallet code paths.
+ */
+export interface WalletAdapter {
+    /** Connected address, or undefined if disconnected. */
+    address?: Hex;
+    /** Sign and send a transaction. Returns the on-chain tx hash. */
+    sendTransaction(request: WalletSendTransactionRequest): Promise<Hex>;
+    /**
+     * Optional contract read. SDKs SHOULD prefer this when present (lets a
+     * smart-account / paymaster-aware wallet route reads through its own
+     * pipeline) and fall back to a public RPC client otherwise.
+     */
+    readContract?(request: WalletReadContractRequest): Promise<unknown>;
+}
+//# sourceMappingURL=wallet.d.ts.map

package/dist/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../src/wallet.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAE/B;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,4BAA4B;IAC3C,EAAE,EAAE,GAAG,CAAA;IACP,IAAI,EAAE,GAAG,CAAA;IACT,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,GAAG,CAAA;IACZ,GAAG,EAAE,SAAS,OAAO,EAAE,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,CAAA;IACzB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,uDAAuD;IACvD,OAAO,CAAC,EAAE,GAAG,CAAA;IACb,iEAAiE;IACjE,eAAe,CAAC,OAAO,EAAE,4BAA4B,GAAG,OAAO,CAAC,GAAG,CAAC,CAAA;IACpE;;;;OAIG;IACH,YAAY,CAAC,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CACpE"}

package/dist/wallet.js

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview The framework-agnostic wallet contract.
+ *
+ * Decouples SDKs from any specific wallet library. A `WalletAdapter` is
+ * the only seam an SDK needs to sign and send a transaction; the dapp
+ * decides whether that backend is wagmi, ethers, viem direct, a smart
+ * account, a multisig, or a relayer.
+ */
+export {};
+//# sourceMappingURL=wallet.js.map

package/dist/wallet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.js","sourceRoot":"","sources":["../src/wallet.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@valve-tech/wallet-adapter",
+  "version": "0.3.1",
+  "description": "Framework-agnostic vocabulary for EVM dapp wallet integration: WalletAdapter interface (sign + send), WriteHookParams lifecycle hooks (onAwaitingSignature, per-call onTransactionHash), and TX_STATUS / TX_FLOW / TrackedTx for tx-state UI. Pure types, no runtime dependencies. 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": {
+    "type": "git",
+    "url": "git+https://github.com/valve-tech/evm-toolkit.git",
+    "directory": "packages/wallet-adapter"
+  },
+  "bugs": {
+    "url": "https://github.com/valve-tech/evm-toolkit/issues"
+  },
+  "keywords": [
+    "ethereum",
+    "evm",
+    "viem",
+    "wagmi",
+    "wallet",
+    "wallet-adapter",
+    "tx-status",
+    "lifecycle-hooks"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p .",
+    "typecheck": "tsc -p . --noEmit",
+    "lint": "eslint src",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "prepare": "yarn build"
+  },
+  "dependencies": {
+    "@valve-tech/viem-errors": "workspace:^"
+  },
+  "peerDependencies": {
+    "viem": "^2.0.0"
+  }
+}