@partylayer/provider 0.6.0 → 0.6.2

package/README.md

@@ -18,7 +18,7 @@
 
 ### Features
 
-- **CIP-0103 Compliant**: All 10 mandatory methods implemented (`connect`, `disconnect`, `isConnected`, `status`, `getActiveNetwork`, `listAccounts`, `getPrimaryAccount`, `signMessage`, `prepareExecute`, `ledgerApi`)
+- **Provider request surface**: Handles the ten method names according to backing wallet capabilities (`connect`, `disconnect`, `isConnected`, `status`, `getActiveNetwork`, `listAccounts`, `getPrimaryAccount`, `signMessage`, `prepareExecute`, `ledgerApi`)
 - **Wallet Discovery**: Automatic scanning for injected CIP-0103 providers at `window.canton.*`
 - **Async Wallet Support**: Handles both synchronous (browser extension) and asynchronous (mobile/QR) wallet flows
 - **Standard Error Model**: `ProviderRpcError` with EIP-1193 / EIP-1474 numeric codes
@@ -58,7 +58,15 @@ const result = await provider.request({ method: 'connect' });
 const account = await provider.request({ method: 'getPrimaryAccount' });
 ```
 
-### Legacy Bridge (with PartyLayerClient)
+### Client compatibility bridge
+
+The bridge projects the active SDK party, retains the legacy `{ response: string }`
+Ledger API result, and emits transaction states only with genuine evidence. It does
+not establish full account/key enumeration or complete native protocol ownership.
+See [alignment and limits](../../docs/CIP-0103-ALIGNMENT.md) before relying on it
+as an exact standard wire implementation.
+
+Existing low-level composition:
 
 ```typescript
 import { createProviderBridge } from '@partylayer/provider';
@@ -67,8 +75,10 @@ import { createPartyLayer } from '@partylayer/sdk';
 const client = createPartyLayer({ network: 'devnet' });
 const provider = createProviderBridge(client);
 
-// Use standard CIP-0103 interface
-await provider.request({ method: 'connect', params: { walletId: 'console' } });
+// Choose a wallet through the SDK's documented application interface.
+await client.connect({ walletId: 'console' });
+// Then use the supported provider requests.
+await provider.request({ method: 'status' });
 ```
 
 ---

package/dist/index.d.mts

@@ -258,6 +258,9 @@ interface BridgeableClient {
         transactionHash?: unknown;
         signedTx?: unknown;
         partyId?: unknown;
+        /** Actual signature metadata, never a transaction hash. */
+        signature?: unknown;
+        signedBy?: unknown;
     }>;
     submitTransaction(params: {
         signedTx: unknown;
@@ -266,6 +269,7 @@ interface BridgeableClient {
         submittedAt?: number;
         commandId?: string;
         updateId?: string;
+        completionOffset?: number;
     }>;
     ledgerApi?(params: {
         requestMethod: string;
@@ -396,11 +400,15 @@ interface ExtensionChannelOptions {
     /** Per-request timeout in ms. Default 30000. */
     timeoutMs?: number;
 }
+interface ExtensionChannelProvider extends CIP0103Provider {
+    /** Remove the channel listener, reject pending RPCs and release subscriptions. */
+    destroy(): void;
+}
 /**
  * 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;
+declare function createExtensionChannelProvider(options?: ExtensionChannelOptions): ExtensionChannelProvider;
 
 /**
  * Async Wallet Handling
@@ -496,4 +504,4 @@ declare class MethodRouter {
     private registerDefaults;
 }
 
-export { type AnnounceDiscoveryOptions, type AnnounceSubscribeOptions, type AnnouncedWallet, type AsyncConnectOptions, type AsyncPrepareExecuteOptions, type BridgeableClient, CIP0103EventBus, type DiscoveredProvider, type ExtensionChannelOptions, JSON_RPC_ERRORS, type MethodHandler, MethodRouter, PartyLayerProvider, type PartyLayerProviderOptions, ProviderRpcError, RPC_ERRORS, type WaitForAnnouncedOptions, chainDisconnected, createExtensionChannelProvider, createProviderBridge, disconnected, discoverAnnouncedProviders, discoverInjectedProviders, discoverProviders, handleAsyncConnect, handleAsyncPrepareExecute, internalError, invalidParams, isCIP0103Provider, methodNotFound, resourceNotFound, resourceUnavailable, subscribeAnnouncedProviders, toPartyLayerError, toProviderRpcError, transactionRejected, unauthorized, unsupportedMethod, userRejected, waitForAnnouncedProvider, waitForProvider };
+export { type AnnounceDiscoveryOptions, type AnnounceSubscribeOptions, type AnnouncedWallet, type AsyncConnectOptions, type AsyncPrepareExecuteOptions, type BridgeableClient, CIP0103EventBus, type DiscoveredProvider, type ExtensionChannelOptions, type ExtensionChannelProvider, JSON_RPC_ERRORS, type MethodHandler, MethodRouter, PartyLayerProvider, type PartyLayerProviderOptions, ProviderRpcError, RPC_ERRORS, type WaitForAnnouncedOptions, chainDisconnected, createExtensionChannelProvider, createProviderBridge, disconnected, discoverAnnouncedProviders, discoverInjectedProviders, discoverProviders, handleAsyncConnect, handleAsyncPrepareExecute, internalError, invalidParams, isCIP0103Provider, methodNotFound, resourceNotFound, resourceUnavailable, subscribeAnnouncedProviders, toPartyLayerError, toProviderRpcError, transactionRejected, unauthorized, unsupportedMethod, userRejected, waitForAnnouncedProvider, waitForProvider };

package/dist/index.d.ts

@@ -258,6 +258,9 @@ interface BridgeableClient {
         transactionHash?: unknown;
         signedTx?: unknown;
         partyId?: unknown;
+        /** Actual signature metadata, never a transaction hash. */
+        signature?: unknown;
+        signedBy?: unknown;
     }>;
     submitTransaction(params: {
         signedTx: unknown;
@@ -266,6 +269,7 @@ interface BridgeableClient {
         submittedAt?: number;
         commandId?: string;
         updateId?: string;
+        completionOffset?: number;
     }>;
     ledgerApi?(params: {
         requestMethod: string;
@@ -396,11 +400,15 @@ interface ExtensionChannelOptions {
     /** Per-request timeout in ms. Default 30000. */
     timeoutMs?: number;
 }
+interface ExtensionChannelProvider extends CIP0103Provider {
+    /** Remove the channel listener, reject pending RPCs and release subscriptions. */
+    destroy(): void;
+}
 /**
  * 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;
+declare function createExtensionChannelProvider(options?: ExtensionChannelOptions): ExtensionChannelProvider;
 
 /**
  * Async Wallet Handling
@@ -496,4 +504,4 @@ declare class MethodRouter {
     private registerDefaults;
 }
 
-export { type AnnounceDiscoveryOptions, type AnnounceSubscribeOptions, type AnnouncedWallet, type AsyncConnectOptions, type AsyncPrepareExecuteOptions, type BridgeableClient, CIP0103EventBus, type DiscoveredProvider, type ExtensionChannelOptions, JSON_RPC_ERRORS, type MethodHandler, MethodRouter, PartyLayerProvider, type PartyLayerProviderOptions, ProviderRpcError, RPC_ERRORS, type WaitForAnnouncedOptions, chainDisconnected, createExtensionChannelProvider, createProviderBridge, disconnected, discoverAnnouncedProviders, discoverInjectedProviders, discoverProviders, handleAsyncConnect, handleAsyncPrepareExecute, internalError, invalidParams, isCIP0103Provider, methodNotFound, resourceNotFound, resourceUnavailable, subscribeAnnouncedProviders, toPartyLayerError, toProviderRpcError, transactionRejected, unauthorized, unsupportedMethod, userRejected, waitForAnnouncedProvider, waitForProvider };
+export { type AnnounceDiscoveryOptions, type AnnounceSubscribeOptions, type AnnouncedWallet, type AsyncConnectOptions, type AsyncPrepareExecuteOptions, type BridgeableClient, CIP0103EventBus, type DiscoveredProvider, type ExtensionChannelOptions, type ExtensionChannelProvider, JSON_RPC_ERRORS, type MethodHandler, MethodRouter, PartyLayerProvider, type PartyLayerProviderOptions, ProviderRpcError, RPC_ERRORS, type WaitForAnnouncedOptions, chainDisconnected, createExtensionChannelProvider, createProviderBridge, disconnected, discoverAnnouncedProviders, discoverInjectedProviders, discoverProviders, handleAsyncConnect, handleAsyncPrepareExecute, internalError, invalidParams, isCIP0103Provider, methodNotFound, resourceNotFound, resourceUnavailable, subscribeAnnouncedProviders, toPartyLayerError, toProviderRpcError, transactionRejected, unauthorized, unsupportedMethod, userRejected, waitForAnnouncedProvider, waitForProvider };

package/dist/index.js

@@ -220,6 +220,17 @@ function isRpcShaped(err) {
   return typeof e.message === "string" && typeof e.code === "number";
 }
 
+// src/request-validation.ts
+function validateRequestPayload(payload) {
+  if (payload === null || typeof payload !== "object" || Array.isArray(payload) || !("method" in payload) || typeof payload.method !== "string") {
+    throw new ProviderRpcError("Request must be an object with a string method", JSON_RPC_ERRORS.INVALID_REQUEST);
+  }
+  const params = "params" in payload ? payload.params : void 0;
+  if (params !== void 0 && (params === null || typeof params !== "object")) {
+    throw new ProviderRpcError("Request params must be an object or array", JSON_RPC_ERRORS.INVALID_PARAMS);
+  }
+}
+
 // src/method-router.ts
 var MethodRouter = class {
   handlers = /* @__PURE__ */ new Map();
@@ -241,6 +252,7 @@ var MethodRouter = class {
   }
   /** Route a request to the appropriate handler */
   async route(payload) {
+    validateRequestPayload(payload);
     const { method, params } = payload;
     const handler = this.handlers.get(method);
     if (!handler) {
@@ -514,7 +526,7 @@ var PartyLayerProvider = class {
 };
 
 // src/bridge.ts
-var PROVIDER_VERSION = "0.6.0" ;
+var PROVIDER_VERSION = "0.6.2" ;
 function createProviderBridge(client) {
   const eventBus = new CIP0103EventBus();
   const pendingEmitted = /* @__PURE__ */ new Set();
@@ -539,6 +551,7 @@ function createProviderBridge(client) {
   return bridge;
 }
 async function handleRequest(client, args, eventBus, pendingEmitted) {
+  validateRequestPayload(args);
   const { method, params } = args;
   try {
     switch (method) {
@@ -579,9 +592,8 @@ async function handleRequest(client, args, eventBus, pendingEmitted) {
       }
       case "getActiveNetwork": {
         const session = await client.getActiveSession();
-        return core.toCAIP2Network(
-          session?.network ?? "devnet"
-        );
+        if (!session) throw disconnected("No active session");
+        return core.toCAIP2Network(session.network);
       }
       case "listAccounts": {
         const session = await client.getActiveSession();
@@ -606,61 +618,42 @@ async function handleRequest(client, args, eventBus, pendingEmitted) {
       }
       case "prepareExecute": {
         const p = normalizeParams(params);
-        const cmdId = `cmd_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+        const session = await client.getActiveSession();
+        if (!session) throw disconnected("No active session");
+        const cmdId = nonempty(p.commandId) ? p.commandId : `cmd_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+        if (pendingEmitted.has(cmdId)) throw resourceUnavailable("This commandId is already pending");
+        const payload = { ...p, commandId: cmdId };
         pendingEmitted.add(cmdId);
-        eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, {
-          status: "pending",
-          commandId: cmdId
-        });
+        eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, { status: "pending", commandId: cmdId });
+        let submitting = false;
         try {
-          const signResult = await client.signTransaction({ tx: p });
-          const session = await client.getActiveSession();
-          const partyId = String(signResult.partyId ?? session?.partyId ?? "unknown");
-          if (signResult.transactionHash !== void 0) {
-            eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, {
-              status: "signed",
-              commandId: cmdId,
-              payload: {
-                signature: String(signResult.transactionHash),
-                signedBy: partyId,
-                party: partyId
-              }
-            });
+          let signedTx = payload;
+          if (!session.capabilitiesSnapshot || session.capabilitiesSnapshot.includes("signTransaction")) {
+            const signed = await client.signTransaction({ tx: payload });
+            if (signed.partyId !== void 0 && signed.partyId !== session.partyId) {
+              throw disconnected("Wallet account changed during signing");
+            }
+            signedTx = signed.signedTx;
+            if (signedTx === void 0) throw new Error("Wallet returned no signed transaction");
+            const event2 = signedEvent({ signature: signed.signature, signedBy: signed.signedBy, party: signed.partyId }, cmdId);
+            if (event2) eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, event2);
           }
-          try {
-            const receipt = await client.submitTransaction({
-              signedTx: signResult.signedTx ?? signResult.transactionHash
-            });
-            pendingEmitted.delete(cmdId);
-            eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, {
-              status: "executed",
-              commandId: cmdId,
-              payload: {
-                // All three are real identifiers — the receipt's update id, the
-                // wallet's command id, or the bridge's own command id for this
-                // operation. `String(receipt.transactionHash)` was the old tail
-                // and would now stringify `undefined`.
-                updateId: receipt.updateId ?? receipt.commandId ?? cmdId,
-                completionOffset: 0
-              }
-            });
-          } catch (submitErr) {
-            pendingEmitted.delete(cmdId);
-            eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, {
-              status: "failed",
-              commandId: cmdId
-            });
-            throw submitErr;
+          const current = await client.getActiveSession();
+          if (!current || current.sessionId !== session.sessionId || current.partyId !== session.partyId || current.network !== session.network) {
+            throw disconnected("Wallet session changed before submission");
           }
-        } catch (signErr) {
-          if (pendingEmitted.has(cmdId)) {
-            pendingEmitted.delete(cmdId);
-            eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, {
-              status: "failed",
-              commandId: cmdId
-            });
+          submitting = true;
+          const receipt = await client.submitTransaction({ signedTx });
+          const event = executedEvent(receipt, cmdId);
+          if (event) eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, event);
+        } catch (reason) {
+          const code = reason?.code;
+          if (!submitting || code === 4001 || code === "USER_REJECTED" || code === -32003) {
+            eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, { status: "failed", commandId: cmdId });
           }
-          throw signErr;
+          throw reason;
+        } finally {
+          pendingEmitted.delete(cmdId);
         }
         return void 0;
       }
@@ -735,59 +728,51 @@ function wireEvents(client, eventBus, pendingEmitted) {
     });
   });
   client.on("tx:status", (event) => {
-    const e = event;
-    if (!e || typeof e !== "object" || !("status" in e)) return;
-    const statusMap = {
-      pending: "pending",
-      submitted: "pending",
-      signed: "signed",
-      committed: "executed",
-      rejected: "failed",
-      failed: "failed"
-    };
-    const mappedStatus = statusMap[e.status] ?? "pending";
-    const commandId = String(e.txId);
-    if (mappedStatus === "pending" && pendingEmitted.has(commandId)) {
-      return;
-    }
-    if (mappedStatus === "executed" || mappedStatus === "failed") {
-      pendingEmitted.delete(commandId);
-    }
+    const e = record(event);
+    if (!e) return;
+    const raw = record(e.raw);
+    const tx = record(raw?.tx) ?? raw;
+    const commandId = nonempty(tx?.commandId) ? tx.commandId : e.txId;
+    if (!nonempty(commandId)) return;
     let txEvent;
-    switch (mappedStatus) {
+    switch (e.status) {
+      case "pending":
+      case "submitted":
+        if (pendingEmitted.has(commandId)) return;
+        txEvent = { status: "pending", commandId };
+        break;
       case "signed":
-        txEvent = {
-          status: "signed",
-          commandId,
-          payload: {
-            signature: "",
-            signedBy: "",
-            party: ""
-          }
-        };
+        txEvent = signedEvent(tx, commandId);
         break;
-      case "executed": {
-        const raw = e.raw;
-        txEvent = {
-          status: "executed",
-          commandId,
-          payload: {
-            updateId: raw?.updateId ?? raw?.commandId ?? commandId,
-            completionOffset: 0
-          }
-        };
+      case "committed":
+        txEvent = executedEvent(tx, commandId);
         break;
-      }
+      case "rejected":
       case "failed":
         txEvent = { status: "failed", commandId };
         break;
       default:
-        txEvent = { status: "pending", commandId };
-        break;
+        return;
     }
-    eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, txEvent);
+    if (txEvent) eventBus.emit(core.CIP0103_EVENTS.TX_CHANGED, txEvent);
   });
 }
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function nonempty(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function signedEvent(value, commandId) {
+  const tx = record(value);
+  const p = record(tx?.payload) ?? tx;
+  return nonempty(p?.signature) && nonempty(p?.signedBy) && nonempty(p?.party) ? { status: "signed", commandId, payload: { signature: p.signature, signedBy: p.signedBy, party: p.party } } : null;
+}
+function executedEvent(value, commandId) {
+  const tx = record(value);
+  const p = record(tx?.payload) ?? tx;
+  return nonempty(p?.updateId) && typeof p.completionOffset === "number" && Number.isSafeInteger(p.completionOffset) && p.completionOffset >= 0 ? { status: "executed", commandId, payload: { updateId: p.updateId, completionOffset: p.completionOffset } } : null;
+}
 function normalizeParams(params) {
   if (!params) return {};
   if (Array.isArray(params)) return params[0] ?? {};
@@ -819,11 +804,33 @@ function createExtensionChannelProvider(options = {}) {
   const eventBus = new CIP0103EventBus();
   const channelId = `pl-${++channelSeq}-${target ?? "ext"}`;
   let requestSeq = 0;
+  let listening = false;
+  let destroyed = false;
+  const subscribedEvents = /* @__PURE__ */ new Set();
+  function listen() {
+    if (!listening && typeof window !== "undefined") {
+      window.addEventListener("message", onMessage);
+      listening = true;
+    }
+  }
+  function detachIfIdle() {
+    if (pending.size > 0 || [...subscribedEvents].some((name) => eventBus.listenerCount(name) > 0)) return;
+    if (listening && typeof window !== "undefined") window.removeEventListener("message", onMessage);
+    listening = false;
+  }
   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 notification = event.data;
+    if (notification?.type === SPLICE_WALLET_REQUEST && notification.request?.jsonrpc === "2.0" && notification.request.id == null && (!target || notification.target === target)) {
+      const method = notification.request.method;
+      if (method && ["statusChanged", "accountsChanged", "txChanged", "connected"].includes(method)) {
+        eventBus.emit(method, notification.request.params);
+      }
+      return;
+    }
     const data = event.data;
     if (!data || data.type !== SPLICE_WALLET_RESPONSE || !data.response) return;
     const { id, result, error } = data.response;
@@ -832,6 +839,7 @@ function createExtensionChannelProvider(options = {}) {
     if (!entry) return;
     pending.delete(String(id));
     clearTimeout(entry.timer);
+    detachIfIdle();
     if (error) {
       entry.reject(
         new ProviderRpcError(
@@ -844,24 +852,29 @@ function createExtensionChannelProvider(options = {}) {
       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) {
+      try {
+        validateRequestPayload(args);
+      } catch (error) {
+        return Promise.reject(error);
+      }
+      if (destroyed) return Promise.reject(new ProviderRpcError("Extension channel was destroyed", RPC_ERRORS.DISCONNECTED));
       if (typeof window === "undefined") {
         return Promise.reject(
           new ProviderRpcError("No window: extension channel unavailable", JSON_RPC_ERRORS.INTERNAL_ERROR)
         );
       }
+      listen();
       const id = `${channelId}-${++requestSeq}`;
       return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
           pending.delete(id);
+          detachIfIdle();
           reject(
             new ProviderRpcError(
               `Wallet request "${args.method}" timed out after ${timeoutMs}ms`,
@@ -880,11 +893,21 @@ function createExtensionChannelProvider(options = {}) {
           },
           ...target ? { target } : {}
         };
-        window.postMessage(message, postTargetOrigin());
+        try {
+          window.postMessage(message, postTargetOrigin());
+        } catch (error) {
+          pending.delete(id);
+          clearTimeout(timer);
+          detachIfIdle();
+          reject(error);
+        }
       });
     },
     on(event, listener) {
+      if (destroyed) return provider;
       eventBus.on(event, listener);
+      subscribedEvents.add(event);
+      listen();
       return provider;
     },
     emit(event, ...args) {
@@ -892,7 +915,20 @@ function createExtensionChannelProvider(options = {}) {
     },
     removeListener(event, listener) {
       eventBus.removeListener(event, listener);
+      detachIfIdle();
       return provider;
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      eventBus.removeAllListeners();
+      subscribedEvents.clear();
+      for (const entry of pending.values()) {
+        clearTimeout(entry.timer);
+        entry.reject(new ProviderRpcError("Extension channel was destroyed", RPC_ERRORS.DISCONNECTED));
+      }
+      pending.clear();
+      detachIfIdle();
     }
   };
   eventBus.setOwner(provider);