@partylayer/provider 0.1.7 → 0.2.1

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { PartyLayerError, CIP0103_EVENTS } from '@partylayer/core';
-export { CIP0103_EVENTS, CIP0103_MANDATORY_METHODS, CIP0103_METHODS } from '@partylayer/core';
+import { PartyLayerError, CIP0103_EVENTS, toCAIP2Network } from '@partylayer/core';
+export { CANTON_NETWORKS, CIP0103_EVENTS, CIP0103_MANDATORY_METHODS, CIP0103_METHODS, fromCAIP2Network, isValidCAIP2, toCAIP2Network } from '@partylayer/core';
 
 // src/provider.ts
 
@@ -164,6 +164,7 @@ var ERROR_CODE_TO_RPC = {
   REGISTRY_VERIFICATION_FAILED: JSON_RPC_ERRORS.INTERNAL_ERROR,
   REGISTRY_SCHEMA_INVALID: JSON_RPC_ERRORS.INTERNAL_ERROR,
   INTERNAL_ERROR: JSON_RPC_ERRORS.INTERNAL_ERROR,
+  NETWORK_MISMATCH: JSON_RPC_ERRORS.INVALID_INPUT,
   TIMEOUT: JSON_RPC_ERRORS.INVALID_INPUT
 };
 var RPC_TO_ERROR_CODE = {
@@ -503,43 +504,8 @@ var PartyLayerProvider = class {
   }
 };
 
-// src/network.ts
-var CANTON_NETWORKS = {
-  mainnet: "canton:da-mainnet",
-  testnet: "canton:da-testnet",
-  devnet: "canton:da-devnet",
-  local: "canton:da-local"
-};
-var CAIP2_TO_SHORT = Object.fromEntries(
-  Object.entries(CANTON_NETWORKS).map(([short, full]) => [full, short])
-);
-function toCAIP2Network(networkId) {
-  let result;
-  if (networkId.includes(":")) {
-    result = networkId;
-  } else {
-    const caip2 = CANTON_NETWORKS[networkId];
-    result = caip2 ?? `canton:${networkId}`;
-  }
-  if (!isValidCAIP2(result)) {
-    throw new Error(
-      `Invalid CAIP-2 network identifier: "${result}". Expected format: "namespace:reference"`
-    );
-  }
-  return { networkId: result };
-}
-function fromCAIP2Network(caip2) {
-  const short = CAIP2_TO_SHORT[caip2];
-  if (short) return short;
-  const colonIndex = caip2.indexOf(":");
-  return colonIndex >= 0 ? caip2.slice(colonIndex + 1) : caip2;
-}
-function isValidCAIP2(networkId) {
-  return /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}$/.test(networkId);
-}
-
 // src/bridge.ts
-var PROVIDER_VERSION = "0.1.7" ;
+var PROVIDER_VERSION = "0.2.1" ;
 function createProviderBridge(client) {
   const eventBus = new CIP0103EventBus();
   const pendingEmitted = /* @__PURE__ */ new Set();
@@ -818,6 +784,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",
@@ -891,7 +947,104 @@ 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;
+}
 
-export { CANTON_NETWORKS, CIP0103EventBus, JSON_RPC_ERRORS, MethodRouter, PartyLayerProvider, 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 { CIP0103EventBus, JSON_RPC_ERRORS, MethodRouter, PartyLayerProvider, ProviderRpcError, RPC_ERRORS, chainDisconnected, createExtensionChannelProvider, createProviderBridge, disconnected, discoverAnnouncedProviders, discoverInjectedProviders, discoverProviders, handleAsyncConnect, handleAsyncPrepareExecute, internalError, invalidParams, isCIP0103Provider, methodNotFound, resourceNotFound, resourceUnavailable, toPartyLayerError, toProviderRpcError, transactionRejected, unauthorized, unsupportedMethod, userRejected, waitForProvider };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map