@partylayer/provider 0.6.0 → 0.6.1

package/dist/index.mjs

@@ -513,7 +513,7 @@ var PartyLayerProvider = class {
 };
 
 // src/bridge.ts
-var PROVIDER_VERSION = "0.6.0" ;
+var PROVIDER_VERSION = "0.6.1" ;
 function createProviderBridge(client) {
   const eventBus = new CIP0103EventBus();
   const pendingEmitted = /* @__PURE__ */ new Set();
@@ -578,9 +578,8 @@ async function handleRequest(client, args, eventBus, pendingEmitted) {
       }
       case "getActiveNetwork": {
         const session = await client.getActiveSession();
-        return toCAIP2Network(
-          session?.network ?? "devnet"
-        );
+        if (!session) throw disconnected("No active session");
+        return toCAIP2Network(session.network);
       }
       case "listAccounts": {
         const session = await client.getActiveSession();
@@ -605,61 +604,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(CIP0103_EVENTS.TX_CHANGED, {
-          status: "pending",
-          commandId: cmdId
-        });
+        eventBus.emit(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(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(CIP0103_EVENTS.TX_CHANGED, event2);
           }
-          try {
-            const receipt = await client.submitTransaction({
-              signedTx: signResult.signedTx ?? signResult.transactionHash
-            });
-            pendingEmitted.delete(cmdId);
-            eventBus.emit(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(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(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(CIP0103_EVENTS.TX_CHANGED, event);
+        } catch (reason) {
+          const code = reason?.code;
+          if (!submitting || code === 4001 || code === "USER_REJECTED" || code === -32003) {
+            eventBus.emit(CIP0103_EVENTS.TX_CHANGED, { status: "failed", commandId: cmdId });
           }
-          throw signErr;
+          throw reason;
+        } finally {
+          pendingEmitted.delete(cmdId);
         }
         return void 0;
       }
@@ -734,59 +714,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(CIP0103_EVENTS.TX_CHANGED, txEvent);
+    if (txEvent) eventBus.emit(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] ?? {};
@@ -818,11 +790,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;
@@ -831,6 +825,7 @@ function createExtensionChannelProvider(options = {}) {
     if (!entry) return;
     pending.delete(String(id));
     clearTimeout(entry.timer);
+    detachIfIdle();
     if (error) {
       entry.reject(
         new ProviderRpcError(
@@ -843,24 +838,24 @@ 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) {
+      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`,
@@ -879,11 +874,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) {
@@ -891,7 +896,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);