kaspa-wallet-standard 0.1.0 → 0.2.0

package/README.md

@@ -5,8 +5,10 @@ any dApp can find any wallet — and any wallet can join every dApp — without
 other. Inspired by Ethereum's [EIP-6963](https://eips.ethereum.org/EIPS/eip-6963) and Solana's
 [Wallet Standard](https://github.com/wallet-standard/wallet-standard).
 
-> **Status: proposed / draft**, open for community adoption and headed for a [KIP](https://github.com/kaspanet/kips).
-> The full specification is in **[SPEC.md](SPEC.md)**. The wire contract is frozen — see SPEC §7.
+> **Status: reference implementation of [KIP-12](https://github.com/kaspanet/kips/pull/21) (draft, under revival).**
+> This standard has been folded into KIP-12, which is now the authoritative specification; this package
+> implements it exactly — canonical names only (`kaspa:provider` announce, bare network ids,
+> `chainChanged`). [SPEC.md](SPEC.md) tracks the same contract. Versioning policy: SPEC §7.
 
 ```bash
 npm install kaspa-wallet-standard
@@ -55,7 +57,7 @@ const provider = {
   getPublicKey:    () => w.request('kas:get_account').then(a => a.publicKey),
   signMessage:     (m) => w.request('kas:sign_message', m),
   signPskt: ({ txJsonString, options }) => w.request('kas:sign_tx', {
-    networkId: /* your network id */ 'kaspa_testnet_10',
+    networkId: /* whatever id YOUR bridge expects — this is the wallet's own dialect */ 'testnet-10',
     txJson: txJsonString,
     scripts: options.signInputs.map(s => ({ inputIndex: s.index, scriptHex: '', signType: 'All' })),
   }),
@@ -74,7 +76,7 @@ const detail = Object.freeze({
   info: Object.freeze({ uuid: crypto.randomUUID(), name: 'YourWallet', icon: 'data:…', rdns: 'com.yourwallet' }),
   provider: window.yourwallet,
 });
-const announce = () => window.dispatchEvent(new CustomEvent('kaspa:announceProvider', { detail }));
+const announce = () => window.dispatchEvent(new CustomEvent('kaspa:provider', { detail }));
 window.addEventListener('kaspa:requestProvider', announce);
 announce();
 ```
@@ -93,7 +95,10 @@ const unsubscribe = requestKaspaWallets(({ info, provider }) => {
 ```
 
 Then on click: `const [address] = await provider.requestAccounts();`. Capability-check optional methods
-before using them, and refuse any `info.icon` that isn't a `data:` URI.
+before using them. `requestKaspaWallets` already strips any non-`data:` `info.icon` for you (a remote URL
+is a tracking/spoofing vector), so what reaches your callback is safe to render. The announce is **not** an
+identity proof, though — any script can announce any name/rdns, so require an explicit user connect before
+signing and treat silent `getAccounts()` restore as display-only. See [SPEC §8](SPEC.md#8-security-considerations).
 
 ## Who's using it
 
@@ -105,10 +110,12 @@ Using it in your wallet or dApp? Open a PR to add yourself.
 
 ## Status & contributing
 
-This is a **proposed** standard. The goal is ratification as a KIP once the handshake is proven across at
-least two independently-developed wallets. If you're a wallet or dApp author — especially if you'd want a
-field changed **before** it freezes into a KIP — please [open an issue](../../issues). See
-[SPEC.md](SPEC.md) for the full contract, security model, and versioning policy.
+This package is the reference implementation of **KIP-12**, the (draft) Kaspa wallet provider and
+discovery standard — the original draft lives at [kaspanet/kips#21](https://github.com/kaspanet/kips/pull/21)
+and a revived, consolidated revision is being prepared with the original authors. The bar for
+ratification: the handshake proven across at least two independently-developed wallets. If you're a
+wallet or dApp author, review happens on the KIP; implementation issues are welcome
+[here](../../issues). See [SPEC.md](SPEC.md) for the contract, security model, and versioning policy.
 
 ## License
 

package/SPEC.md

@@ -1,11 +1,12 @@
 # Kaspa Wallet Standard
 
-**Status: Proposed (draft).** This is an open proposal for how Kaspa dApps and wallets discover and talk
-to each other. It is **not** (yet) a ratified [Kaspa Improvement Proposal](https://github.com/kaspanet/kips) —
-it is offered for community adoption and feedback, with the explicit goal of becoming a KIP once it has
-proven out across independent wallets. Comments, issues, and PRs are welcome.
+**Status: folded into [KIP-12](https://github.com/kaspanet/kips/pull/21) (draft, under revival).**
+This document began as an independent proposal and has since been consolidated into KIP-12, the
+Kaspa wallet provider and discovery standard — **the KIP is the authoritative specification**; this
+file tracks the same contract as the companion to the reference implementation in this package.
+Standards review happens on the KIP; implementation issues are welcome here.
 
-**Version:** 0.1 · **Wire contract:** frozen (see §7).
+**Version:** 0.2 · **Naming:** KIP-12 canonical only (see §7 for the versioning policy).
 
 ---
 
@@ -30,7 +31,7 @@ It has two parts: a **provider interface** (§3–4) and a **discovery handshake
 
 - **Provider** — the object a wallet injects/exposes that a dApp calls to get accounts, network, and
   signatures (§3).
-- **Announce** — a wallet advertising its provider via the `kaspa:announceProvider` event (§5).
+- **Announce** — a wallet advertising its provider via the `kaspa:provider` event (§5).
 - **dApp** — any web page that wants to use a Kaspa wallet.
 - Keywords **MUST**, **SHOULD**, **MAY** are used per [RFC 2119](https://www.rfc-editor.org/rfc/rfc2119).
 
@@ -50,7 +51,7 @@ method is **optional** and MUST be capability-checked by the dApp (`typeof p.sig
 | `signMessage(msg): Promise<string>` | no | KIP-5 message signing → Schnorr signature hex. |
 | `signPskt({ txJsonString, options }): Promise<string>` | no | Sign specific inputs of a transaction (§4). |
 | `disconnect(origin?): Promise<void>` | no | Drop the site's authorization. |
-| `on / removeListener(event, handler)` | no | `accountsChanged`, `networkChanged`. |
+| `on / removeListener(event, handler)` | no | `accountsChanged`, `chainChanged`. |
 
 A wallet that implements only `requestAccounts` is valid — it will connect and display balances in a
 dApp, which simply disables features that need the missing methods.
@@ -74,7 +75,7 @@ array of `{ index, sighashType }`, and returns the re-serialized signed transact
 
 Two events on `window`, mirroring EIP-6963 replay semantics:
 
-- **`kaspa:announceProvider`** — a `CustomEvent` dispatched by the **wallet**. `detail` is a **frozen**
+- **`kaspa:provider`** — a `CustomEvent` dispatched by the **wallet**. `detail` is a **frozen**
   `{ info, provider }` (see §5.1). MUST be dispatched on load, and re-dispatched on every
   `kaspa:requestProvider`.
 - **`kaspa:requestProvider`** — a plain `Event` dispatched by the **dApp** to ask present wallets to
@@ -83,7 +84,7 @@ Two events on `window`, mirroring EIP-6963 replay semantics:
 **Sequence**
 
 1. On load, the wallet registers a `kaspa:requestProvider` listener that re-announces, then announces once.
-2. The dApp registers its `kaspa:announceProvider` listener (kept alive for the page lifetime), then
+2. The dApp registers its `kaspa:provider` listener (kept alive for the page lifetime), then
    dispatches `kaspa:requestProvider`.
 3. Late arrival is covered from both directions: a late wallet announces unprompted on load; a late dApp's
    request triggers a replay from every wallet already present.
@@ -100,33 +101,55 @@ type KaspaProviderInfo = {
 type KaspaProviderDetail = { info: KaspaProviderInfo; provider: KaspaProvider };
 ```
 
-- The wallet **MUST** freeze `detail` (and `detail.info`) so page scripts cannot swap the provider out.
-- The wallet **SHOULD** provide a stable `rdns`; without it a dApp cannot silently restore the session
-  after a reload (there is no stable identity to match).
-- The dApp **SHOULD** dedupe announces by `info.rdns ?? info.uuid`, first-announce-wins.
+- The wallet **MUST** freeze `detail` (and `detail.info`) so a page script cannot mutate an announce
+  **in flight** (swap the `provider` or a field on an already-dispatched event). Freezing protects the
+  integrity of a *single* announce only — it does **not** authenticate the announcer, and a hostile
+  script can still dispatch its **own** competing announce. Freezing is not a trust signal (see §8).
+- The wallet **SHOULD** provide a stable `rdns`; without it a dApp cannot restore the session after a
+  reload (there is no stable identity to match). `rdns` is a convenience key, **not** an authenticity
+  claim — any script can announce any `rdns` (see §8).
+- The dApp **SHOULD** dedupe announces by `info.rdns ?? info.uuid` (first-announce-wins). Because `rdns`
+  is spoofable, a dApp **MAY** surface a *second* announce for an already-seen `rdns` as a warning rather
+  than silently discarding it.
 
 ## 6. Network ids
 
-Canonical strings (also exported as `KASPA_NETWORKS`):
+Canonical strings (also exported as `KASPA_NETWORKS`) — the node's own network ids, per KIP-12:
 
-`kaspa_mainnet` · `kaspa_testnet_10` · `kaspa_testnet_11` · `kaspa_devnet`
+`mainnet` · `testnet-10` · `testnet-11` · `devnet`
 
-## 7. Compatibility and versioning (frozen contract)
+Some injected wallet APIs speak a `kaspa_`-prefixed dialect (`kaspa_mainnet`, `kaspa_testnet_10`);
+adapters SHOULD normalize those to canonical — the package exports `normalizeKaspaNetworkId()` for
+exactly this.
 
-The **wire contract is frozen**: the two event names, and every field defined above, never change
-meaning or type. The standard evolves **only by adding new OPTIONAL fields/methods**. A wallet or dApp
-built against this document keeps working against every future version. Breaking changes, if ever
-unavoidable, would ship under a **new event name** — never by mutating these.
+## 7. Compatibility and versioning
+
+**v0.2 is a clean break to KIP-12 canonical naming** (announce event, network ids, change event) —
+made while this package's own deployments were the only consumers of the v0.1 names, which are
+retired outright (no dual bridge). From v0.2 the contract is stable under KIP-12's own rule: the
+event names and every field defined above never change meaning or type; the standard evolves **only
+by adding new OPTIONAL fields/methods**; breaking changes, if ever unavoidable, ship under a **new
+event name** — never by mutating these.
 
 ## 8. Security considerations
 
 - `name`/`icon` are **display hints, not trust signals**. An announce proves a provider is *present*, not
   that it is *who it claims to be*. dApps MUST NOT grant trust based on them, and MUST refuse non-`data:`
-  icons (a remote URL is a tracking/spoofing vector).
-- Any page script can dispatch `kaspa:announceProvider`. Treat the provider as untrusted until the user
-  explicitly connects; the connect prompt is the trust boundary.
+  icons (a remote URL is a tracking/spoofing vector). The reference `requestKaspaWallets` **enforces this
+  for you** — it strips any non-`data:` icon (delivers it as `''`) before handing the announce to your
+  callback.
+- Any page script can dispatch `kaspa:provider`, including one that claims another wallet's
+  `name`/`rdns`. Treat the provider as untrusted until the user explicitly connects; the wallet's own
+  connect/sign prompt — rendered by the extension, outside page control — is the trust boundary, not the
+  announce.
+- **Silent session restore is display-only.** A dApp MAY use a remembered `rdns` to silently re-populate
+  *displayed* accounts via `getAccounts()` after a reload, but it **MUST** require a fresh explicit user
+  connect gesture before calling `signPskt` (or any signing). Never route a signature to a provider the
+  user did not explicitly (re-)select this session — `rdns` alone is spoofable and is not consent.
 - The fund-safety rules in §4 are the load-bearing security property. A wallet that signs sloppily can
-  lose user funds even though the handshake itself is benign.
+  lose user funds even though the handshake itself is benign. Note a spoofed in-page provider still
+  **cannot forge a signature** (it holds no keys); the realistic risk of announce-spoofing is *display
+  spoofing / phishing setup*, which the connect-gesture boundary above is designed to contain.
 
 ## 9. Reference implementation & adoption
 
@@ -136,9 +159,12 @@ unavoidable, would ship under a **new event name** — never by mutating these.
   discovery handshake in production, and ships built-in adapters for KasWare and Kastle behind the same
   provider interface.
 
-## 10. Path to standardization
+## 10. Standardization status
 
-This document is intended to graduate into a **KIP**. The bar we're aiming for before proposing
-ratification: the handshake proven across **at least two independently-developed wallets**, and the
-provider interface exercised by covenant-grade `signPskt` on-chain. Wallet and dApp authors who adopt it
-(or who want fields changed *before* it freezes into a KIP) are invited to open an issue.
+This document **has been folded into KIP-12** ([original draft PR](https://github.com/kaspanet/kips/pull/21);
+a revived, consolidated revision is being prepared with the original authors) — the KIP is where the
+standard lives and where review happens. The bar before proposing ratification stands: the handshake
+proven across **at least two independently-developed wallets** (in progress: KRON's dApp side against
+the Rift wallet PoC, plus the KasWare/Kastle adapters), and the provider interface exercised by
+covenant-grade `signPskt` on-chain. Wallet and dApp authors: raise standards questions on the KIP,
+implementation issues here.

package/dist/index.d.ts

@@ -1,19 +1,25 @@
 /** Canonical network ids used by `getNetwork()` / `switchNetwork()`. String literals are the contract;
  *  this object is a convenience so integrators don't hand-type them. */
 declare const KASPA_NETWORKS: {
-    readonly MAINNET: "kaspa_mainnet";
-    readonly TESTNET_10: "kaspa_testnet_10";
-    readonly TESTNET_11: "kaspa_testnet_11";
-    readonly DEVNET: "kaspa_devnet";
+    readonly MAINNET: "mainnet";
+    readonly TESTNET_10: "testnet-10";
+    readonly TESTNET_11: "testnet-11";
+    readonly DEVNET: "devnet";
 };
 type KaspaNetworkId = (typeof KASPA_NETWORKS)[keyof typeof KASPA_NETWORKS];
+/** Normalize any wallet-reported network id to the canonical KIP-12 form: legacy `kaspa_`-prefixed
+ *  variants (`kaspa_mainnet`, `kaspa_testnet_10` — v0.1 of this package, KasWare's injected API) map to
+ *  the node's bare ids (`mainnet`, `testnet-10`). Canonical ids pass through unchanged. */
+declare const normalizeKaspaNetworkId: (id: string) => string;
 /** Identity a wallet announces about itself. `name`/`icon` are DISPLAY hints — never trust signals. */
 type KaspaProviderInfo = {
     /** UUIDv4, freshly generated per page load — instance identity, used only for dedupe. */
     uuid: string;
     /** Human-readable wallet name shown in pickers, e.g. "Kastle". */
     name: string;
-    /** Wallet icon as a `data:` URI (SVG/PNG). dApps should refuse to render remote URLs. */
+    /** Wallet icon as a `data:` URI (SVG/PNG) — a DISPLAY hint, never a trust signal. A remote URL is a
+     *  tracking/spoofing vector, so the dApp-side {@link requestKaspaWallets} STRIPS any non-`data:` icon
+     *  (delivers it as `''`) — a dApp can never be handed a remote URL through the handshake. */
     icon: string;
     /** Reverse-DNS identifier, e.g. "com.kasware" — STABLE across page loads and versions. Strongly
      *  recommended: it is what lets a dApp silently restore a session with your wallet after a reload. */
@@ -25,6 +31,95 @@ type KaspaSignInput = {
     index: number;
     sighashType: number;
 };
+/** Argument of {@link KaspaProvider.signPskt}: a Kaspa Safe-JSON transaction plus the explicit list of
+ *  inputs to sign. The wallet MUST sign ONLY these inputs and leave the rest untouched (fund-safety). */
+interface KaspaSignPsktArg {
+    txJsonString: string;
+    options: {
+        signInputs: KaspaSignInput[];
+    };
+}
+/** Simple transfer (SPEC §4.2). Amount is sompi as a base-10 **string** — float KAS is FORBIDDEN in the
+ *  wire contract: IEEE-754 doubles cannot represent every sompi value exactly, and a rounding error in an
+ *  amount is a fund-safety defect. */
+interface KaspaSimpleTransfer {
+    to: string;
+    amountSompi: string;
+}
+/** Provider events and their payloads (SPEC §6). */
+interface KaspaProviderEventMap {
+    /** The authorized account list changed (switch, revoke). */
+    accountsChanged: string[];
+    /** The wallet switched networks; payload is a network id (see {@link KaspaNetworkId}). */
+    chainChanged: string;
+}
+type KaspaProviderEvent = keyof KaspaProviderEventMap;
+/** Canonical `request()` registry (SPEC §7): every §3 method under a namespaced name, so a
+ *  `request()`-only client stays possible. Future KIPs/protocols extend this map via declaration
+ *  merging; wallets serve vendor methods under their own namespace (e.g. `"rift:…"`). */
+interface KaspaRequestMap {
+    'kaspa:requestAccounts': {
+        args: [];
+        result: string[];
+    };
+    'kaspa:getAccounts': {
+        args: [];
+        result: string[];
+    };
+    'kaspa:getNetwork': {
+        args: [];
+        result: string;
+    };
+    'kaspa:switchNetwork': {
+        args: [networkId: string];
+        result: void;
+    };
+    'kaspa:getPublicKey': {
+        args: [];
+        result: string;
+    };
+    'kaspa:signMessage': {
+        args: [message: string];
+        result: string;
+    };
+    'kaspa:signPskt': {
+        args: [arg: KaspaSignPsktArg];
+        result: string;
+    };
+    'kaspa:sendTransaction': {
+        args: [tx: KaspaSimpleTransfer];
+        result: string;
+    };
+    'kaspa:signPskb': {
+        args: [pskb: string];
+        result: string;
+    };
+    'kaspa:broadcastPskb': {
+        args: [pskb: string];
+        result: string[];
+    };
+    'kaspa:disconnect': {
+        args: [origin?: string];
+        result: void;
+    };
+}
+type KaspaRequestMethod = keyof KaspaRequestMap;
+/** Standard rejection codes (SPEC §8, mirroring EIP-1193 for developer familiarity). */
+declare const KIP12_ERRORS: {
+    /** The user rejected the request. */
+    readonly USER_REJECTED: 4001;
+    /** The origin is not authorized (call `requestAccounts` first). */
+    readonly UNAUTHORIZED: 4100;
+    /** The wallet does not support the requested method. */
+    readonly UNSUPPORTED_METHOD: 4200;
+    /** The wallet is locked or unavailable. */
+    readonly WALLET_UNAVAILABLE: 4900;
+};
+interface Kip12Error {
+    message: string;
+    code?: number | string;
+    details?: unknown;
+}
 /**
  * The raw provider surface a wallet exposes. Deliberately shaped like the widely-deployed injected APIs
  * (KasWare's `window.kasware`) so an existing wallet can usually announce its injected object as-is.
@@ -50,21 +145,30 @@ interface KaspaProvider {
     getPublicKey?(): Promise<string>;
     /** KIP-5 message signing; resolves to the Schnorr signature hex. */
     signMessage?(message: string): Promise<string>;
-    /** Sign ONLY the listed inputs of a Kaspa Safe-JSON transaction and return the signed Safe JSON. */
-    signPskt?(arg: {
-        txJsonString: string;
-        options: {
-            signInputs: KaspaSignInput[];
-        };
-    }): Promise<string>;
+    /** Sign ONLY the listed inputs of a Kaspa Safe-JSON transaction and return the signed Safe JSON —
+     *  the covenant-grade signing primitive (fund-safety rules apply). */
+    signPskt?(arg: KaspaSignPsktArg): Promise<string>;
+    /** Simple transfer (SPEC §4.2); resolves to the transaction id. */
+    sendTransaction?(tx: KaspaSimpleTransfer): Promise<string>;
+    /** Sign a PSKB bundle (SPEC §4.3); the per-input discipline of {@link signPskt} applies. */
+    signPskb?(pskb: string): Promise<string>;
+    /** Broadcast a signed PSKB; resolves to transaction ids. */
+    broadcastPskb?(pskb: string): Promise<string[]>;
     disconnect?(origin?: string): Promise<void>;
-    on?(event: 'accountsChanged' | 'networkChanged', handler: (...args: any[]) => void): void;
-    removeListener?(event: string, handler: (...args: any[]) => void): void;
+    /** Subscribe to a provider event; the handler payload is inferred from the event
+     *  ({@link KaspaProviderEventMap}). `chainChanged` is the KIP-12 network-change event. */
+    on?<E extends KaspaProviderEvent>(event: E, handler: (payload: KaspaProviderEventMap[E]) => void): void;
+    removeListener?<E extends KaspaProviderEvent>(event: E, handler: (payload: KaspaProviderEventMap[E]) => void): void;
+    /** Typed protocol-extension escape hatch (SPEC §7). Extends the surface, never the privileges — a
+     *  method served here is still subject to the authorization gate and fund-safety rules. An unknown
+     *  method MUST reject with code 4200 ({@link KIP12_ERRORS}). */
+    request?<M extends KaspaRequestMethod>(method: M, args: KaspaRequestMap[M]['args']): Promise<KaspaRequestMap[M]['result']>;
 }
 /** Dispatched on `window` by a dApp to ask all present wallets to (re-)announce themselves. */
 declare const KASPA_REQUEST_PROVIDER_EVENT = "kaspa:requestProvider";
-/** Dispatched on `window` by a wallet; `detail` is a frozen {@link KaspaProviderDetail}. */
-declare const KASPA_ANNOUNCE_PROVIDER_EVENT = "kaspa:announceProvider";
+/** Dispatched on `window` by a wallet; `detail` is a frozen {@link KaspaProviderDetail}.
+ *  KIP-12 canonical name. */
+declare const KASPA_ANNOUNCE_PROVIDER_EVENT = "kaspa:provider";
 /** The `detail` of a `kaspa:announceProvider` CustomEvent. */
 type KaspaProviderDetail = {
     info: KaspaProviderInfo;
@@ -80,9 +184,17 @@ declare function announceKaspaWallet(info: KaspaProviderInfo, provider: KaspaPro
  * dApp SIDE — register `onAnnounce` (fires once per announce event, including replays; dedupe by
  * `info.rdns ?? info.uuid` yourself), then request announcements from wallets already present. Keep the
  * subscription alive for the page lifetime to catch late-injecting wallets. Returns an unsubscribe.
- * Malformed announces (missing identity or `requestAccounts`) are dropped, never delivered. No-op
- * outside a window context.
+ *
+ * Two receiver-side safety filters run before an announce reaches `onAnnounce`:
+ *   • Malformed announces (missing `uuid`/`name`, or no `requestAccounts`) are dropped, never delivered.
+ *   • A non-`data:` `icon` (a remote-URL tracking/spoofing vector, SPEC §8) is STRIPPED to `''` — the
+ *     wallet is still surfaced, just without the unsafe icon. An absent or valid `data:` icon passes
+ *     through untouched (the announce stays the wallet's original frozen object).
+ *
+ * NEITHER filter authenticates the announcer: any page script can announce (SPEC §8), so treat a provider
+ * as untrusted until the user explicitly connects — that connect gesture is the trust boundary, not this
+ * handshake. No-op outside a window context.
  */
 declare function requestKaspaWallets(onAnnounce: (detail: KaspaProviderDetail) => void): () => void;
 
-export { KASPA_ANNOUNCE_PROVIDER_EVENT, KASPA_NETWORKS, KASPA_REQUEST_PROVIDER_EVENT, type KaspaNetworkId, type KaspaProvider, type KaspaProviderDetail, type KaspaProviderInfo, type KaspaSignInput, announceKaspaWallet, requestKaspaWallets };
+export { KASPA_ANNOUNCE_PROVIDER_EVENT, KASPA_NETWORKS, KASPA_REQUEST_PROVIDER_EVENT, KIP12_ERRORS, type KaspaNetworkId, type KaspaProvider, type KaspaProviderDetail, type KaspaProviderEvent, type KaspaProviderEventMap, type KaspaProviderInfo, type KaspaRequestMap, type KaspaRequestMethod, type KaspaSignInput, type KaspaSignPsktArg, type KaspaSimpleTransfer, type Kip12Error, announceKaspaWallet, normalizeKaspaNetworkId, requestKaspaWallets };

package/dist/index.js

@@ -1,12 +1,23 @@
 // src/index.ts
 var KASPA_NETWORKS = {
-  MAINNET: "kaspa_mainnet",
-  TESTNET_10: "kaspa_testnet_10",
-  TESTNET_11: "kaspa_testnet_11",
-  DEVNET: "kaspa_devnet"
+  MAINNET: "mainnet",
+  TESTNET_10: "testnet-10",
+  TESTNET_11: "testnet-11",
+  DEVNET: "devnet"
+};
+var normalizeKaspaNetworkId = (id) => id.startsWith("kaspa_") ? id.slice("kaspa_".length).replace(/_/g, "-") : id;
+var KIP12_ERRORS = {
+  /** The user rejected the request. */
+  USER_REJECTED: 4001,
+  /** The origin is not authorized (call `requestAccounts` first). */
+  UNAUTHORIZED: 4100,
+  /** The wallet does not support the requested method. */
+  UNSUPPORTED_METHOD: 4200,
+  /** The wallet is locked or unavailable. */
+  WALLET_UNAVAILABLE: 4900
 };
 var KASPA_REQUEST_PROVIDER_EVENT = "kaspa:requestProvider";
-var KASPA_ANNOUNCE_PROVIDER_EVENT = "kaspa:announceProvider";
+var KASPA_ANNOUNCE_PROVIDER_EVENT = "kaspa:provider";
 function announceKaspaWallet(info, provider) {
   if (typeof window === "undefined") return () => {
   };
@@ -16,6 +27,7 @@ function announceKaspaWallet(info, provider) {
   announce();
   return () => window.removeEventListener(KASPA_REQUEST_PROVIDER_EVENT, announce);
 }
+var isSafeIcon = (icon) => typeof icon === "string" && /^data:/i.test(icon.trim());
 function requestKaspaWallets(onAnnounce) {
   if (typeof window === "undefined") return () => {
   };
@@ -23,6 +35,10 @@ function requestKaspaWallets(onAnnounce) {
     const detail = e.detail;
     if (!detail?.info?.uuid || !detail?.info?.name) return;
     if (typeof detail.provider?.requestAccounts !== "function") return;
+    if (detail.info.icon != null && !isSafeIcon(detail.info.icon)) {
+      onAnnounce({ info: { ...detail.info, icon: "" }, provider: detail.provider });
+      return;
+    }
     onAnnounce(detail);
   };
   window.addEventListener(KASPA_ANNOUNCE_PROVIDER_EVENT, listener);
@@ -33,7 +49,9 @@ export {
   KASPA_ANNOUNCE_PROVIDER_EVENT,
   KASPA_NETWORKS,
   KASPA_REQUEST_PROVIDER_EVENT,
+  KIP12_ERRORS,
   announceKaspaWallet,
+  normalizeKaspaNetworkId,
   requestKaspaWallets
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["// Kaspa Wallet Standard — reference implementation.\n//\n// A PROPOSED standard (see SPEC.md) for how a Kaspa dApp and a Kaspa wallet find and talk to each other,\n// with two parts:\n//   • Part 1 — the provider interface a wallet exposes (accounts, network, signing).\n//   • Part 2 — an EIP-6963-style discovery handshake so a dApp finds every present wallet with zero\n//     per-wallet code, and any future wallet self-registers by dispatching one event.\n//\n// This package has ZERO runtime dependencies and is safe to import in Node (all browser access is guarded).\n// The wire contract — the two event names and the existing fields below — is FROZEN: it never changes.\n// Evolution happens only by adding new OPTIONAL fields. A wallet written against this file keeps working\n// against every future version.\n\n// ============================================================================================\n// Part 1 — Provider interface\n// ============================================================================================\n\n/** Canonical network ids used by `getNetwork()` / `switchNetwork()`. String literals are the contract;\n *  this object is a convenience so integrators don't hand-type them. */\nexport const KASPA_NETWORKS = {\n  MAINNET: 'kaspa_mainnet',\n  TESTNET_10: 'kaspa_testnet_10',\n  TESTNET_11: 'kaspa_testnet_11',\n  DEVNET: 'kaspa_devnet',\n} as const;\n\nexport type KaspaNetworkId = (typeof KASPA_NETWORKS)[keyof typeof KASPA_NETWORKS];\n\n/** Identity a wallet announces about itself. `name`/`icon` are DISPLAY hints — never trust signals. */\nexport type KaspaProviderInfo = {\n  /** UUIDv4, freshly generated per page load — instance identity, used only for dedupe. */\n  uuid: string;\n  /** Human-readable wallet name shown in pickers, e.g. \"Kastle\". */\n  name: string;\n  /** Wallet icon as a `data:` URI (SVG/PNG). dApps should refuse to render remote URLs. */\n  icon: string;\n  /** Reverse-DNS identifier, e.g. \"com.kasware\" — STABLE across page loads and versions. Strongly\n   *  recommended: it is what lets a dApp silently restore a session with your wallet after a reload. */\n  rdns?: string;\n};\n\n/** One input a wallet is asked to sign, by position. `sighashType` 1 = SIGHASH_ALL (the only value\n *  KRON uses today); a wallet MUST refuse a type it does not implement rather than guess. */\nexport type KaspaSignInput = { index: number; sighashType: number };\n\n/**\n * The raw provider surface a wallet exposes. Deliberately shaped like the widely-deployed injected APIs\n * (KasWare's `window.kasware`) so an existing wallet can usually announce its injected object as-is.\n *\n * Only `requestAccounts` is MANDATORY. Everything else is OPTIONAL and MUST be capability-checked by the\n * dApp (`typeof provider.signPskt === 'function'`) — a dApp degrades gracefully (e.g. disables trading)\n * when a method is absent, rather than refusing to list the wallet.\n *\n * FUND-SAFETY RULE (wallet side): `signPskt` MUST sign ONLY the inputs listed in `options.signInputs`,\n * and MUST leave every other input untouched. Kaspa covenant transactions carry pre-authorized inputs\n * that must NOT be re-signed; a signature over an unlisted input, or over the wrong sighash, is a\n * fund-safety bug, not a cosmetic mismatch. See SPEC.md §\"Security considerations\".\n */\nexport interface KaspaProvider {\n  /** Connect: prompt the user if needed; resolve to the authorized address list (active address first). */\n  requestAccounts(): Promise<string[]>;\n  /** Already-authorized accounts WITHOUT prompting (empty array if none) — enables silent session restore. */\n  getAccounts?(): Promise<string[]>;\n  /** Current network id (see {@link KaspaNetworkId}). */\n  getNetwork?(): Promise<string>;\n  switchNetwork?(networkId: string): Promise<void>;\n  /** The active account's public key hex (compressed 33-byte or x-only 32-byte — both accepted). */\n  getPublicKey?(): Promise<string>;\n  /** KIP-5 message signing; resolves to the Schnorr signature hex. */\n  signMessage?(message: string): Promise<string>;\n  /** Sign ONLY the listed inputs of a Kaspa Safe-JSON transaction and return the signed Safe JSON. */\n  signPskt?(arg: { txJsonString: string; options: { signInputs: KaspaSignInput[] } }): Promise<string>;\n  disconnect?(origin?: string): Promise<void>;\n  on?(event: 'accountsChanged' | 'networkChanged', handler: (...args: any[]) => void): void;\n  removeListener?(event: string, handler: (...args: any[]) => void): void;\n}\n\n// ============================================================================================\n// Part 2 — Discovery handshake\n// ============================================================================================\n\n/** Dispatched on `window` by a dApp to ask all present wallets to (re-)announce themselves. */\nexport const KASPA_REQUEST_PROVIDER_EVENT = 'kaspa:requestProvider';\n/** Dispatched on `window` by a wallet; `detail` is a frozen {@link KaspaProviderDetail}. */\nexport const KASPA_ANNOUNCE_PROVIDER_EVENT = 'kaspa:announceProvider';\n\n/** The `detail` of a `kaspa:announceProvider` CustomEvent. */\nexport type KaspaProviderDetail = { info: KaspaProviderInfo; provider: KaspaProvider };\n\n/**\n * WALLET SIDE — call once when your content script loads. Announces immediately AND replays on every\n * `kaspa:requestProvider` (so a dApp that loads after you still finds you). Returns an unsubscribe\n * (rarely needed; e.g. extension teardown). No-op outside a window context.\n */\nexport function announceKaspaWallet(info: KaspaProviderInfo, provider: KaspaProvider): () => void {\n  if (typeof window === 'undefined') return () => {};\n  const detail: KaspaProviderDetail = Object.freeze({ info: Object.freeze({ ...info }), provider });\n  const announce = () =>\n    window.dispatchEvent(new CustomEvent(KASPA_ANNOUNCE_PROVIDER_EVENT, { detail }));\n  window.addEventListener(KASPA_REQUEST_PROVIDER_EVENT, announce);\n  announce();\n  return () => window.removeEventListener(KASPA_REQUEST_PROVIDER_EVENT, announce);\n}\n\n/**\n * dApp SIDE — register `onAnnounce` (fires once per announce event, including replays; dedupe by\n * `info.rdns ?? info.uuid` yourself), then request announcements from wallets already present. Keep the\n * subscription alive for the page lifetime to catch late-injecting wallets. Returns an unsubscribe.\n * Malformed announces (missing identity or `requestAccounts`) are dropped, never delivered. No-op\n * outside a window context.\n */\nexport function requestKaspaWallets(onAnnounce: (detail: KaspaProviderDetail) => void): () => void {\n  if (typeof window === 'undefined') return () => {};\n  const listener = (e: Event) => {\n    const detail = (e as CustomEvent<KaspaProviderDetail>).detail;\n    if (!detail?.info?.uuid || !detail?.info?.name) return;\n    if (typeof detail.provider?.requestAccounts !== 'function') return;\n    onAnnounce(detail);\n  };\n  window.addEventListener(KASPA_ANNOUNCE_PROVIDER_EVENT, listener);\n  window.dispatchEvent(new Event(KASPA_REQUEST_PROVIDER_EVENT));\n  return () => window.removeEventListener(KASPA_ANNOUNCE_PROVIDER_EVENT, listener);\n}\n"],"mappings":";AAmBO,IAAM,iBAAiB;AAAA,EAC5B,SAAS;AAAA,EACT,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,QAAQ;AACV;AA0DO,IAAM,+BAA+B;AAErC,IAAM,gCAAgC;AAUtC,SAAS,oBAAoB,MAAyB,UAAqC;AAChG,MAAI,OAAO,WAAW,YAAa,QAAO,MAAM;AAAA,EAAC;AACjD,QAAM,SAA8B,OAAO,OAAO,EAAE,MAAM,OAAO,OAAO,EAAE,GAAG,KAAK,CAAC,GAAG,SAAS,CAAC;AAChG,QAAM,WAAW,MACf,OAAO,cAAc,IAAI,YAAY,+BAA+B,EAAE,OAAO,CAAC,CAAC;AACjF,SAAO,iBAAiB,8BAA8B,QAAQ;AAC9D,WAAS;AACT,SAAO,MAAM,OAAO,oBAAoB,8BAA8B,QAAQ;AAChF;AASO,SAAS,oBAAoB,YAA+D;AACjG,MAAI,OAAO,WAAW,YAAa,QAAO,MAAM;AAAA,EAAC;AACjD,QAAM,WAAW,CAAC,MAAa;AAC7B,UAAM,SAAU,EAAuC;AACvD,QAAI,CAAC,QAAQ,MAAM,QAAQ,CAAC,QAAQ,MAAM,KAAM;AAChD,QAAI,OAAO,OAAO,UAAU,oBAAoB,WAAY;AAC5D,eAAW,MAAM;AAAA,EACnB;AACA,SAAO,iBAAiB,+BAA+B,QAAQ;AAC/D,SAAO,cAAc,IAAI,MAAM,4BAA4B,CAAC;AAC5D,SAAO,MAAM,OAAO,oBAAoB,+BAA+B,QAAQ;AACjF;","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["// Kaspa Wallet Standard — reference implementation.\n//\n// A PROPOSED standard (see SPEC.md) for how a Kaspa dApp and a Kaspa wallet find and talk to each other,\n// with two parts:\n//   • Part 1 — the provider interface a wallet exposes (accounts, network, signing).\n//   • Part 2 — an EIP-6963-style discovery handshake so a dApp finds every present wallet with zero\n//     per-wallet code, and any future wallet self-registers by dispatching one event.\n//\n// This package has ZERO runtime dependencies and is safe to import in Node (all browser access is guarded).\n//\n// v0.2 — KIP-12. This package is the reference implementation of the revived KIP-12 and speaks ONLY its\n// canonical names: `kaspa:provider` announce, the node's bare network ids (`mainnet`, `testnet-10`),\n// `chainChanged`. The v0.1 names (`kaspa:announceProvider`, `kaspa_mainnet`, `networkChanged`) are gone —\n// a clean break, made while KRON was the only deployed consumer (updated in lockstep). From here the\n// wire contract evolves per KIP-12 itself: add-only fields/methods; breaking = new event name.\n//\n// The type surface below is kept at 1:1 parity with the KIP's formal interfaces (`kip-0012/interfaces.ts`\n// in kaspanet/kips) — same provider methods, `request()` registry, event map, and error codes. The two\n// runtime helpers (announce/request) implement the discovery handshake + receiver-side security filters\n// that the spec describes; a wallet/dApp gets a correct, zero-dependency implementation for free.\n\n// ============================================================================================\n// Part 1 — Provider interface\n// ============================================================================================\n\n/** Canonical network ids used by `getNetwork()` / `switchNetwork()`. String literals are the contract;\n *  this object is a convenience so integrators don't hand-type them. */\nexport const KASPA_NETWORKS = {\n  MAINNET: 'mainnet',\n  TESTNET_10: 'testnet-10',\n  TESTNET_11: 'testnet-11',\n  DEVNET: 'devnet',\n} as const;\n\nexport type KaspaNetworkId = (typeof KASPA_NETWORKS)[keyof typeof KASPA_NETWORKS];\n\n/** Normalize any wallet-reported network id to the canonical KIP-12 form: legacy `kaspa_`-prefixed\n *  variants (`kaspa_mainnet`, `kaspa_testnet_10` — v0.1 of this package, KasWare's injected API) map to\n *  the node's bare ids (`mainnet`, `testnet-10`). Canonical ids pass through unchanged. */\nexport const normalizeKaspaNetworkId = (id: string): string =>\n  id.startsWith('kaspa_') ? id.slice('kaspa_'.length).replace(/_/g, '-') : id;\n\n/** Identity a wallet announces about itself. `name`/`icon` are DISPLAY hints — never trust signals. */\nexport type KaspaProviderInfo = {\n  /** UUIDv4, freshly generated per page load — instance identity, used only for dedupe. */\n  uuid: string;\n  /** Human-readable wallet name shown in pickers, e.g. \"Kastle\". */\n  name: string;\n  /** Wallet icon as a `data:` URI (SVG/PNG) — a DISPLAY hint, never a trust signal. A remote URL is a\n   *  tracking/spoofing vector, so the dApp-side {@link requestKaspaWallets} STRIPS any non-`data:` icon\n   *  (delivers it as `''`) — a dApp can never be handed a remote URL through the handshake. */\n  icon: string;\n  /** Reverse-DNS identifier, e.g. \"com.kasware\" — STABLE across page loads and versions. Strongly\n   *  recommended: it is what lets a dApp silently restore a session with your wallet after a reload. */\n  rdns?: string;\n};\n\n/** One input a wallet is asked to sign, by position. `sighashType` 1 = SIGHASH_ALL (the only value\n *  KRON uses today); a wallet MUST refuse a type it does not implement rather than guess. */\nexport type KaspaSignInput = { index: number; sighashType: number };\n\n/** Argument of {@link KaspaProvider.signPskt}: a Kaspa Safe-JSON transaction plus the explicit list of\n *  inputs to sign. The wallet MUST sign ONLY these inputs and leave the rest untouched (fund-safety). */\nexport interface KaspaSignPsktArg {\n  txJsonString: string;\n  options: { signInputs: KaspaSignInput[] };\n}\n\n/** Simple transfer (SPEC §4.2). Amount is sompi as a base-10 **string** — float KAS is FORBIDDEN in the\n *  wire contract: IEEE-754 doubles cannot represent every sompi value exactly, and a rounding error in an\n *  amount is a fund-safety defect. */\nexport interface KaspaSimpleTransfer {\n  to: string;\n  amountSompi: string;\n}\n\n/** Provider events and their payloads (SPEC §6). */\nexport interface KaspaProviderEventMap {\n  /** The authorized account list changed (switch, revoke). */\n  accountsChanged: string[];\n  /** The wallet switched networks; payload is a network id (see {@link KaspaNetworkId}). */\n  chainChanged: string;\n}\n\nexport type KaspaProviderEvent = keyof KaspaProviderEventMap;\n\n/** Canonical `request()` registry (SPEC §7): every §3 method under a namespaced name, so a\n *  `request()`-only client stays possible. Future KIPs/protocols extend this map via declaration\n *  merging; wallets serve vendor methods under their own namespace (e.g. `\"rift:…\"`). */\nexport interface KaspaRequestMap {\n  'kaspa:requestAccounts': { args: []; result: string[] };\n  'kaspa:getAccounts': { args: []; result: string[] };\n  'kaspa:getNetwork': { args: []; result: string };\n  'kaspa:switchNetwork': { args: [networkId: string]; result: void };\n  'kaspa:getPublicKey': { args: []; result: string };\n  'kaspa:signMessage': { args: [message: string]; result: string };\n  'kaspa:signPskt': { args: [arg: KaspaSignPsktArg]; result: string };\n  'kaspa:sendTransaction': { args: [tx: KaspaSimpleTransfer]; result: string };\n  'kaspa:signPskb': { args: [pskb: string]; result: string };\n  'kaspa:broadcastPskb': { args: [pskb: string]; result: string[] };\n  'kaspa:disconnect': { args: [origin?: string]; result: void };\n}\n\nexport type KaspaRequestMethod = keyof KaspaRequestMap;\n\n/** Standard rejection codes (SPEC §8, mirroring EIP-1193 for developer familiarity). */\nexport const KIP12_ERRORS = {\n  /** The user rejected the request. */\n  USER_REJECTED: 4001,\n  /** The origin is not authorized (call `requestAccounts` first). */\n  UNAUTHORIZED: 4100,\n  /** The wallet does not support the requested method. */\n  UNSUPPORTED_METHOD: 4200,\n  /** The wallet is locked or unavailable. */\n  WALLET_UNAVAILABLE: 4900,\n} as const;\n\nexport interface Kip12Error {\n  message: string;\n  code?: number | string;\n  details?: unknown;\n}\n\n/**\n * The raw provider surface a wallet exposes. Deliberately shaped like the widely-deployed injected APIs\n * (KasWare's `window.kasware`) so an existing wallet can usually announce its injected object as-is.\n *\n * Only `requestAccounts` is MANDATORY. Everything else is OPTIONAL and MUST be capability-checked by the\n * dApp (`typeof provider.signPskt === 'function'`) — a dApp degrades gracefully (e.g. disables trading)\n * when a method is absent, rather than refusing to list the wallet.\n *\n * FUND-SAFETY RULE (wallet side): `signPskt` MUST sign ONLY the inputs listed in `options.signInputs`,\n * and MUST leave every other input untouched. Kaspa covenant transactions carry pre-authorized inputs\n * that must NOT be re-signed; a signature over an unlisted input, or over the wrong sighash, is a\n * fund-safety bug, not a cosmetic mismatch. See SPEC.md §\"Security considerations\".\n */\nexport interface KaspaProvider {\n  /** Connect: prompt the user if needed; resolve to the authorized address list (active address first). */\n  requestAccounts(): Promise<string[]>;\n  /** Already-authorized accounts WITHOUT prompting (empty array if none) — enables silent session restore. */\n  getAccounts?(): Promise<string[]>;\n  /** Current network id (see {@link KaspaNetworkId}). */\n  getNetwork?(): Promise<string>;\n  switchNetwork?(networkId: string): Promise<void>;\n  /** The active account's public key hex (compressed 33-byte or x-only 32-byte — both accepted). */\n  getPublicKey?(): Promise<string>;\n  /** KIP-5 message signing; resolves to the Schnorr signature hex. */\n  signMessage?(message: string): Promise<string>;\n  /** Sign ONLY the listed inputs of a Kaspa Safe-JSON transaction and return the signed Safe JSON —\n   *  the covenant-grade signing primitive (fund-safety rules apply). */\n  signPskt?(arg: KaspaSignPsktArg): Promise<string>;\n  /** Simple transfer (SPEC §4.2); resolves to the transaction id. */\n  sendTransaction?(tx: KaspaSimpleTransfer): Promise<string>;\n  /** Sign a PSKB bundle (SPEC §4.3); the per-input discipline of {@link signPskt} applies. */\n  signPskb?(pskb: string): Promise<string>;\n  /** Broadcast a signed PSKB; resolves to transaction ids. */\n  broadcastPskb?(pskb: string): Promise<string[]>;\n  disconnect?(origin?: string): Promise<void>;\n  /** Subscribe to a provider event; the handler payload is inferred from the event\n   *  ({@link KaspaProviderEventMap}). `chainChanged` is the KIP-12 network-change event. */\n  on?<E extends KaspaProviderEvent>(event: E, handler: (payload: KaspaProviderEventMap[E]) => void): void;\n  removeListener?<E extends KaspaProviderEvent>(event: E, handler: (payload: KaspaProviderEventMap[E]) => void): void;\n  /** Typed protocol-extension escape hatch (SPEC §7). Extends the surface, never the privileges — a\n   *  method served here is still subject to the authorization gate and fund-safety rules. An unknown\n   *  method MUST reject with code 4200 ({@link KIP12_ERRORS}). */\n  request?<M extends KaspaRequestMethod>(\n    method: M,\n    args: KaspaRequestMap[M]['args'],\n  ): Promise<KaspaRequestMap[M]['result']>;\n}\n\n// ============================================================================================\n// Part 2 — Discovery handshake\n// ============================================================================================\n\n/** Dispatched on `window` by a dApp to ask all present wallets to (re-)announce themselves. */\nexport const KASPA_REQUEST_PROVIDER_EVENT = 'kaspa:requestProvider';\n/** Dispatched on `window` by a wallet; `detail` is a frozen {@link KaspaProviderDetail}.\n *  KIP-12 canonical name. */\nexport const KASPA_ANNOUNCE_PROVIDER_EVENT = 'kaspa:provider';\n\n/** The `detail` of a `kaspa:announceProvider` CustomEvent. */\nexport type KaspaProviderDetail = { info: KaspaProviderInfo; provider: KaspaProvider };\n\n/**\n * WALLET SIDE — call once when your content script loads. Announces immediately AND replays on every\n * `kaspa:requestProvider` (so a dApp that loads after you still finds you). Returns an unsubscribe\n * (rarely needed; e.g. extension teardown). No-op outside a window context.\n */\nexport function announceKaspaWallet(info: KaspaProviderInfo, provider: KaspaProvider): () => void {\n  if (typeof window === 'undefined') return () => {};\n  const detail: KaspaProviderDetail = Object.freeze({ info: Object.freeze({ ...info }), provider });\n  const announce = () =>\n    window.dispatchEvent(new CustomEvent(KASPA_ANNOUNCE_PROVIDER_EVENT, { detail }));\n  window.addEventListener(KASPA_REQUEST_PROVIDER_EVENT, announce);\n  announce();\n  return () => window.removeEventListener(KASPA_REQUEST_PROVIDER_EVENT, announce);\n}\n\n/** An icon is safe to render only as an inline `data:` URI. A remote URL is a tracking/spoofing vector\n *  (SPEC §8), so the dApp-side handshake refuses it. */\nconst isSafeIcon = (icon: unknown): icon is string => typeof icon === 'string' && /^data:/i.test(icon.trim());\n\n/**\n * dApp SIDE — register `onAnnounce` (fires once per announce event, including replays; dedupe by\n * `info.rdns ?? info.uuid` yourself), then request announcements from wallets already present. Keep the\n * subscription alive for the page lifetime to catch late-injecting wallets. Returns an unsubscribe.\n *\n * Two receiver-side safety filters run before an announce reaches `onAnnounce`:\n *   • Malformed announces (missing `uuid`/`name`, or no `requestAccounts`) are dropped, never delivered.\n *   • A non-`data:` `icon` (a remote-URL tracking/spoofing vector, SPEC §8) is STRIPPED to `''` — the\n *     wallet is still surfaced, just without the unsafe icon. An absent or valid `data:` icon passes\n *     through untouched (the announce stays the wallet's original frozen object).\n *\n * NEITHER filter authenticates the announcer: any page script can announce (SPEC §8), so treat a provider\n * as untrusted until the user explicitly connects — that connect gesture is the trust boundary, not this\n * handshake. No-op outside a window context.\n */\nexport function requestKaspaWallets(onAnnounce: (detail: KaspaProviderDetail) => void): () => void {\n  if (typeof window === 'undefined') return () => {};\n  const listener = (e: Event) => {\n    const detail = (e as CustomEvent<KaspaProviderDetail>).detail;\n    if (!detail?.info?.uuid || !detail?.info?.name) return;\n    if (typeof detail.provider?.requestAccounts !== 'function') return;\n    if (detail.info.icon != null && !isSafeIcon(detail.info.icon)) {\n      // Strip the unsafe icon but keep the wallet: deliver a sanitized copy; the wallet's frozen\n      // original is left untouched (a valid/absent icon skips this and passes through frozen).\n      onAnnounce({ info: { ...detail.info, icon: '' }, provider: detail.provider });\n      return;\n    }\n    onAnnounce(detail);\n  };\n  window.addEventListener(KASPA_ANNOUNCE_PROVIDER_EVENT, listener);\n  window.dispatchEvent(new Event(KASPA_REQUEST_PROVIDER_EVENT));\n  return () => window.removeEventListener(KASPA_ANNOUNCE_PROVIDER_EVENT, listener);\n}\n"],"mappings":";AA2BO,IAAM,iBAAiB;AAAA,EAC5B,SAAS;AAAA,EACT,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,QAAQ;AACV;AAOO,IAAM,0BAA0B,CAAC,OACtC,GAAG,WAAW,QAAQ,IAAI,GAAG,MAAM,SAAS,MAAM,EAAE,QAAQ,MAAM,GAAG,IAAI;AAkEpE,IAAM,eAAe;AAAA;AAAA,EAE1B,eAAe;AAAA;AAAA,EAEf,cAAc;AAAA;AAAA,EAEd,oBAAoB;AAAA;AAAA,EAEpB,oBAAoB;AACtB;AA6DO,IAAM,+BAA+B;AAGrC,IAAM,gCAAgC;AAUtC,SAAS,oBAAoB,MAAyB,UAAqC;AAChG,MAAI,OAAO,WAAW,YAAa,QAAO,MAAM;AAAA,EAAC;AACjD,QAAM,SAA8B,OAAO,OAAO,EAAE,MAAM,OAAO,OAAO,EAAE,GAAG,KAAK,CAAC,GAAG,SAAS,CAAC;AAChG,QAAM,WAAW,MACf,OAAO,cAAc,IAAI,YAAY,+BAA+B,EAAE,OAAO,CAAC,CAAC;AACjF,SAAO,iBAAiB,8BAA8B,QAAQ;AAC9D,WAAS;AACT,SAAO,MAAM,OAAO,oBAAoB,8BAA8B,QAAQ;AAChF;AAIA,IAAM,aAAa,CAAC,SAAkC,OAAO,SAAS,YAAY,UAAU,KAAK,KAAK,KAAK,CAAC;AAiBrG,SAAS,oBAAoB,YAA+D;AACjG,MAAI,OAAO,WAAW,YAAa,QAAO,MAAM;AAAA,EAAC;AACjD,QAAM,WAAW,CAAC,MAAa;AAC7B,UAAM,SAAU,EAAuC;AACvD,QAAI,CAAC,QAAQ,MAAM,QAAQ,CAAC,QAAQ,MAAM,KAAM;AAChD,QAAI,OAAO,OAAO,UAAU,oBAAoB,WAAY;AAC5D,QAAI,OAAO,KAAK,QAAQ,QAAQ,CAAC,WAAW,OAAO,KAAK,IAAI,GAAG;AAG7D,iBAAW,EAAE,MAAM,EAAE,GAAG,OAAO,MAAM,MAAM,GAAG,GAAG,UAAU,OAAO,SAAS,CAAC;AAC5E;AAAA,IACF;AACA,eAAW,MAAM;AAAA,EACnB;AACA,SAAO,iBAAiB,+BAA+B,QAAQ;AAC/D,SAAO,cAAc,IAAI,MAAM,4BAA4B,CAAC;AAC5D,SAAO,MAAM,OAAO,oBAAoB,+BAA+B,QAAQ;AACjF;","names":[]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kaspa-wallet-standard",
-  "version": "0.1.0",
-  "description": "A proposed standard for dApp↔wallet interoperability on Kaspa: a provider interface plus an EIP-6963-style discovery handshake so any wallet can announce itself to any dApp. Zero dependencies.",
+  "version": "0.2.0",
+  "description": "A proposed standard for dApp\u2194wallet interoperability on Kaspa: a provider interface plus an EIP-6963-style discovery handshake so any wallet can announce itself to any dApp. Zero dependencies.",
   "license": "MIT",
   "author": "Shawn Pearce",
   "type": "module",