@solana/kit-plugin-wallet 0.0.0 → 0.13.0

package/dist/types/types.d.ts

@@ -0,0 +1,384 @@
+import type { MessageSigner, ReadonlyUint8Array, SignatureBytes, TransactionSigner } from '@solana/kit';
+import type { SolanaChain } from '@solana/wallet-standard-chains';
+import type { SolanaSignInInput, SolanaSignInOutput } from '@solana/wallet-standard-features';
+import type { IdentifierString } from '@wallet-standard/base';
+import type { UiWallet, UiWalletAccount } from '@wallet-standard/ui';
+/**
+ * The signer type for a connected wallet account.
+ *
+ * Always satisfies `TransactionSigner`. Additionally implements `MessageSigner`
+ * when the wallet supports `solana:signMessage`.
+ */
+export type WalletSigner = TransactionSigner | (MessageSigner & TransactionSigner);
+/**
+ * The connection status of the wallet plugin.
+ *
+ * - `pending` — not yet initialized. Initial state on both server and browser.
+ *   On the server — and in React Native, which is treated the same way — this
+ *   state is permanent. In the browser it resolves to `disconnected` or
+ *   `reconnecting` once the storage check completes.
+ * - `disconnected` — initialized, no wallet connected.
+ * - `connecting` — a user-initiated connection request is in progress. When
+ *   connecting to a different wallet while one is already connected, the
+ *   existing connection is preserved until the new one succeeds — so
+ *   {@link WalletState.connected} can be non-null during this state, and a
+ *   failed attempt reverts to the previous connection.
+ * - `connected` — a wallet is connected.
+ * - `disconnecting` — a user-initiated disconnection request is in progress.
+ * - `reconnecting` — auto-connect in progress (connecting to persisted wallet).
+ */
+export type WalletStatus = 'connected' | 'connecting' | 'disconnected' | 'disconnecting' | 'pending' | 'reconnecting';
+/**
+ * A snapshot of the wallet plugin state at a point in time.
+ *
+ * Returned by {@link WalletNamespace.getState}. The same object reference
+ * is returned on successive calls as long as nothing has changed — a new
+ * object is only created when a field actually changes. This ensures
+ * `useSyncExternalStore` only triggers re-renders on meaningful state changes.
+ *
+ * @see {@link WalletNamespace.getState}
+ */
+export type WalletState = {
+    /**
+     * The active connection, or `null` when disconnected.
+     *
+     * `signer` is `null` for read-only / watch-only wallets that do not
+     * support any signing feature.
+     *
+     * Independent of {@link status}: when {@link connect} or {@link signIn} is
+     * called for a different wallet while one is already connected, `connected`
+     * keeps describing the existing connection while `status` is `'connecting'`,
+     * and a failed attempt leaves it in place.
+     */
+    readonly connected: {
+        readonly account: UiWalletAccount;
+        /** The signer for the active account, or `null` for read-only wallets. */
+        readonly signer: WalletSigner | null;
+        readonly wallet: UiWallet;
+    } | null;
+    /** The current connection status. */
+    readonly status: WalletStatus;
+    /** All discovered wallets matching the configured chain and filter. */
+    readonly wallets: readonly UiWallet[];
+};
+/**
+ * Options accepted by each async wallet action.
+ *
+ * Currently only carries an `abortSignal`, but is kept as an object for
+ * consistency with the rest of the Kit ecosystem and to allow future
+ * additions without breaking the call-site shape.
+ *
+ * @see {@link WalletNamespace.connect}
+ * @see {@link WalletNamespace.disconnect}
+ * @see {@link WalletNamespace.signMessage}
+ * @see {@link WalletNamespace.signIn}
+ */
+export type WalletActionOptions = {
+    /**
+     * An optional `AbortSignal` used to cancel the operation.
+     *
+     * Cancellation is pre-call only: the plugin calls
+     * `abortSignal.throwIfAborted()` at the start of each action and bails
+     * out before invoking the wallet. Once the underlying wallet-standard
+     * call has been dispatched, its result is returned even if the signal
+     * is aborted mid-flight — the wallet's side effect (an approved
+     * signature, a live connection, a broadcast transaction) is the source
+     * of truth, and throwing here would discard real user work without
+     * undoing what the wallet already did.
+     */
+    abortSignal?: AbortSignal;
+};
+/**
+ * A pluggable storage adapter for persisting the selected wallet account.
+ *
+ * Follows the Web Storage API shape (`getItem`/`setItem`/`removeItem`).
+ * `localStorage` and `sessionStorage` satisfy this interface directly.
+ * Async backends (IndexedDB, encrypted storage) may return `Promise`s.
+ *
+ * Writes are fire-and-forget: the plugin does not await `setItem`/`removeItem`
+ * and swallows any rejection (the live wallet connection is the source of
+ * truth, so a failed persist is non-fatal). A resolved action therefore does
+ * not guarantee the write has landed, and rapid successive writes are not
+ * ordered. This is intentional — persistence only records which account to
+ * silently reconnect to on the next load.
+ *
+ * @example
+ * ```ts
+ * // Use sessionStorage
+ * walletSigner({ chain: 'solana:mainnet', storage: sessionStorage });
+ *
+ * // Custom async adapter
+ * walletSigner({
+ *   chain: 'solana:mainnet',
+ *   storage: {
+ *     getItem: (key) => myStore.get(key),
+ *     setItem: (key, value) => myStore.set(key, value),
+ *     removeItem: (key) => myStore.delete(key),
+ *   },
+ * });
+ * ```
+ */
+export type WalletStorage = {
+    getItem(key: string): Promise<string | null> | string | null;
+    removeItem(key: string): Promise<void> | void;
+    setItem(key: string, value: string): Promise<void> | void;
+};
+/**
+ * Configuration for the wallet plugins.
+ *
+ * @see {@link walletSigner}
+ * @see {@link walletIdentity}
+ * @see {@link walletPayer}
+ * @see {@link walletWithoutSigner}
+ */
+export type WalletPluginConfig = {
+    /**
+     * Whether to attempt silent reconnection on startup using the persisted
+     * wallet account from `storage`.
+     *
+     * Has no effect if `storage` is `null`.
+     *
+     * @default true
+     */
+    autoConnect?: boolean;
+    /**
+     * The chain this client targets (e.g. `'solana:mainnet'`).
+     *
+     * Accepts any {@link SolanaChain} (with literal autocomplete) and, as an
+     * escape hatch, any wallet-standard {@link IdentifierString} shape
+     * (`${string}:${string}`) for custom chains or non-Solana L2s. The plugin's
+     * runtime behavior is chain-agnostic — it passes the identifier to
+     * wallet-standard discovery (`uiWallet.chains.includes(chain)`) and to
+     * `createSignerFromWalletAccount`. Wallets that don't advertise the chain
+     * are filtered out, and accounts that can't produce a signer for the chain
+     * resolve to `signer: null` (matching the read-only-wallet contract).
+     *
+     * One client = one chain. To switch networks, create a separate client
+     * with a different chain and RPC endpoint.
+     */
+    chain: SolanaChain | (IdentifierString & {});
+    /**
+     * Optional filter function for wallet discovery. Called for each wallet
+     * that supports the configured chain and `standard:connect`. Return `true`
+     * to include the wallet, `false` to exclude it.
+     *
+     * @example
+     * ```ts
+     * // Require signAndSendTransaction
+     * filter: (w) => w.features.includes('solana:signAndSendTransaction')
+     *
+     * // Whitelist specific wallets
+     * filter: (w) => ['SomeWallet', 'SomeOtherWallet'].includes(w.name)
+     * ```
+     */
+    filter?: (wallet: UiWallet) => boolean;
+    /**
+     * Storage adapter for persisting the selected wallet account across page
+     * loads. Pass `null` to disable persistence entirely.
+     *
+     * When omitted in a browser environment, `localStorage` is used by default.
+     * On the server, storage is always skipped regardless of this option.
+     *
+     * @default localStorage (in browser)
+     * @see {@link WalletStorage}
+     */
+    storage?: WalletStorage | null;
+    /**
+     * Storage key used for persistence.
+     *
+     * @default 'kit-wallet'
+     */
+    storageKey?: string;
+};
+/**
+ * The `wallet` namespace exposed on the client as `client.wallet`.
+ *
+ * All wallet state is accessed via {@link getState}. Use {@link subscribe}
+ * to be notified of changes and integrate with framework primitives such as
+ * React's `useSyncExternalStore`.
+ *
+ * @see {@link ClientWithWallet}
+ */
+export type WalletNamespace = {
+    /**
+     * Connect to a wallet. Calls `standard:connect`, then selects the first
+     * newly authorized account (or the first account if reconnecting). Creates
+     * and caches a signer for the active account.
+     *
+     * Resolving means the wallet is connected; any failure rejects. If a wallet
+     * is already connected, it stays connected until the new one is established:
+     * a failed attempt — a rejected prompt, no authorized accounts, or the
+     * wallet becoming unavailable — leaves the previous connection in place
+     * rather than disconnecting it.
+     *
+     * @returns All accounts from the wallet after connection.
+     * @throws The wallet's rejection error if the user declines the prompt.
+     * @throws `SolanaError(SOLANA_ERROR__WALLET__NOT_CONNECTED)` if the wallet
+     *   authorizes no accounts, or unregisters (or drops a required
+     *   feature/chain) while its connect prompt is open. Any previously
+     *   connected wallet is left in place.
+     * @throws `DOMException` with `name: 'AbortError'` if a newer `connect` or
+     *   `signIn` is started before this call resolves. The newer request wins
+     *   and owns the resulting connection; this superseded call rejects so it
+     *   can be ignored like any other aborted operation (e.g. an accidental
+     *   double-click still connects — only the orphaned first promise rejects).
+     * @throws `options.abortSignal.reason` if the signal is already aborted
+     *   when the action is called. Aborts after the wallet call has been
+     *   dispatched do not take effect.
+     */
+    connect: (wallet: UiWallet, options?: WalletActionOptions) => Promise<readonly UiWalletAccount[]>;
+    /**
+     * Disconnect a wallet. Calls `standard:disconnect` if supported.
+     *
+     * `wallet` defaults to the active wallet. Passing a non-active, currently
+     * authorized wallet deauthorizes it (calling `standard:disconnect` if
+     * supported) while leaving the active connection untouched. A `wallet`
+     * that doesn't support `standard:disconnect`, or one that is already
+     * unauthorized/unregistered, is a forgiving no-op.
+     *
+     * @throws `options.abortSignal.reason` if the signal is already aborted
+     *   when the action is called. Aborts after the wallet call has been
+     *   dispatched do not take effect.
+     */
+    disconnect: (wallet?: UiWallet, options?: WalletActionOptions) => Promise<void>;
+    /**
+     * Get the current wallet state. Referentially stable — a new object is
+     * only created when a field actually changes, so React's
+     * `useSyncExternalStore` skips re-renders when nothing meaningful changed.
+     *
+     * @see {@link WalletState}
+     */
+    getState: () => WalletState;
+    /**
+     * Select an account, creating and caching a new signer for it.
+     *
+     * The account may belong to any currently authorized wallet, not only the
+     * active one. When it belongs to a different authorized wallet, the active
+     * connection switches to that wallet synchronously (no prompt), leaving the
+     * previously active wallet authorized. If the store is currently 'disconnected',
+     * this allows transitioning to 'connected' synchronously.
+     *
+     * @throws `SolanaError(SOLANA_ERROR__WALLET__ACCOUNT_NOT_AVAILABLE)` if the
+     *   account's handle cannot be resolved to a currently authorized wallet, or
+     *   the account is not among that wallet's accounts.
+     * @throws `SolanaError(SOLANA_ERROR__WALLET__NOT_CONNECTED)` if the account's
+     *   wallet is currently disconnecting.
+     */
+    selectAccount: (account: UiWalletAccount) => void;
+    /**
+     * Sign In With Solana (SIWS-as-connect).
+     *
+     * Connects the wallet, calls `solana:signIn`, sets the returned account as
+     * active, and creates a signer. Resolving means the client is in the same
+     * state as if {@link connect} had been called; any failure to connect
+     * rejects rather than resolving while disconnected.
+     *
+     * All fields on `SolanaSignInInput` are optional — pass `{}` if no sign-in
+     * customization is needed.
+     *
+     * To sign in with the already-connected wallet, pass
+     * `getState().connected.wallet`.
+     *
+     * Like {@link connect}, a failed sign-in to a different wallet rejects and
+     * leaves any existing connection in place rather than disconnecting it.
+     *
+     * @returns The wallet's sign-in output, once the connection is established.
+     * @throws `WalletStandardError(WALLET_STANDARD_ERROR__FEATURES__WALLET_ACCOUNT_FEATURE_UNIMPLEMENTED)`
+     *   if the wallet does not support `solana:signIn`.
+     * @throws `SolanaError(SOLANA_ERROR__WALLET__NOT_CONNECTED)` if the wallet
+     *   unregisters (or drops a required feature/chain) while its sign-in prompt
+     *   is open, or signs in with an account it does not expose. Any previously
+     *   connected wallet is left in place.
+     * @throws `DOMException` with `name: 'AbortError'` if a newer `connect` or
+     *   `signIn` is started before this call resolves. The newer request wins
+     *   and owns the resulting connection; this superseded call rejects so it
+     *   can be ignored like any other aborted operation.
+     * @throws `options.abortSignal.reason` if the signal is already aborted
+     *   when the action is called. Aborts after the wallet call has been
+     *   dispatched do not take effect.
+     */
+    signIn: (wallet: UiWallet, input: SolanaSignInInput, options?: WalletActionOptions) => Promise<SolanaSignInOutput>;
+    /**
+     * Sign an arbitrary message with the connected account.
+     *
+     * Calls the wallet's `solana:signMessage` feature directly (does not go
+     * through the cached signer), so message signing works even for wallets
+     * that don't support transaction signing.
+     *
+     * @throws `SolanaError(SOLANA_ERROR__WALLET__NOT_CONNECTED)` if no wallet is connected.
+     * @throws `WalletStandardError(WALLET_STANDARD_ERROR__FEATURES__WALLET_ACCOUNT_FEATURE_UNIMPLEMENTED)`
+     *   if the wallet does not support `solana:signMessage`.
+     * @throws `options.abortSignal.reason` if the signal is already aborted
+     *   when the action is called. Aborts after the wallet call has been
+     *   dispatched do not take effect.
+     */
+    signMessage: (message: ReadonlyUint8Array, options?: WalletActionOptions) => Promise<SignatureBytes>;
+    /**
+     * Subscribe to any wallet state change. Compatible with React's
+     * `useSyncExternalStore` and similar framework primitives.
+     *
+     * @returns An unsubscribe function.
+     *
+     * @example
+     * ```ts
+     * const state = useSyncExternalStore(client.wallet.subscribe, client.wallet.getState);
+     * ```
+     */
+    subscribe: (listener: () => void) => () => void;
+    /**
+     * **Advanced.** Resolves once the initial connection attempt has settled —
+     * i.e. {@link getState}'s `status` is no longer `'pending'` or
+     * `'reconnecting'`.
+     *
+     * You only need this if your app **rebuilds the client at runtime** (for
+     * example, to change chain). Each freshly built client runs a silent
+     * auto-reconnect that briefly passes through `'pending'`/`'reconnecting'`;
+     * awaiting this lets you hold the previous UI until the new client is ready
+     * instead of flashing a "reconnecting" state on every swap. Most apps never
+     * call it — subscribe to `status` with {@link subscribe} instead.
+     *
+     * Does **not** wait for user-initiated `connect`/`disconnect`/`signIn`
+     * (those pass through `'connecting'`/`'disconnecting'`, which count as
+     * ready), so a normal connect never makes this block. While transient it
+     * returns the **same** promise reference on every call, so successive
+     * awaits during one warm-up share a single settlement.
+     *
+     * Disposing the client mid-warm-up settles the status to `'disconnected'`,
+     * so a pending `whenReady()` resolves rather than hanging. Check
+     * {@link getState} after awaiting if you need to distinguish a ready
+     * connection from a disposed (or never-connected) client.
+     *
+     * @returns A promise that resolves with no value once the wallet is past its
+     *   initial `'pending'`/`'reconnecting'` warm-up. Already resolved when the
+     *   status is not transient.
+     *
+     * @example
+     * ```ts
+     * // On a chain switch, hold the old UI until the rebuilt client is ready:
+     * const next = createClient().use(walletSigner({ chain }));
+     * await next.wallet.whenReady();
+     * setClient(next);
+     * ```
+     */
+    whenReady: () => Promise<void>;
+};
+/**
+ * Properties added to the client by the wallet plugins.
+ *
+ * All wallet state and actions are namespaced under `client.wallet`.
+ * Depending on which plugin variant is used, `client.payer` and/or
+ * `client.identity` may also be set to the connected wallet's signer.
+ * This is not part of Kit plugin-interfaces, as it depends on wallet-standard types
+ *
+ * @see {@link walletSigner}
+ * @see {@link walletPayer}
+ * @see {@link walletIdentity}
+ * @see {@link walletWithoutSigner}
+ * @see {@link WalletNamespace}
+ *
+ */
+export type ClientWithWallet = {
+    /** The wallet namespace — state, actions, and framework integration. */
+    readonly wallet: WalletNamespace;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types/wallet.d.ts

@@ -0,0 +1,133 @@
+import { type ClientWithIdentity, type ClientWithPayer, type ClientWithSubscribeToIdentity, type ClientWithSubscribeToPayer } from '@solana/kit';
+import type { ClientWithWallet, WalletPluginConfig } from './types';
+/**
+ * A framework-agnostic Kit plugin that manages wallet discovery, connection
+ * lifecycle, and signer creation using wallet-standard — and syncs the
+ * connected wallet's signer to both `client.payer` and `client.identity`.
+ *
+ * This is the most common entrypoint for dApps. When a signing-capable
+ * wallet is connected, `client.payer` and `client.identity` both return the
+ * wallet signer. When disconnected or read-only, accessing either throws.
+ *
+ * Because the signer is dynamic, both `client.subscribeToPayer` and
+ * `client.subscribeToIdentity` are installed so reactive consumers can observe
+ * changes (the Kit reactive-capability convention).
+ *
+ * **SSR-safe.** Can be included in a shared client chain that runs on both
+ * server and browser.
+ *
+ * ```ts
+ * const client = createClient()
+ *   .use(walletSigner({ chain: 'solana:mainnet' }))
+ *   .use(solanaRpc({ rpcUrl: 'https://api.mainnet-beta.solana.com' }))
+ *   .use(planAndSendTransactions());
+ * ```
+ *
+ * @param config - Plugin configuration.
+ *
+ * @see {@link walletPayer}
+ * @see {@link walletIdentity}
+ * @see {@link walletWithoutSigner}
+ * @see {@link WalletPluginConfig}
+ */
+export declare function walletSigner(config: WalletPluginConfig): <T extends object & {
+    wallet?: never;
+}>(client: T) => Disposable & Omit<T, "identity" | "payer" | "subscribeToIdentity" | "subscribeToPayer" | "wallet"> & ClientWithIdentity & ClientWithPayer & ClientWithSubscribeToIdentity & ClientWithSubscribeToPayer & ClientWithWallet;
+/**
+ * A framework-agnostic Kit plugin that manages wallet discovery, connection
+ * lifecycle, and signer creation using wallet-standard — and syncs the
+ * connected wallet's signer to `client.identity`.
+ *
+ * Use this when `client.payer` is controlled by a separate `payer()` plugin
+ * (e.g. a backend relayer pays fees, but the user's wallet is the identity).
+ *
+ * Because the signer is dynamic, `client.subscribeToIdentity` is installed so
+ * reactive consumers can observe changes (the Kit reactive-capability convention).
+ *
+ * **SSR-safe.** Can be included in a shared client chain that runs on both
+ * server and browser.
+ *
+ * ```ts
+ * const client = createClient()
+ *   .use(payer(relayerKeypair))
+ *   .use(walletIdentity({ chain: 'solana:mainnet' }))
+ *   .use(solanaRpc({ rpcUrl: 'https://api.mainnet-beta.solana.com' }))
+ *   .use(planAndSendTransactions());
+ * ```
+ *
+ * @param config - Plugin configuration.
+ *
+ * @see {@link walletSigner}
+ * @see {@link walletPayer}
+ * @see {@link walletWithoutSigner}
+ * @see {@link WalletPluginConfig}
+ */
+export declare function walletIdentity(config: WalletPluginConfig): <T extends object & {
+    wallet?: never;
+}>(client: T) => Disposable & Omit<T, "identity" | "subscribeToIdentity" | "wallet"> & ClientWithIdentity & ClientWithSubscribeToIdentity & ClientWithWallet;
+/**
+ * A framework-agnostic Kit plugin that manages wallet discovery, connection
+ * lifecycle, and signer creation using wallet-standard — and syncs the
+ * connected wallet's signer to `client.payer`.
+ *
+ * Use this when you need the wallet as the fee payer but don't need
+ * `client.identity`. For most dApps, prefer {@link walletSigner} which
+ * sets both.
+ *
+ * Because the signer is dynamic, `client.subscribeToPayer` is installed so
+ * reactive consumers can observe changes (the Kit reactive-capability convention).
+ *
+ * **SSR-safe.** Can be included in a shared client chain that runs on both
+ * server and browser.
+ *
+ * ```ts
+ * const client = createClient()
+ *   .use(walletPayer({ chain: 'solana:mainnet' }))
+ *   .use(solanaRpc({ rpcUrl: 'https://api.mainnet-beta.solana.com' }))
+ *   .use(planAndSendTransactions());
+ * ```
+ *
+ * @param config - Plugin configuration.
+ *
+ * @see {@link walletSigner}
+ * @see {@link walletIdentity}
+ * @see {@link walletWithoutSigner}
+ * @see {@link WalletPluginConfig}
+ */
+export declare function walletPayer(config: WalletPluginConfig): <T extends object & {
+    wallet?: never;
+}>(client: T) => Disposable & Omit<T, "payer" | "subscribeToPayer" | "wallet"> & ClientWithPayer & ClientWithSubscribeToPayer & ClientWithWallet;
+/**
+ * A framework-agnostic Kit plugin that manages wallet discovery, connection
+ * lifecycle, and signer creation using wallet-standard.
+ *
+ * Adds the `wallet` namespace to the client without setting `client.payer`
+ * or `client.identity`. Use this alongside separate `payer()` and/or
+ * `identity()` plugins, or when the wallet's signer is used explicitly in
+ * instructions. For most dApps, prefer {@link walletSigner} instead.
+ *
+ * **SSR-safe.** Can be included in a shared client chain that runs on both
+ * server and browser.
+ *
+ * ```ts
+ * const client = createClient()
+ *   .use(payer(backendKeypair))
+ *   .use(walletWithoutSigner({ chain: 'solana:mainnet' }))
+ *   .use(solanaRpc({ rpcUrl: 'https://api.mainnet-beta.solana.com' }))
+ *   .use(planAndSendTransactions());
+ *
+ * // client.payer is always backendKeypair
+ * // client.wallet.getState().connected?.signer for manual use
+ * ```
+ *
+ * @param config - Plugin configuration.
+ *
+ * @see {@link walletSigner}
+ * @see {@link walletPayer}
+ * @see {@link walletIdentity}
+ * @see {@link WalletPluginConfig}
+ */
+export declare function walletWithoutSigner(config: WalletPluginConfig): <T extends object & {
+    wallet?: never;
+}>(client: T) => Disposable & Omit<T, "wallet"> & ClientWithWallet;
+//# sourceMappingURL=wallet.d.ts.map

package/dist/types/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../src/wallet.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,EAMlC,MAAM,aAAa,CAAC;AAGrB,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAkEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,kBAAkB,IAtD3C,CAAC,SAAS,MAAM,GAAG;IAAE,MAAM,CAAC,EAAE,KAAK,CAAA;CAAE,0OA8DhD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,kBAAkB,IA7F7C,CAAC,SAAS,MAAM,GAAG;IAAE,MAAM,CAAC,EAAE,KAAK,CAAA;CAAE,4JA+FhD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,kBAAkB,IA9H1C,CAAC,SAAS,MAAM,GAAG;IAAE,MAAM,CAAC,EAAE,KAAK,CAAA;CAAE,gJAgIhD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,kBAAkB,IAhKlD,CAAC,SAAS,MAAM,GAAG;IAAE,MAAM,CAAC,EAAE,KAAK,CAAA;CAAE,kEAkKhD"}

package/package.json

@@ -1,12 +1,108 @@
 {
   "name": "@solana/kit-plugin-wallet",
-  "version": "0.0.0",
-  "description": "",
-  "license": "ISC",
-  "author": "",
+  "version": "0.13.0",
+  "description": "Wallet connection plugin for Kit clients",
+  "keywords": [
+    "kit",
+    "plugin",
+    "signer",
+    "solana",
+    "wallet",
+    "wallet-adapter",
+    "wallet-standard"
+  ],
+  "bugs": {
+    "url": "http://github.com/anza-xyz/kit-plugins/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anza-xyz/kit-plugins"
+  },
+  "files": [
+    "./dist/types",
+    "./dist/index.*",
+    "./dist/react/index.*",
+    "./src/"
+  ],
   "type": "commonjs",
-  "main": "index.js",
+  "sideEffects": false,
+  "main": "./dist/index.node.cjs",
+  "module": "./dist/index.node.mjs",
+  "browser": {
+    "./dist/index.node.cjs": "./dist/index.browser.cjs",
+    "./dist/index.node.mjs": "./dist/index.browser.mjs"
+  },
+  "types": "./dist/types/index.d.ts",
+  "react-native": "./dist/index.react-native.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "react-native": "./dist/index.react-native.mjs",
+      "browser": {
+        "import": "./dist/index.browser.mjs",
+        "require": "./dist/index.browser.cjs"
+      },
+      "node": {
+        "import": "./dist/index.node.mjs",
+        "require": "./dist/index.node.cjs"
+      }
+    },
+    "./react": {
+      "types": "./dist/types/react/index.d.ts",
+      "react-native": "./dist/react/index.react-native.mjs",
+      "browser": {
+        "import": "./dist/react/index.browser.mjs",
+        "require": "./dist/react/index.browser.cjs"
+      },
+      "node": {
+        "import": "./dist/react/index.node.mjs",
+        "require": "./dist/react/index.node.cjs"
+      }
+    }
+  },
+  "dependencies": {
+    "@solana/wallet-account-signer": "^7.0.0",
+    "@solana/wallet-standard-chains": "^1.1.2",
+    "@solana/wallet-standard-features": "^1.4.0",
+    "@wallet-standard/app": "^1.1.1",
+    "@wallet-standard/base": "^1.1.1",
+    "@wallet-standard/features": "^1.1.1",
+    "@wallet-standard/ui": "^1.0.3",
+    "@wallet-standard/ui-features": "^1.0.3",
+    "@wallet-standard/ui-registry": "^1.1.1"
+  },
+  "devDependencies": {
+    "@solana/react": "^7.0.0",
+    "@testing-library/react": "^16.0.0",
+    "@types/react": "^18.0.0 || ^19.0.0",
+    "@wallet-standard/errors": "^0.1.2",
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "peerDependencies": {
+    "@solana/kit": "^7.0.0",
+    "@solana/react": "^7.0.0",
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@solana/react": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "browserslist": [
+    "supports bigint and not dead",
+    "maintained node versions"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "rimraf dist && tsup && tsc -p ./tsconfig.declarations.json",
+    "dev": "vitest --project node",
+    "test": "pnpm test:types && pnpm test:treeshakability && pnpm test:unit",
+    "test:treeshakability": "for file in dist/index.*.mjs dist/react/index.*.mjs; do agadoo $file; done",
+    "test:types": "tsc --noEmit",
+    "test:unit": "vitest run"
   }
-}
+}