@partylayer/sdk 0.2.5 → 0.2.6

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { mapUnknownErrorToPartyLayerError, WalletNotFoundError, capabilityGuard, installGuard, toSessionId, CapabilityNotSupportedError } from '@partylayer/core';
-export { PartyLayerError as CantonConnectError, CapabilityNotSupportedError, InternalError, OriginNotAllowedError, PartyLayerError, RegistryFetchFailedError, RegistrySchemaInvalidError, RegistryVerificationFailedError, SessionExpiredError, TimeoutError, TransportError, UserRejectedError, WalletNotFoundError, WalletNotInstalledError } from '@partylayer/core';
+import { hashForPrivacy, createMetricsPayload, mapUnknownErrorToPartyLayerError, METRICS, WalletNotFoundError, capabilityGuard, installGuard, toSessionId, CapabilityNotSupportedError, errorMetricName } from '@partylayer/core';
+export { PartyLayerError as CantonConnectError, CapabilityNotSupportedError, ENABLEMENT_METRICS, ERROR_METRICS, InternalError, METRICS, OriginNotAllowedError, PartyLayerError, REGISTRY_METRICS, RegistryFetchFailedError, RegistrySchemaInvalidError, RegistryVerificationFailedError, SessionExpiredError, TimeoutError, TransportError, UserRejectedError, WalletNotFoundError, WalletNotInstalledError, errorMetricName } from '@partylayer/core';
 import { RegistryClient } from '@partylayer/registry-client';
 import { ConsoleAdapter } from '@partylayer/adapter-console';
 export { ConsoleAdapter } from '@partylayer/adapter-console';
@@ -7,9 +7,17 @@ import { LoopAdapter } from '@partylayer/adapter-loop';
 export { LoopAdapter } from '@partylayer/adapter-loop';
 import { Cantor8Adapter } from '@partylayer/adapter-cantor8';
 export { Cantor8Adapter } from '@partylayer/adapter-cantor8';
+import { NightlyAdapter } from '@partylayer/adapter-nightly';
+export { NightlyAdapter } from '@partylayer/adapter-nightly';
 export { BronAdapter } from '@partylayer/adapter-bron';
+export { CANTON_NETWORKS, CIP0103EventBus, CIP0103_EVENTS, CIP0103_MANDATORY_METHODS, CIP0103_METHODS, JSON_RPC_ERRORS, PartyLayerProvider, ProviderRpcError, RPC_ERRORS, createProviderBridge, discoverInjectedProviders, fromCAIP2Network, isCIP0103Provider, isValidCAIP2, toCAIP2Network, waitForProvider } from '@partylayer/provider';
 
-// src/client.ts
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/config.ts
 var DEFAULT_REGISTRY_URL = "https://registry.partylayer.xyz";
@@ -168,12 +176,196 @@ function getBuiltinAdapters() {
     // Console Wallet - browser extension
     new LoopAdapter(),
     // 5N Loop - QR code / popup
-    new Cantor8Adapter()
+    new Cantor8Adapter(),
     // Cantor8 - deep link transport
+    new NightlyAdapter()
+    // Nightly - multichain wallet (injected)
   ];
 }
-
-// src/client.ts
+var SDK_VERSION = "0.3.0";
+var MetricsTelemetryAdapter = class {
+  config;
+  metrics = /* @__PURE__ */ new Map();
+  buffer = [];
+  flushTimer = null;
+  appIdHash = null;
+  originHash = null;
+  initialized = false;
+  constructor(config) {
+    this.config = {
+      enabled: config.enabled ?? false,
+      endpoint: config.endpoint,
+      sampleRate: config.sampleRate ?? 1,
+      appId: config.appId,
+      includeOrigin: config.includeOrigin ?? false,
+      batchSize: config.batchSize ?? 10,
+      flushIntervalMs: config.flushIntervalMs ?? 3e4,
+      network: config.network
+    };
+    this.initialize();
+  }
+  /**
+   * Initialize async components (hashing)
+   */
+  async initialize() {
+    if (this.initialized) return;
+    if (this.config.appId) {
+      this.appIdHash = await hashForPrivacy(this.config.appId);
+    }
+    if (this.config.includeOrigin && typeof window !== "undefined") {
+      this.originHash = await hashForPrivacy(window.location.origin);
+    }
+    if (this.config.enabled && this.config.flushIntervalMs) {
+      this.flushTimer = setInterval(() => {
+        this.flush().catch(console.error);
+      }, this.config.flushIntervalMs);
+    }
+    this.initialized = true;
+  }
+  /**
+   * Check if telemetry is enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Track a named event (TelemetryAdapter interface)
+   */
+  track(event, properties) {
+    if (!this.config.enabled) return;
+    const sampleRate = this.config.sampleRate ?? 1;
+    if (sampleRate < 1 && Math.random() >= sampleRate) {
+      return;
+    }
+    const current = this.metrics.get(`event_${event}`) ?? 0;
+    this.metrics.set(`event_${event}`, current + 1);
+    this.bufferEvent({ type: "increment", metric: `event_${event}`, value: 1, timestamp: Date.now() });
+    if (properties) {
+      for (const [key, value] of Object.entries(properties)) {
+        if (typeof value === "number") {
+          this.gauge(`${event}_${key}`, value);
+        }
+      }
+    }
+  }
+  /**
+   * Track an error (TelemetryAdapter interface)
+   */
+  error(error, properties) {
+    if (!this.config.enabled) return;
+    const code = error.code ?? "UNKNOWN";
+    this.increment(`error_${code}`);
+    if (properties) {
+      this.track("error", properties);
+    }
+  }
+  /**
+   * Increment a metric counter
+   */
+  increment(metric, value = 1) {
+    if (!this.config.enabled) return;
+    const sampleRate = this.config.sampleRate ?? 1;
+    if (sampleRate < 1 && Math.random() >= sampleRate) {
+      return;
+    }
+    const current = this.metrics.get(metric) ?? 0;
+    this.metrics.set(metric, current + value);
+    this.bufferEvent({
+      type: "increment",
+      metric,
+      value,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Set a gauge metric value
+   */
+  gauge(metric, value) {
+    if (!this.config.enabled) return;
+    this.metrics.set(metric, value);
+    this.bufferEvent({
+      type: "gauge",
+      metric,
+      value,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Buffer an event for batched sending
+   */
+  bufferEvent(event) {
+    this.buffer.push(event);
+    if (this.config.batchSize && this.buffer.length >= this.config.batchSize) {
+      this.flush().catch(console.error);
+    }
+  }
+  /**
+   * Flush buffered metrics to backend
+   */
+  async flush() {
+    if (!this.config.enabled) return;
+    if (this.metrics.size === 0) return;
+    if (!this.config.endpoint) {
+      this.buffer = [];
+      return;
+    }
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    try {
+      const payload = createMetricsPayload({
+        sdkVersion: SDK_VERSION,
+        network: this.config.network ?? "unknown",
+        metrics: Object.fromEntries(this.metrics),
+        appIdHash: this.appIdHash ?? void 0,
+        originHash: this.originHash ?? void 0
+      });
+      await fetch(this.config.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      this.buffer = [];
+    } catch (error) {
+      console.debug("[PartyLayer Telemetry] Flush failed:", error);
+    }
+  }
+  /**
+   * Get current metrics snapshot (for testing/debugging)
+   */
+  getMetrics() {
+    return Object.fromEntries(this.metrics);
+  }
+  /**
+   * Reset all metrics (for testing)
+   */
+  reset() {
+    this.metrics.clear();
+    this.buffer = [];
+  }
+  /**
+   * Destroy the adapter (cleanup timers)
+   */
+  destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flush().catch(console.error);
+  }
+};
+function isTelemetryConfig(value) {
+  return typeof value === "object" && value !== null && "enabled" in value && typeof value.enabled === "boolean";
+}
+function createTelemetryAdapter(config) {
+  if (!config) return void 0;
+  if (isTelemetryConfig(config)) {
+    return new MetricsTelemetryAdapter(config);
+  }
+  return config;
+}
 var PartyLayerClient = class {
   config;
   adapters = /* @__PURE__ */ new Map();
@@ -198,7 +390,8 @@ var PartyLayerClient = class {
     this.logger = config.logger || new DefaultLogger();
     this.crypto = config.crypto || new DefaultCrypto();
     this.storage = config.storage || new DefaultStorage();
-    this.telemetry = config.telemetry || new DefaultTelemetry();
+    const telemetryAdapter = createTelemetryAdapter(config.telemetry);
+    this.telemetry = telemetryAdapter || new DefaultTelemetry();
     const adaptersToRegister = config.adapters ?? getBuiltinAdapters();
     for (const adapterOrClass of adaptersToRegister) {
       let adapter;
@@ -244,33 +437,49 @@ var PartyLayerClient = class {
    * List available wallets
    */
   async listWallets(filter) {
+    let registryWallets;
     try {
-      const allWalletInfos = await this.registryClient.getWallets();
+      registryWallets = await this.registryClient.getWallets();
       this.updateRegistryStatus();
-      if (filter?.requiredCapabilities) {
-        return allWalletInfos.filter(
-          (walletInfo) => filter.requiredCapabilities.every(
-            (cap) => walletInfo.capabilities.includes(cap)
-          )
-        );
-      }
-      if (!filter?.includeExperimental) {
-        return allWalletInfos.filter((walletInfo) => walletInfo.channel === "stable");
-      }
-      return allWalletInfos;
     } catch (err) {
       this.updateRegistryStatus();
-      const error = mapUnknownErrorToPartyLayerError(err, {
-        phase: "connect"
+      this.logger.warn("Registry fetch failed, using registered adapters only", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      registryWallets = [];
+    }
+    const registryIds = new Set(registryWallets.map((w) => String(w.walletId)));
+    for (const [, adapter] of this.adapters) {
+      if (registryIds.has(String(adapter.walletId))) continue;
+      registryWallets.push({
+        walletId: adapter.walletId,
+        name: adapter.name,
+        website: "",
+        icons: {},
+        capabilities: adapter.getCapabilities(),
+        adapter: { packageName: "builtin", versionRange: "*" },
+        docs: [],
+        networks: [this.config.network || "devnet"],
+        channel: "stable"
       });
-      this.emit("error", { type: "error", error });
-      throw error;
     }
+    if (filter?.requiredCapabilities) {
+      return registryWallets.filter(
+        (walletInfo) => filter.requiredCapabilities.every(
+          (cap) => walletInfo.capabilities.includes(cap)
+        )
+      );
+    }
+    if (!filter?.includeExperimental) {
+      return registryWallets.filter((walletInfo) => walletInfo.channel === "stable");
+    }
+    return registryWallets;
   }
   /**
    * Connect to a wallet
    */
   async connect(options) {
+    this.telemetry?.increment?.(METRICS.WALLET_CONNECT_ATTEMPTS);
     try {
       const wallets = await this.listWallets({
         requiredCapabilities: options?.requiredCapabilities,
@@ -282,31 +491,33 @@ var PartyLayerClient = class {
           (w) => options.allowWallets.includes(w.walletId)
         );
       }
-      if (options?.preferInstalled) {
-        const installedWallets = [];
-        const notInstalledWallets = [];
-        for (const wallet of availableWallets) {
-          const adapter2 = this.adapters.get(wallet.walletId);
-          if (adapter2) {
-            const detect = await adapter2.detectInstalled();
-            if (detect.installed) {
-              installedWallets.push(wallet);
-            } else {
-              notInstalledWallets.push(wallet);
-            }
-          } else {
-            notInstalledWallets.push(wallet);
-          }
-        }
-        availableWallets = [...installedWallets, ...notInstalledWallets];
-      }
       let selectedWallet;
+      let isNativeWallet = false;
       if (options?.walletId) {
-        selectedWallet = availableWallets.find(
+        const found = availableWallets.find(
           (w) => w.walletId === options.walletId
         );
-        if (!selectedWallet) {
-          throw new WalletNotFoundError(String(options.walletId));
+        if (found) {
+          selectedWallet = found;
+        } else {
+          const nativeAdapter = this.adapters.get(options.walletId);
+          if (nativeAdapter) {
+            isNativeWallet = true;
+            selectedWallet = {
+              walletId: options.walletId,
+              name: nativeAdapter.name,
+              website: "",
+              icons: {},
+              capabilities: nativeAdapter.getCapabilities(),
+              adapter: { packageName: "native-cip0103", versionRange: "*" },
+              docs: [],
+              networks: [this.config.network],
+              channel: "stable",
+              metadata: { source: "native-cip0103" }
+            };
+          } else {
+            throw new WalletNotFoundError(String(options.walletId));
+          }
         }
       } else if (availableWallets.length === 0) {
         throw new WalletNotFoundError("No wallets available");
@@ -317,14 +528,22 @@ var PartyLayerClient = class {
       if (!adapter) {
         throw new WalletNotFoundError(String(selectedWallet.walletId));
       }
-      const walletEntry = await this.registryClient.getWalletEntry(String(selectedWallet.walletId));
-      if (walletEntry.originAllowlist && walletEntry.originAllowlist.length > 0) {
-        if (!walletEntry.originAllowlist.includes(this.origin)) {
-          const { OriginNotAllowedError: OriginNotAllowedError2 } = await import('@partylayer/core');
-          throw new OriginNotAllowedError2(
-            this.origin,
-            walletEntry.originAllowlist
-          );
+      if (!isNativeWallet) {
+        try {
+          const walletEntry = await this.registryClient.getWalletEntry(String(selectedWallet.walletId));
+          if (walletEntry.originAllowlist && walletEntry.originAllowlist.length > 0) {
+            if (!walletEntry.originAllowlist.includes(this.origin)) {
+              const { OriginNotAllowedError: OriginNotAllowedError2 } = await import('@partylayer/core');
+              throw new OriginNotAllowedError2(
+                this.origin,
+                walletEntry.originAllowlist
+              );
+            }
+          }
+        } catch (e) {
+          if (!(e instanceof WalletNotFoundError)) {
+            throw e;
+          }
         }
       }
       if (options?.requiredCapabilities) {
@@ -358,6 +577,8 @@ var PartyLayerClient = class {
       await this.persistSession(session);
       this.activeSession = session;
       this.updateRegistryStatus();
+      this.telemetry?.increment?.(METRICS.WALLET_CONNECT_SUCCESS);
+      this.telemetry?.increment?.(METRICS.SESSIONS_CREATED);
       this.emit("session:connected", {
         type: "session:connected",
         session
@@ -517,6 +738,33 @@ var PartyLayerClient = class {
       throw error;
     }
   }
+  /**
+   * Proxy a JSON Ledger API request through the active wallet adapter
+   */
+  async ledgerApi(params) {
+    const session = await this.getActiveSession();
+    if (!session) {
+      throw new Error("No active session");
+    }
+    const adapter = this.adapters.get(session.walletId);
+    if (!adapter || !adapter.ledgerApi) {
+      throw new CapabilityNotSupportedError(
+        session.walletId,
+        "ledgerApi"
+      );
+    }
+    try {
+      const ctx = this.createAdapterContext();
+      return await adapter.ledgerApi(ctx, session, params);
+    } catch (err) {
+      const error = mapUnknownErrorToPartyLayerError(err, {
+        phase: "ledgerApi",
+        walletId: String(session.walletId)
+      });
+      this.emit("error", { type: "error", error });
+      throw error;
+    }
+  }
   /**
    * Subscribe to events
    */
@@ -538,10 +786,36 @@ var PartyLayerClient = class {
       handlers.delete(handler);
     }
   }
+  /**
+   * Get a CIP-0103 Provider backed by this client.
+   *
+   * This bridge routes all request() calls through the existing
+   * PartyLayerClient methods and maps events to CIP-0103 format.
+   *
+   * The bridge implements the full CIP-0103 specification:
+   * - All 10 mandatory methods including `ledgerApi` (when adapter supports it)
+   * - Full transaction lifecycle: pending -> signed -> executed/failed
+   * - All CIP-0103 events: statusChanged, accountsChanged, txChanged, connected
+   *
+   * **Note:** Async wallets (userUrl pattern) are not supported through the
+   * bridge. For async wallet support, use `PartyLayerProvider` directly.
+   *
+   * @returns CIP-0103 compliant Provider
+   */
+  asProvider() {
+    const { createProviderBridge: createProviderBridge2 } = __require("@partylayer/provider");
+    return createProviderBridge2(this);
+  }
   /**
    * Destroy client and cleanup
    */
   destroy() {
+    if (this.telemetry && "destroy" in this.telemetry && typeof this.telemetry.destroy === "function") {
+      this.telemetry.destroy();
+    } else if (this.telemetry?.flush) {
+      this.telemetry.flush().catch(() => {
+      });
+    }
     this.eventHandlers.clear();
     this.activeSession = null;
   }
@@ -595,6 +869,7 @@ var PartyLayerClient = class {
    * Restore session from storage
    */
   async restoreSession() {
+    this.telemetry?.increment?.(METRICS.RESTORE_ATTEMPTS);
     try {
       const encrypted = await this.storage.get("active_session");
       if (!encrypted) {
@@ -619,6 +894,8 @@ var PartyLayerClient = class {
         if (restored) {
           this.activeSession = restored;
           await this.persistSession(restored);
+          this.telemetry?.increment?.(METRICS.SESSIONS_RESTORED);
+          this.telemetry?.increment?.(METRICS.WALLET_CONNECT_SUCCESS);
           this.emit("session:connected", {
             type: "session:connected",
             session: restored
@@ -646,6 +923,14 @@ var PartyLayerClient = class {
   updateRegistryStatus() {
     const status = this.registryClient.getStatus();
     if (status) {
+      if (status.source === "network") {
+        this.telemetry?.increment?.(METRICS.REGISTRY_FETCH);
+      } else if (status.source === "cache") {
+        this.telemetry?.increment?.(METRICS.REGISTRY_CACHE_HIT);
+      }
+      if (status.stale) {
+        this.telemetry?.increment?.(METRICS.REGISTRY_STALE);
+      }
       this.emit("registry:status", {
         type: "registry:status",
         status: {
@@ -671,6 +956,12 @@ var PartyLayerClient = class {
    * Emit event to handlers
    */
   emit(event, payload) {
+    if (event === "error" && "error" in payload) {
+      const error = payload.error;
+      if (error.code) {
+        this.telemetry?.increment?.(errorMetricName(error.code));
+      }
+    }
     const handlers = this.eventHandlers.get(event);
     if (handlers) {
       for (const handler of handlers) {
@@ -687,6 +978,6 @@ function createPartyLayer(config) {
   return new PartyLayerClient(config);
 }
 
-export { PartyLayerClient as CantonConnectClient, DEFAULT_REGISTRY_URL, PartyLayerClient, createPartyLayer as createCantonConnect, createPartyLayer, getBuiltinAdapters };
+export { PartyLayerClient as CantonConnectClient, DEFAULT_REGISTRY_URL, MetricsTelemetryAdapter, PartyLayerClient, createPartyLayer as createCantonConnect, createPartyLayer, createTelemetryAdapter, getBuiltinAdapters, isTelemetryConfig };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map