@partylayer/provider 0.1.6 → 0.2.0

package/README.md

@@ -42,12 +42,15 @@ npm install @partylayer/provider
 ```typescript
 import { PartyLayerProvider, discoverProviders } from '@partylayer/provider';
 
-// Discover injected CIP-0103 wallet providers
-const wallets = discoverProviders();
+// Discover CIP-0103 wallets: the synchronous window.canton scan PLUS the
+// canton:announceProvider handshake (async), merged + deduped by provider id.
+const wallets = await discoverProviders();
 
 // Create provider with first discovered wallet
 const provider = new PartyLayerProvider({ walletProvider: wallets[0] });
 
+// (For the synchronous window.canton-only scan, use discoverInjectedProviders().)
+
 // Connect
 const result = await provider.request({ method: 'connect' });
 

package/dist/index.d.mts

@@ -21,6 +21,8 @@ interface DiscoveredProvider {
     isAsync?: boolean;
     /** Display name (if discoverable from status) */
     name?: string;
+    /** Icon (data: URI or URL) — populated for announce-discovered wallets. */
+    icon?: string;
 }
 /**
  * Check if an object implements the CIP-0103 Provider interface.
@@ -47,6 +49,54 @@ declare function discoverInjectedProviders(): DiscoveredProvider[];
  * @param timeoutMs - Maximum wait time (default 3000ms)
  */
 declare function waitForProvider(id: string, timeoutMs?: number): Promise<DiscoveredProvider | null>;
+/** Metadata carried by a `canton:announceProvider` event. */
+interface AnnouncedWallet {
+    /** Stable provider id (extension id), e.g. "ldmoh…" for Send. */
+    id: string;
+    /** Display name. */
+    name?: string;
+    /** Icon (data: URI or URL). */
+    icon?: string;
+    /** Routing key for the extension postMessage channel. */
+    target?: string;
+}
+interface AnnounceDiscoveryOptions {
+    /** How long to collect announce replies after the request (ms). Default 300. */
+    timeoutMs?: number;
+    /**
+     * Build a CIP-0103 provider from an announced wallet. Defaults to the
+     * self-contained `createExtensionChannelProvider` (splice postMessage over
+     * the `target` channel). Injectable so apps can substitute the official
+     * `@canton-network/dapp-sdk` `ExtensionAdapter`, and tests a mock.
+     */
+    createProvider?: (announced: AnnouncedWallet) => CIP0103Provider | Promise<CIP0103Provider>;
+}
+/**
+ * Discover wallets that advertise via `canton:announceProvider` (EIP-6963-style).
+ *
+ * Works regardless of who owns `window.canton` — this is how Send (and
+ * Console-via-announce) are found. Each result is a working CIP-0103 provider.
+ * Announce replies are deduped by id within a single call.
+ */
+declare function discoverAnnouncedProviders(options?: AnnounceDiscoveryOptions): Promise<DiscoveredProvider[]>;
+/**
+ * Discover ALL CIP-0103 wallets: the synchronous `window.canton` scan PLUS the
+ * `canton:announceProvider` handshake, MERGED and deduped by stable provider id.
+ *
+ * Dedup keys:
+ *   - INJECTED entries: resolved via {@link resolveInjectedKey} (sync id →
+ *     capped read-only status() probe → path id). Resolved in PARALLEL.
+ *   - ANNOUNCE entries: their `d.id` (== announce id == target == the wallet's
+ *     `provider.id`). NOT status-probed — an offline announce wallet (e.g. Send)
+ *     would otherwise hang up to the channel timeout.
+ *
+ * INJECTED entries are processed FIRST so the direct `window.canton` provider
+ * wins over the announce postMessage shim for a wallet reachable both ways
+ * (e.g. Console announces AND owns `window.canton` → appears exactly once).
+ *
+ * Backward-compatible superset of `discoverInjectedProviders()` (left unchanged).
+ */
+declare function discoverProviders(options?: AnnounceDiscoveryOptions): Promise<DiscoveredProvider[]>;
 
 /**
  * PartyLayerProvider — CIP-0103 Native Provider Implementation
@@ -261,6 +311,38 @@ declare function toProviderRpcError(err: unknown): ProviderRpcError;
  */
 declare function toPartyLayerError(err: ProviderRpcError): PartyLayerError;
 
+/**
+ * Extension target-channel CIP-0103 provider.
+ *
+ * Builds a working CIP-0103 provider for a wallet discovered via
+ * `canton:announceProvider` (see discovery.ts). Announce wallets route requests
+ * over the splice-wallet postMessage protocol — the dApp posts a
+ * `SPLICE_WALLET_REQUEST` on `window` and the extension replies with a
+ * `SPLICE_WALLET_RESPONSE`, correlated by JSON-RPC id and routed by `target`.
+ *
+ * This is a self-contained, dependency-free implementation of that wire
+ * protocol. We deliberately do NOT depend on `@canton-network/dapp-sdk`'s
+ * `ExtensionAdapter`: its single bundled entry statically imports
+ * `@walletconnect/sign-client` (an optional peer used only by its
+ * WalletConnectAdapter), which is not installed and breaks every downstream
+ * webpack/Next build that pulls `@partylayer/provider` into its graph
+ * (confirmed against the live demo's `next build`). The protocol constants and
+ * message shapes below mirror `@canton-network/core-types` (`WalletEvent`,
+ * `SpliceMessage`) verbatim, so behaviour matches the official adapter.
+ */
+
+interface ExtensionChannelOptions {
+    /** Routing key (announce `target`) included on every request message. */
+    target?: string;
+    /** Per-request timeout in ms. Default 30000. */
+    timeoutMs?: number;
+}
+/**
+ * Create a CIP-0103 provider that talks the splice-wallet postMessage protocol
+ * over the page `window`, routed by `target`.
+ */
+declare function createExtensionChannelProvider(options?: ExtensionChannelOptions): CIP0103Provider;
+
 /**
  * Async Wallet Handling
  *
@@ -386,4 +468,4 @@ declare class MethodRouter {
     private registerDefaults;
 }
 
-export { type AsyncConnectOptions, type AsyncPrepareExecuteOptions, CANTON_NETWORKS, CIP0103EventBus, type DiscoveredProvider, JSON_RPC_ERRORS, type MethodHandler, MethodRouter, PartyLayerProvider, type PartyLayerProviderOptions, ProviderRpcError, RPC_ERRORS, chainDisconnected, createProviderBridge, disconnected, discoverInjectedProviders, fromCAIP2Network, handleAsyncConnect, handleAsyncPrepareExecute, internalError, invalidParams, isCIP0103Provider, isValidCAIP2, methodNotFound, resourceNotFound, resourceUnavailable, toCAIP2Network, toPartyLayerError, toProviderRpcError, transactionRejected, unauthorized, unsupportedMethod, userRejected, waitForProvider };
+export { type AnnounceDiscoveryOptions, type AnnouncedWallet, type AsyncConnectOptions, type AsyncPrepareExecuteOptions, type BridgeableClient, CANTON_NETWORKS, CIP0103EventBus, type DiscoveredProvider, type ExtensionChannelOptions, JSON_RPC_ERRORS, type MethodHandler, MethodRouter, PartyLayerProvider, type PartyLayerProviderOptions, ProviderRpcError, RPC_ERRORS, chainDisconnected, createExtensionChannelProvider, createProviderBridge, disconnected, discoverAnnouncedProviders, discoverInjectedProviders, discoverProviders, fromCAIP2Network, handleAsyncConnect, handleAsyncPrepareExecute, internalError, invalidParams, isCIP0103Provider, isValidCAIP2, methodNotFound, resourceNotFound, resourceUnavailable, toCAIP2Network, toPartyLayerError, toProviderRpcError, transactionRejected, unauthorized, unsupportedMethod, userRejected, waitForProvider };

package/dist/index.d.ts

@@ -21,6 +21,8 @@ interface DiscoveredProvider {
     isAsync?: boolean;
     /** Display name (if discoverable from status) */
     name?: string;
+    /** Icon (data: URI or URL) — populated for announce-discovered wallets. */
+    icon?: string;
 }
 /**
  * Check if an object implements the CIP-0103 Provider interface.
@@ -47,6 +49,54 @@ declare function discoverInjectedProviders(): DiscoveredProvider[];
  * @param timeoutMs - Maximum wait time (default 3000ms)
  */
 declare function waitForProvider(id: string, timeoutMs?: number): Promise<DiscoveredProvider | null>;
+/** Metadata carried by a `canton:announceProvider` event. */
+interface AnnouncedWallet {
+    /** Stable provider id (extension id), e.g. "ldmoh…" for Send. */
+    id: string;
+    /** Display name. */
+    name?: string;
+    /** Icon (data: URI or URL). */
+    icon?: string;
+    /** Routing key for the extension postMessage channel. */
+    target?: string;
+}
+interface AnnounceDiscoveryOptions {
+    /** How long to collect announce replies after the request (ms). Default 300. */
+    timeoutMs?: number;
+    /**
+     * Build a CIP-0103 provider from an announced wallet. Defaults to the
+     * self-contained `createExtensionChannelProvider` (splice postMessage over
+     * the `target` channel). Injectable so apps can substitute the official
+     * `@canton-network/dapp-sdk` `ExtensionAdapter`, and tests a mock.
+     */
+    createProvider?: (announced: AnnouncedWallet) => CIP0103Provider | Promise<CIP0103Provider>;
+}
+/**
+ * Discover wallets that advertise via `canton:announceProvider` (EIP-6963-style).
+ *
+ * Works regardless of who owns `window.canton` — this is how Send (and
+ * Console-via-announce) are found. Each result is a working CIP-0103 provider.
+ * Announce replies are deduped by id within a single call.
+ */
+declare function discoverAnnouncedProviders(options?: AnnounceDiscoveryOptions): Promise<DiscoveredProvider[]>;
+/**
+ * Discover ALL CIP-0103 wallets: the synchronous `window.canton` scan PLUS the
+ * `canton:announceProvider` handshake, MERGED and deduped by stable provider id.
+ *
+ * Dedup keys:
+ *   - INJECTED entries: resolved via {@link resolveInjectedKey} (sync id →
+ *     capped read-only status() probe → path id). Resolved in PARALLEL.
+ *   - ANNOUNCE entries: their `d.id` (== announce id == target == the wallet's
+ *     `provider.id`). NOT status-probed — an offline announce wallet (e.g. Send)
+ *     would otherwise hang up to the channel timeout.
+ *
+ * INJECTED entries are processed FIRST so the direct `window.canton` provider
+ * wins over the announce postMessage shim for a wallet reachable both ways
+ * (e.g. Console announces AND owns `window.canton` → appears exactly once).
+ *
+ * Backward-compatible superset of `discoverInjectedProviders()` (left unchanged).
+ */
+declare function discoverProviders(options?: AnnounceDiscoveryOptions): Promise<DiscoveredProvider[]>;
 
 /**
  * PartyLayerProvider — CIP-0103 Native Provider Implementation
@@ -261,6 +311,38 @@ declare function toProviderRpcError(err: unknown): ProviderRpcError;
  */
 declare function toPartyLayerError(err: ProviderRpcError): PartyLayerError;
 
+/**
+ * Extension target-channel CIP-0103 provider.
+ *
+ * Builds a working CIP-0103 provider for a wallet discovered via
+ * `canton:announceProvider` (see discovery.ts). Announce wallets route requests
+ * over the splice-wallet postMessage protocol — the dApp posts a
+ * `SPLICE_WALLET_REQUEST` on `window` and the extension replies with a
+ * `SPLICE_WALLET_RESPONSE`, correlated by JSON-RPC id and routed by `target`.
+ *
+ * This is a self-contained, dependency-free implementation of that wire
+ * protocol. We deliberately do NOT depend on `@canton-network/dapp-sdk`'s
+ * `ExtensionAdapter`: its single bundled entry statically imports
+ * `@walletconnect/sign-client` (an optional peer used only by its
+ * WalletConnectAdapter), which is not installed and breaks every downstream
+ * webpack/Next build that pulls `@partylayer/provider` into its graph
+ * (confirmed against the live demo's `next build`). The protocol constants and
+ * message shapes below mirror `@canton-network/core-types` (`WalletEvent`,
+ * `SpliceMessage`) verbatim, so behaviour matches the official adapter.
+ */
+
+interface ExtensionChannelOptions {
+    /** Routing key (announce `target`) included on every request message. */
+    target?: string;
+    /** Per-request timeout in ms. Default 30000. */
+    timeoutMs?: number;
+}
+/**
+ * Create a CIP-0103 provider that talks the splice-wallet postMessage protocol
+ * over the page `window`, routed by `target`.
+ */
+declare function createExtensionChannelProvider(options?: ExtensionChannelOptions): CIP0103Provider;
+
 /**
  * Async Wallet Handling
  *
@@ -386,4 +468,4 @@ declare class MethodRouter {
     private registerDefaults;
 }
 
-export { type AsyncConnectOptions, type AsyncPrepareExecuteOptions, CANTON_NETWORKS, CIP0103EventBus, type DiscoveredProvider, JSON_RPC_ERRORS, type MethodHandler, MethodRouter, PartyLayerProvider, type PartyLayerProviderOptions, ProviderRpcError, RPC_ERRORS, chainDisconnected, createProviderBridge, disconnected, discoverInjectedProviders, fromCAIP2Network, handleAsyncConnect, handleAsyncPrepareExecute, internalError, invalidParams, isCIP0103Provider, isValidCAIP2, methodNotFound, resourceNotFound, resourceUnavailable, toCAIP2Network, toPartyLayerError, toProviderRpcError, transactionRejected, unauthorized, unsupportedMethod, userRejected, waitForProvider };
+export { type AnnounceDiscoveryOptions, type AnnouncedWallet, type AsyncConnectOptions, type AsyncPrepareExecuteOptions, type BridgeableClient, CANTON_NETWORKS, CIP0103EventBus, type DiscoveredProvider, type ExtensionChannelOptions, JSON_RPC_ERRORS, type MethodHandler, MethodRouter, PartyLayerProvider, type PartyLayerProviderOptions, ProviderRpcError, RPC_ERRORS, chainDisconnected, createExtensionChannelProvider, createProviderBridge, disconnected, discoverAnnouncedProviders, discoverInjectedProviders, discoverProviders, fromCAIP2Network, handleAsyncConnect, handleAsyncPrepareExecute, internalError, invalidParams, isCIP0103Provider, isValidCAIP2, methodNotFound, resourceNotFound, resourceUnavailable, toCAIP2Network, toPartyLayerError, toProviderRpcError, transactionRejected, unauthorized, unsupportedMethod, userRejected, waitForProvider };

package/dist/index.js

@@ -540,7 +540,7 @@ function isValidCAIP2(networkId) {
 }
 
 // src/bridge.ts
-var PROVIDER_VERSION = "0.1.6" ;
+var PROVIDER_VERSION = "0.2.0" ;
 function createProviderBridge(client) {
   const eventBus = new CIP0103EventBus();
   const pendingEmitted = /* @__PURE__ */ new Set();
@@ -819,6 +819,96 @@ function sessionToAccount(session) {
   };
 }
 
+// src/extension-channel.ts
+var SPLICE_WALLET_REQUEST = "SPLICE_WALLET_REQUEST";
+var SPLICE_WALLET_RESPONSE = "SPLICE_WALLET_RESPONSE";
+var channelSeq = 0;
+function createExtensionChannelProvider(options = {}) {
+  const target = options.target;
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const eventBus = new CIP0103EventBus();
+  const channelId = `pl-${++channelSeq}-${target ?? "ext"}`;
+  let requestSeq = 0;
+  const pending = /* @__PURE__ */ new Map();
+  function onMessage(event) {
+    if (event.source !== window) return;
+    const selfOrigin = typeof window !== "undefined" ? window.location?.origin : void 0;
+    if (selfOrigin && selfOrigin !== "null" && event.origin !== selfOrigin) return;
+    const data = event.data;
+    if (!data || data.type !== SPLICE_WALLET_RESPONSE || !data.response) return;
+    const { id, result, error } = data.response;
+    if (id === void 0 || id === null) return;
+    const entry = pending.get(String(id));
+    if (!entry) return;
+    pending.delete(String(id));
+    clearTimeout(entry.timer);
+    if (error) {
+      entry.reject(
+        new ProviderRpcError(
+          error.message || "Wallet request failed",
+          typeof error.code === "number" ? error.code : JSON_RPC_ERRORS.INTERNAL_ERROR,
+          error.data
+        )
+      );
+    } else {
+      entry.resolve(result);
+    }
+  }
+  if (typeof window !== "undefined") {
+    window.addEventListener("message", onMessage);
+  }
+  function postTargetOrigin() {
+    const origin = typeof window !== "undefined" ? window.location?.origin : void 0;
+    return origin && origin !== "null" ? origin : "*";
+  }
+  const provider = {
+    request(args) {
+      if (typeof window === "undefined") {
+        return Promise.reject(
+          new ProviderRpcError("No window: extension channel unavailable", JSON_RPC_ERRORS.INTERNAL_ERROR)
+        );
+      }
+      const id = `${channelId}-${++requestSeq}`;
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          reject(
+            new ProviderRpcError(
+              `Wallet request "${args.method}" timed out after ${timeoutMs}ms`,
+              JSON_RPC_ERRORS.INTERNAL_ERROR
+            )
+          );
+        }, timeoutMs);
+        pending.set(id, { resolve, reject, timer });
+        const message = {
+          type: SPLICE_WALLET_REQUEST,
+          request: {
+            jsonrpc: "2.0",
+            id,
+            method: args.method,
+            ...args.params !== void 0 ? { params: args.params } : {}
+          },
+          ...target ? { target } : {}
+        };
+        window.postMessage(message, postTargetOrigin());
+      });
+    },
+    on(event, listener) {
+      eventBus.on(event, listener);
+      return provider;
+    },
+    emit(event, ...args) {
+      return eventBus.emit(event, ...args);
+    },
+    removeListener(event, listener) {
+      eventBus.removeListener(event, listener);
+      return provider;
+    }
+  };
+  eventBus.setOwner(provider);
+  return provider;
+}
+
 // src/discovery.ts
 var KNOWN_INJECTION_PATHS = [
   "canton",
@@ -892,6 +982,103 @@ function findById(id) {
     (p) => p.id === id || p.id.endsWith(`.${id}`)
   );
 }
+var CANTON_REQUEST_PROVIDER_EVENT = "canton:requestProvider";
+var CANTON_ANNOUNCE_PROVIDER_EVENT = "canton:announceProvider";
+function defaultAnnounceProvider(announced) {
+  return createExtensionChannelProvider({ target: announced.target });
+}
+async function discoverAnnouncedProviders(options = {}) {
+  if (typeof window === "undefined") return [];
+  const timeoutMs = options.timeoutMs ?? 300;
+  const make = options.createProvider ?? defaultAnnounceProvider;
+  const announced = /* @__PURE__ */ new Map();
+  const onAnnounce = (event) => {
+    const detail = event.detail;
+    if (!detail) return;
+    const rawId = detail.providerId ?? detail.id;
+    if (typeof rawId !== "string" || rawId.length === 0) return;
+    if (announced.has(rawId)) return;
+    announced.set(rawId, {
+      id: rawId,
+      name: typeof detail.name === "string" ? detail.name : void 0,
+      icon: typeof detail.icon === "string" ? detail.icon : void 0,
+      target: typeof detail.target === "string" ? detail.target : void 0
+    });
+  };
+  window.addEventListener(
+    CANTON_ANNOUNCE_PROVIDER_EVENT,
+    onAnnounce
+  );
+  try {
+    window.dispatchEvent(new CustomEvent(CANTON_REQUEST_PROVIDER_EVENT));
+    await new Promise((resolve) => setTimeout(resolve, timeoutMs));
+  } finally {
+    window.removeEventListener(
+      CANTON_ANNOUNCE_PROVIDER_EVENT,
+      onAnnounce
+    );
+  }
+  const results = [];
+  for (const wallet of announced.values()) {
+    let provider;
+    try {
+      provider = await make(wallet);
+    } catch {
+      continue;
+    }
+    if (!isCIP0103Provider(provider)) continue;
+    results.push({
+      id: wallet.id,
+      provider,
+      source: "injected",
+      name: wallet.name,
+      icon: wallet.icon
+    });
+  }
+  return results;
+}
+var INJECTED_ID_PROBE_TIMEOUT_MS = 1500;
+function raceTimeout(promise, ms) {
+  return Promise.race([
+    promise,
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new Error("id-probe timeout")), ms)
+    )
+  ]);
+}
+async function resolveInjectedKey(d) {
+  const sync = d.provider.id;
+  if (typeof sync === "string" && sync.length > 0) return sync;
+  try {
+    const status = await raceTimeout(
+      d.provider.request({ method: "status" }),
+      INJECTED_ID_PROBE_TIMEOUT_MS
+    );
+    const pid = status?.provider?.id;
+    if (typeof pid === "string" && pid.length > 0) return pid;
+  } catch {
+  }
+  return d.id;
+}
+async function discoverProviders(options = {}) {
+  const injected = discoverInjectedProviders();
+  const announcedResults = await discoverAnnouncedProviders(options);
+  const injectedKeys = await Promise.all(injected.map(resolveInjectedKey));
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  injected.forEach((d, i) => {
+    const key = injectedKeys[i];
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push(d);
+  });
+  for (const d of announcedResults) {
+    if (seen.has(d.id)) continue;
+    seen.add(d.id);
+    out.push(d);
+  }
+  return out;
+}
 
 Object.defineProperty(exports, "CIP0103_EVENTS", {
   enumerable: true,
@@ -913,9 +1100,12 @@ exports.PartyLayerProvider = PartyLayerProvider;
 exports.ProviderRpcError = ProviderRpcError;
 exports.RPC_ERRORS = RPC_ERRORS;
 exports.chainDisconnected = chainDisconnected;
+exports.createExtensionChannelProvider = createExtensionChannelProvider;
 exports.createProviderBridge = createProviderBridge;
 exports.disconnected = disconnected;
+exports.discoverAnnouncedProviders = discoverAnnouncedProviders;
 exports.discoverInjectedProviders = discoverInjectedProviders;
+exports.discoverProviders = discoverProviders;
 exports.fromCAIP2Network = fromCAIP2Network;
 exports.handleAsyncConnect = handleAsyncConnect;
 exports.handleAsyncPrepareExecute = handleAsyncPrepareExecute;