@powerhousedao/connect 1.0.24-dev.0 → 1.1.1

package/dist/assets/{index-BVVRVlZN.js → index-C3PlmBGF.js}

@@ -1,8 +1,8 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/app-loader-CmEZOj3m.js","assets/main.DA6nl4Ov.js","assets/app-loader-NDVZu4bS.css"])))=>i.map(i=>d[i]);
-import { _ as __vitePreload } from "./main.DA6nl4Ov.js";
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/app-loader-CyUyHxMC.js","assets/main.8RNzWcZO.js","assets/app-loader-4GyeoNTc.css"])))=>i.map(i=>d[i]);
+import { _ as __vitePreload } from "./main.8RNzWcZO.js";
 import { createRoot } from "react-dom/client";
 async function renderApp(element) {
-  const AppLoader = await __vitePreload(() => import("./app-loader-CmEZOj3m.js").then((n) => n.ca), true ? __vite__mapDeps([0,1,2]) : void 0);
+  const AppLoader = await __vitePreload(() => import("./app-loader-CyUyHxMC.js").then((n) => n.ca), true ? __vite__mapDeps([0,1,2]) : void 0);
   createRoot(element).render(AppLoader.default);
 }
 const AppElement = document.getElementById("app");
@@ -10,4 +10,3 @@ if (!AppElement) {
   throw new Error("#app element not found!");
 }
 renderApp(AppElement).catch(console.error);
-//# sourceMappingURL=index-BVVRVlZN.js.map

package/dist/assets/{index-dSMCpjcQ.js → index-DFiZ2Eug.js}

@@ -1,16 +1,19 @@
+var __defProp = Object.defineProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _DB_NAME, _STORE_NAME, _KEY, _db, _BrowserKeyStorage_instances, useStore_fn, _store, _namespace, _BaseStorage_instances, buildKey_fn, _baseUrl, _store2, _connectId, _eventEmitter, _Renown_instances, updateUser_fn, getCredential_fn;
-import { U as RENOWN_URL, V as getEnsInfo } from "./app-B5yYl0zv.js";
-import { X, a1, a0, Z, a2, Y, _, $ } from "./app-B5yYl0zv.js";
-import { ah as connectConfig, _ as logger } from "./app-loader-CmEZOj3m.js";
-import "./main.DA6nl4Ov.js";
+var _DB_NAME, _STORE_NAME, _KEY, _db, _BrowserKeyStorage_instances, useStore_fn, _subtleCrypto, _keyPair, _keyPairStorage, _did, _ConnectCrypto_instances, initCrypto_fn, initialize_fn, parseDid_fn, generateECDSAKeyPair_fn, exportKeyPair_fn, importKeyPair_fn, _sign, _verify, _store, _namespace, _BaseStorage_instances, buildKey_fn, _baseUrl, _store2, _connectId, _eventEmitter, _Renown_instances, updateUser_fn, getCredential_fn;
+import { _ as __vitePreload } from "./main.8RNzWcZO.js";
+import { r as rawKeyInHexfromUncompressed, c as compressedKeyInHexfromRaw, e as encodeDIDfromHexString, a as eventsExports, R as RENOWN_URL, g as getEnsInfo } from "./app-CZSKsD-w.js";
+import { i, h, d, j, b, f, s } from "./app-CZSKsD-w.js";
+import { ah as connectConfig, ac as logger } from "./app-loader-CyUyHxMC.js";
 import "react/jsx-runtime";
 import "react";
 import "react-dom";
@@ -71,6 +74,157 @@ __privateAdd(_BrowserKeyStorage, _DB_NAME, "browserKeyDB");
 __privateAdd(_BrowserKeyStorage, _STORE_NAME, "keyPairs");
 __privateAdd(_BrowserKeyStorage, _KEY, "keyPair");
 let BrowserKeyStorage = _BrowserKeyStorage;
+function ab2hex(ab) {
+  return Array.prototype.map.call(
+    new Uint8Array(ab),
+    (x) => ("00" + x.toString(16)).slice(-2)
+  ).join("");
+}
+const _ConnectCrypto = class _ConnectCrypto {
+  constructor(keyPairStorage) {
+    __privateAdd(this, _ConnectCrypto_instances);
+    __privateAdd(this, _subtleCrypto);
+    __privateAdd(this, _keyPair);
+    __privateAdd(this, _keyPairStorage);
+    __privateAdd(this, _did);
+    __privateAdd(this, _sign, async (...args) => {
+      return (await __privateGet(this, _subtleCrypto)).sign(...args);
+    });
+    __privateAdd(this, _verify, async (...args) => {
+      return (await __privateGet(this, _subtleCrypto)).verify(...args);
+    });
+    __privateSet(this, _keyPairStorage, keyPairStorage);
+    __privateSet(this, _subtleCrypto, __privateMethod(this, _ConnectCrypto_instances, initCrypto_fn).call(this));
+    __privateSet(this, _did, __privateMethod(this, _ConnectCrypto_instances, initialize_fn).call(this));
+  }
+  did() {
+    return __privateGet(this, _did);
+  }
+  async regenerateDid() {
+    __privateSet(this, _keyPair, await __privateMethod(this, _ConnectCrypto_instances, generateECDSAKeyPair_fn).call(this));
+    await __privateGet(this, _keyPairStorage).saveKeyPair(await __privateMethod(this, _ConnectCrypto_instances, exportKeyPair_fn).call(this));
+  }
+  async sign(data) {
+    var _a;
+    if ((_a = __privateGet(this, _keyPair)) == null ? void 0 : _a.privateKey) {
+      const subtleCrypto = await __privateGet(this, _subtleCrypto);
+      const arrayBuffer = await subtleCrypto.sign(
+        _ConnectCrypto.signAlgorithm,
+        __privateGet(this, _keyPair).privateKey,
+        data.buffer
+      );
+      return new Uint8Array(arrayBuffer);
+    } else {
+      throw new Error("No private key available");
+    }
+  }
+};
+_subtleCrypto = new WeakMap();
+_keyPair = new WeakMap();
+_keyPairStorage = new WeakMap();
+_did = new WeakMap();
+_ConnectCrypto_instances = new WeakSet();
+initCrypto_fn = function() {
+  return new Promise((resolve, reject) => {
+    var _a;
+    if (typeof window === "undefined") {
+      __vitePreload(() => import("node:crypto"), true ? [] : void 0).then((module) => {
+        resolve(module.webcrypto.subtle);
+      }).catch(reject);
+    } else {
+      if (!((_a = window.crypto) == null ? void 0 : _a.subtle)) {
+        reject(new Error("Crypto module not available"));
+      }
+      resolve(window.crypto.subtle);
+    }
+  });
+};
+initialize_fn = async function() {
+  const loadedKeyPair = await __privateGet(this, _keyPairStorage).loadKeyPair();
+  if (loadedKeyPair) {
+    __privateSet(this, _keyPair, await __privateMethod(this, _ConnectCrypto_instances, importKeyPair_fn).call(this, loadedKeyPair));
+    console.log("Found key pair");
+  } else {
+    __privateSet(this, _keyPair, await __privateMethod(this, _ConnectCrypto_instances, generateECDSAKeyPair_fn).call(this));
+    console.log("Created key pair");
+    await __privateGet(this, _keyPairStorage).saveKeyPair(await __privateMethod(this, _ConnectCrypto_instances, exportKeyPair_fn).call(this));
+  }
+  const did = await __privateMethod(this, _ConnectCrypto_instances, parseDid_fn).call(this);
+  console.log("Connect DID:", did);
+  return did;
+};
+parseDid_fn = async function() {
+  if (!__privateGet(this, _keyPair)) {
+    throw new Error("No key pair available");
+  }
+  const subtleCrypto = await __privateGet(this, _subtleCrypto);
+  const publicKeyRaw = await subtleCrypto.exportKey(
+    "raw",
+    __privateGet(this, _keyPair).publicKey
+  );
+  const multicodecName = "p256-pub";
+  const rawKey = rawKeyInHexfromUncompressed(ab2hex(publicKeyRaw));
+  const compressedKey = compressedKeyInHexfromRaw(rawKey);
+  const did = encodeDIDfromHexString(multicodecName, compressedKey);
+  return did;
+};
+generateECDSAKeyPair_fn = async function() {
+  const subtleCrypto = await __privateGet(this, _subtleCrypto);
+  const keyPair = await subtleCrypto.generateKey(
+    _ConnectCrypto.algorithm,
+    true,
+    ["sign", "verify"]
+  );
+  return keyPair;
+};
+exportKeyPair_fn = async function() {
+  if (!__privateGet(this, _keyPair)) {
+    throw new Error("No key pair available");
+  }
+  const subtleCrypto = await __privateGet(this, _subtleCrypto);
+  const jwkKeyPair = {
+    publicKey: await subtleCrypto.exportKey(
+      "jwk",
+      __privateGet(this, _keyPair).publicKey
+    ),
+    privateKey: await subtleCrypto.exportKey(
+      "jwk",
+      __privateGet(this, _keyPair).privateKey
+    )
+  };
+  return jwkKeyPair;
+};
+importKeyPair_fn = async function(jwkKeyPair) {
+  const subtleCrypto = await __privateGet(this, _subtleCrypto);
+  return {
+    publicKey: await subtleCrypto.importKey(
+      "jwk",
+      jwkKeyPair.publicKey,
+      _ConnectCrypto.algorithm,
+      true,
+      ["verify"]
+    ),
+    privateKey: await subtleCrypto.importKey(
+      "jwk",
+      jwkKeyPair.privateKey,
+      _ConnectCrypto.algorithm,
+      true,
+      ["sign"]
+    )
+  };
+};
+_sign = new WeakMap();
+_verify = new WeakMap();
+__publicField(_ConnectCrypto, "algorithm", {
+  name: "ECDSA",
+  namedCurve: "P-256"
+});
+__publicField(_ConnectCrypto, "signAlgorithm", {
+  name: "ECDSA",
+  namedCurve: "P-256",
+  hash: "SHA-256"
+});
+let ConnectCrypto = _ConnectCrypto;
 function parsePkhDid(did) {
   const parts = did.split(":");
   if (!did.startsWith("did:pkh:") || parts.length !== 5) {
@@ -146,7 +300,7 @@ class Renown {
     __privateAdd(this, _baseUrl);
     __privateAdd(this, _store2);
     __privateAdd(this, _connectId);
-    __privateAdd(this, _eventEmitter, new EventTarget());
+    __privateAdd(this, _eventEmitter, new eventsExports.EventEmitter());
     __privateSet(this, _store2, store2);
     __privateSet(this, _connectId, connectId);
     __privateSet(this, _baseUrl, baseUrl);
@@ -198,12 +352,9 @@ class Renown {
     __privateMethod(this, _Renown_instances, updateUser_fn).call(this, void 0);
   }
   on(event, listener) {
-    const eventListener = (e) => {
-      listener(e.detail);
-    };
-    __privateGet(this, _eventEmitter).addEventListener(event, eventListener);
+    __privateGet(this, _eventEmitter).on(event, listener);
     return () => {
-      __privateGet(this, _eventEmitter).removeEventListener(event, eventListener);
+      __privateGet(this, _eventEmitter).removeListener(event, listener);
     };
   }
 }
@@ -214,9 +365,7 @@ _eventEmitter = new WeakMap();
 _Renown_instances = new WeakSet();
 updateUser_fn = function(user) {
   user ? __privateGet(this, _store2).set("user", user) : __privateGet(this, _store2).delete("user");
-  __privateGet(this, _eventEmitter).dispatchEvent(
-    new CustomEvent("user", { detail: user })
-  );
+  __privateGet(this, _eventEmitter).emit("user", user);
 };
 getCredential_fn = async function(address, chainId, connectId) {
   if (!__privateGet(this, _baseUrl)) {
@@ -239,18 +388,17 @@ getCredential_fn = async function(address, chainId, connectId) {
 export {
   BaseStorage,
   BrowserKeyStorage,
-  X as ConnectCrypto,
-  a1 as RENOWN_CHAIN_ID,
-  a0 as RENOWN_NETWORK_ID,
+  ConnectCrypto,
+  i as RENOWN_CHAIN_ID,
+  h as RENOWN_NETWORK_ID,
   RENOWN_URL,
   Renown,
-  Z as addExternalPackage,
-  a2 as getChain,
+  d as addExternalPackage,
+  j as getChain,
   getEnsInfo,
-  Y as getHMRModule,
+  b as getHMRModule,
   initRenownBrowser,
   parsePkhDid,
-  _ as removeExternalPackage,
-  $ as subscribeExternalPackages
+  f as removeExternalPackage,
+  s as subscribeExternalPackages
 };
-//# sourceMappingURL=index-dSMCpjcQ.js.map