@noir-wallet/sdk 0.1.0

package/dist/chunk-B5WLNS6I.mjs

@@ -0,0 +1,121 @@
+var __defProp = Object.defineProperty;
+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);
+
+// src/chains/zcash/provider.ts
+function getZcashProvider() {
+  if (typeof window === "undefined") return null;
+  const rheaWallet = window.rheawallet;
+  return rheaWallet?.zcash || null;
+}
+async function detectProvider(timeout = 3e3) {
+  return new Promise((resolve, reject) => {
+    if (typeof window === "undefined") {
+      return reject(new Error("window is undefined"));
+    }
+    const provider = getZcashProvider();
+    if (provider) {
+      return resolve(provider);
+    }
+    let handled = false;
+    const handleProvider = () => {
+      if (handled) return;
+      handled = true;
+      const provider2 = getZcashProvider();
+      if (provider2) {
+        resolve(provider2);
+      } else {
+        reject(new Error("RHEA Wallet is not installed"));
+      }
+    };
+    window.addEventListener("rheawallet#initialized", handleProvider, { once: true });
+    setTimeout(() => {
+      handleProvider();
+    }, timeout);
+  });
+}
+function getProvider() {
+  return getZcashProvider();
+}
+
+// src/chains/zcash/wallet.ts
+var ZcashWallet = class {
+  constructor() {
+    __publicField(this, "provider", null);
+    __publicField(this, "_connected", false);
+  }
+  async connect() {
+    this.provider = await detectProvider();
+    if (!this.provider) {
+      throw new Error("RHEA Wallet provider not available");
+    }
+    const accounts = await this.provider.request({ method: "zcash_requestAccounts" });
+    this._connected = true;
+    return accounts;
+  }
+  async getAddresses() {
+    if (!this.provider || !this._connected) {
+      throw new Error("Wallet not connected");
+    }
+    return this.provider.request({ method: "zcash_getAddresses" });
+  }
+  async getBalance() {
+    if (!this.provider || !this._connected) {
+      throw new Error("Wallet not connected");
+    }
+    return this.provider.request({ method: "zcash_getBalance" });
+  }
+  async sendTransaction(params) {
+    if (!this.provider || !this._connected) {
+      throw new Error("Wallet not connected");
+    }
+    return this.provider.request({
+      method: "zcash_sendTransaction",
+      params: [params]
+    });
+  }
+  async signMessage(message) {
+    if (!this.provider || !this._connected) {
+      throw new Error("Wallet not connected");
+    }
+    return this.provider.request({
+      method: "zcash_signMessage",
+      params: [{ message }]
+    });
+  }
+  async switchNetwork(network) {
+    if (!this.provider || !this._connected) {
+      throw new Error("Wallet not connected");
+    }
+    return this.provider.request({
+      method: "zcash_switchNetwork",
+      params: [{ network }]
+    });
+  }
+  on(event, handler) {
+    if (!this.provider) {
+      throw new Error("Wallet not connected");
+    }
+    this.provider.on(event, handler);
+  }
+  removeListener(event, handler) {
+    if (!this.provider?.removeListener) {
+      return;
+    }
+    this.provider.removeListener(event, handler);
+  }
+  disconnect() {
+    this._connected = false;
+    this.provider = null;
+  }
+  get connected() {
+    return this._connected;
+  }
+};
+
+export {
+  getZcashProvider,
+  detectProvider,
+  getProvider,
+  ZcashWallet
+};

package/dist/chunk-JG4K44MD.mjs

@@ -0,0 +1,183 @@
+var __defProp = Object.defineProperty;
+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);
+
+// src/chains/zcash/provider.ts
+function getZcashProvider() {
+  if (typeof window === "undefined") return null;
+  const rheaWallet = window.rheawallet;
+  return rheaWallet?.zcash || null;
+}
+async function detectProvider(timeout = 3e3) {
+  return new Promise((resolve, reject) => {
+    if (typeof window === "undefined") {
+      return reject(new Error("window is undefined"));
+    }
+    const provider = getZcashProvider();
+    if (provider) {
+      return resolve(provider);
+    }
+    let handled = false;
+    const handleProvider = () => {
+      if (handled) return;
+      handled = true;
+      const provider2 = getZcashProvider();
+      if (provider2) {
+        resolve(provider2);
+      } else {
+        reject(new Error("RHEA Wallet is not installed"));
+      }
+    };
+    window.addEventListener("rheawallet#initialized", handleProvider, { once: true });
+    setTimeout(() => {
+      handleProvider();
+    }, timeout);
+  });
+}
+function getProvider() {
+  return getZcashProvider();
+}
+
+// src/chains/zcash/api.ts
+var ZcashAPI = class {
+  constructor(provider) {
+    __publicField(this, "provider");
+    this.provider = provider;
+  }
+  async connect() {
+    return this.provider.request({ method: "zcash_requestAccounts" });
+  }
+  async getAccounts() {
+    return this.provider.request({ method: "zcash_getAccounts" });
+  }
+  async getBalance() {
+    return this.provider.request({ method: "zcash_getBalance" });
+  }
+  async getPublicKey() {
+    return this.provider.request({ method: "zcash_getPublicKey" });
+  }
+  async sendTransaction(params) {
+    return this.provider.request({
+      method: "zcash_sendTransaction",
+      params: [params]
+    });
+  }
+  async signMessage(message) {
+    return this.provider.request({
+      method: "zcash_signMessage",
+      params: [message]
+    });
+  }
+  async switchNetwork(network) {
+    return this.provider.request({
+      method: "zcash_switchNetwork",
+      params: [{ network }]
+    });
+  }
+  async disconnect() {
+    await this.provider.request({ method: "zcash_disconnect" });
+  }
+  on(event, handler) {
+    this.provider.on(event, handler);
+  }
+  removeListener(event, handler) {
+    this.provider.removeListener?.(event, handler);
+  }
+};
+
+// src/chains/zcash/utils.ts
+import bs58 from "bs58";
+import * as hashjs from "hash.js";
+var MAINNET_P2PKH_PREFIX = new Uint8Array([28, 184]);
+var TESTNET_P2PKH_PREFIX = new Uint8Array([29, 37]);
+function sha2562(data) {
+  return new Uint8Array(hashjs.sha256().update(Array.from(data)).digest());
+}
+function ripemd1602(data) {
+  return new Uint8Array(hashjs.ripemd160().update(Array.from(data)).digest());
+}
+function hash160(data) {
+  return ripemd1602(sha2562(data));
+}
+function hexToUint8Array(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+  }
+  return bytes;
+}
+function concatUint8Arrays(...arrays) {
+  const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+function compressPublicKey(pubkey) {
+  if (pubkey.length === 33) {
+    return pubkey;
+  }
+  if (pubkey.length !== 65) {
+    throw new Error("Invalid public key length for compression");
+  }
+  if (pubkey[0] !== 4) {
+    throw new Error("Invalid uncompressed public key format");
+  }
+  const x = pubkey.slice(1, 33);
+  const y = pubkey.slice(33, 65);
+  const yIsOdd = (y[y.length - 1] & 1) === 1;
+  const prefix = yIsOdd ? 3 : 2;
+  const compressed = new Uint8Array(33);
+  compressed[0] = prefix;
+  compressed.set(x, 1);
+  return compressed;
+}
+function publicKeyToAddress(pubkeyHex, network = "mainnet") {
+  if (!pubkeyHex || typeof pubkeyHex !== "string") {
+    throw new Error("Invalid public key: must be a non-empty hex string");
+  }
+  const cleanHex = pubkeyHex.toLowerCase().replace(/^0x/, "");
+  if (!/^[0-9a-f]+$/.test(cleanHex)) {
+    throw new Error("Invalid public key: must contain only hexadecimal characters");
+  }
+  const pubkeyBytes = hexToUint8Array(cleanHex);
+  if (pubkeyBytes.length !== 33 && pubkeyBytes.length !== 65) {
+    throw new Error(
+      `Invalid public key length: expected 33 (compressed) or 65 (uncompressed) bytes, got ${pubkeyBytes.length}`
+    );
+  }
+  if (pubkeyBytes.length === 33) {
+    const prefix = pubkeyBytes[0];
+    if (prefix !== 2 && prefix !== 3) {
+      throw new Error(
+        `Invalid compressed public key prefix: expected 0x02 or 0x03, got 0x${prefix.toString(16).padStart(2, "0")}`
+      );
+    }
+  } else if (pubkeyBytes.length === 65) {
+    const prefix = pubkeyBytes[0];
+    if (prefix !== 4) {
+      throw new Error(
+        `Invalid uncompressed public key prefix: expected 0x04, got 0x${prefix.toString(16).padStart(2, "0")}`
+      );
+    }
+  }
+  const compressedPubkey = compressPublicKey(pubkeyBytes);
+  const pubkeyHash = hash160(compressedPubkey);
+  const versionPrefix = network === "mainnet" ? MAINNET_P2PKH_PREFIX : TESTNET_P2PKH_PREFIX;
+  const payload = concatUint8Arrays(versionPrefix, pubkeyHash);
+  const checksum = sha2562(sha2562(payload)).slice(0, 4);
+  const addressBytes = concatUint8Arrays(payload, checksum);
+  const address = bs58.encode(addressBytes);
+  return address;
+}
+
+export {
+  ZcashAPI,
+  getZcashProvider,
+  detectProvider,
+  getProvider,
+  publicKeyToAddress
+};

package/dist/chunk-JTGVB6AM.mjs

@@ -0,0 +1,41 @@
+// src/chains/zcash/provider.ts
+function getZcashProvider() {
+  if (typeof window === "undefined") return null;
+  const rheaWallet = window.rheawallet;
+  return rheaWallet?.zcash || null;
+}
+async function detectProvider(timeout = 3e3) {
+  return new Promise((resolve, reject) => {
+    if (typeof window === "undefined") {
+      return reject(new Error("window is undefined"));
+    }
+    const provider = getZcashProvider();
+    if (provider) {
+      return resolve(provider);
+    }
+    let handled = false;
+    const handleProvider = () => {
+      if (handled) return;
+      handled = true;
+      const provider2 = getZcashProvider();
+      if (provider2) {
+        resolve(provider2);
+      } else {
+        reject(new Error("RHEA Wallet is not installed"));
+      }
+    };
+    window.addEventListener("rheawallet#initialized", handleProvider, { once: true });
+    setTimeout(() => {
+      handleProvider();
+    }, timeout);
+  });
+}
+function getProvider() {
+  return getZcashProvider();
+}
+
+export {
+  getZcashProvider,
+  detectProvider,
+  getProvider
+};

package/dist/chunk-LM5EFW23.mjs

@@ -0,0 +1,173 @@
+var __defProp = Object.defineProperty;
+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);
+
+// src/chains/zcash/provider.ts
+function getZcashProvider() {
+  if (typeof window === "undefined") return null;
+  const rheaWallet = window.rheawallet;
+  return rheaWallet?.zcash || null;
+}
+async function detectProvider(timeout = 3e3) {
+  return new Promise((resolve, reject) => {
+    if (typeof window === "undefined") {
+      return reject(new Error("window is undefined"));
+    }
+    const provider = getZcashProvider();
+    if (provider) {
+      return resolve(provider);
+    }
+    let handled = false;
+    const handleProvider = () => {
+      if (handled) return;
+      handled = true;
+      const provider2 = getZcashProvider();
+      if (provider2) {
+        resolve(provider2);
+      } else {
+        reject(new Error("RHEA Wallet is not installed"));
+      }
+    };
+    window.addEventListener("rheawallet#initialized", handleProvider, { once: true });
+    setTimeout(() => {
+      handleProvider();
+    }, timeout);
+  });
+}
+function getProvider() {
+  return getZcashProvider();
+}
+
+// src/chains/zcash/wallet.ts
+var ZcashWallet = class {
+  constructor() {
+    __publicField(this, "provider", null);
+    __publicField(this, "_connected", false);
+  }
+  async connect() {
+    this.provider = await detectProvider();
+    if (!this.provider) {
+      throw new Error("RHEA Wallet provider not available");
+    }
+    const accounts = await this.provider.request({ method: "zcash_requestAccounts" });
+    this._connected = true;
+    return accounts;
+  }
+  async getAddresses() {
+    if (!this.provider || !this._connected) {
+      throw new Error("Wallet not connected");
+    }
+    return this.provider.request({ method: "zcash_getAddresses" });
+  }
+  async getBalance() {
+    if (!this.provider || !this._connected) {
+      throw new Error("Wallet not connected");
+    }
+    return this.provider.request({ method: "zcash_getBalance" });
+  }
+  async sendTransaction(params) {
+    if (!this.provider || !this._connected) {
+      throw new Error("Wallet not connected");
+    }
+    return this.provider.request({
+      method: "zcash_sendTransaction",
+      params: [params]
+    });
+  }
+  async signMessage(message) {
+    if (!this.provider || !this._connected) {
+      throw new Error("Wallet not connected");
+    }
+    return this.provider.request({
+      method: "zcash_signMessage",
+      params: [{ message }]
+    });
+  }
+  async switchNetwork(network) {
+    if (!this.provider || !this._connected) {
+      throw new Error("Wallet not connected");
+    }
+    return this.provider.request({
+      method: "zcash_switchNetwork",
+      params: [{ network }]
+    });
+  }
+  on(event, handler) {
+    if (!this.provider) {
+      throw new Error("Wallet not connected");
+    }
+    this.provider.on(event, handler);
+  }
+  removeListener(event, handler) {
+    if (!this.provider?.removeListener) {
+      return;
+    }
+    this.provider.removeListener(event, handler);
+  }
+  async disconnect() {
+    if (this._connected && this.provider) {
+      try {
+        await this.provider.request({ method: "zcash_disconnect" });
+      } catch (error) {
+        console.warn("Failed to notify extension about disconnect:", error);
+      }
+    }
+    this._connected = false;
+    this.provider = null;
+  }
+  get connected() {
+    return this._connected;
+  }
+};
+
+// src/chains/zcash/api.ts
+var ZcashAPI = class {
+  constructor(provider) {
+    __publicField(this, "provider");
+    this.provider = provider;
+  }
+  async connect() {
+    return this.provider.request({ method: "zcash_requestAccounts" });
+  }
+  async getAccounts() {
+    return this.provider.request({ method: "zcash_getAccounts" });
+  }
+  async getBalance() {
+    return this.provider.request({ method: "zcash_getBalance" });
+  }
+  async sendTransaction(params) {
+    return this.provider.request({
+      method: "zcash_sendTransaction",
+      params: [params]
+    });
+  }
+  async signMessage(message) {
+    return this.provider.request({
+      method: "zcash_signMessage",
+      params: [message]
+    });
+  }
+  async switchNetwork(network) {
+    return this.provider.request({
+      method: "zcash_switchNetwork",
+      params: [{ network }]
+    });
+  }
+  async disconnect() {
+    await this.provider.request({ method: "zcash_disconnect" });
+  }
+  on(event, handler) {
+    this.provider.on(event, handler);
+  }
+  removeListener(event, handler) {
+    this.provider.removeListener?.(event, handler);
+  }
+};
+
+export {
+  ZcashAPI,
+  getZcashProvider,
+  detectProvider,
+  getProvider,
+  ZcashWallet
+};

package/dist/chunk-OKXWHTTZ.mjs

@@ -0,0 +1,163 @@
+var __defProp = Object.defineProperty;
+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);
+
+// src/chains/zcash/provider.ts
+function getZcashProvider() {
+  if (typeof window === "undefined") return null;
+  const rheaWallet = window.rheawallet;
+  return rheaWallet?.zcash || null;
+}
+async function detectProvider(timeout = 3e3) {
+  return new Promise((resolve, reject) => {
+    if (typeof window === "undefined") {
+      return reject(new Error("window is undefined"));
+    }
+    const provider = getZcashProvider();
+    if (provider) {
+      return resolve(provider);
+    }
+    let handled = false;
+    const handleProvider = () => {
+      if (handled) return;
+      handled = true;
+      const provider2 = getZcashProvider();
+      if (provider2) {
+        resolve(provider2);
+      } else {
+        reject(new Error("RHEA Wallet is not installed"));
+      }
+    };
+    window.addEventListener("rheawallet#initialized", handleProvider, { once: true });
+    setTimeout(() => {
+      handleProvider();
+    }, timeout);
+  });
+}
+function getProvider() {
+  return getZcashProvider();
+}
+
+// src/chains/zcash/api.ts
+var ZcashAPI = class {
+  constructor(provider) {
+    __publicField(this, "provider");
+    this.provider = provider;
+  }
+  async connect() {
+    return this.provider.request({ method: "zcash_requestAccounts" });
+  }
+  async getAccounts() {
+    return this.provider.request({ method: "zcash_getAccounts" });
+  }
+  async getBalance() {
+    return this.provider.request({ method: "zcash_getBalance" });
+  }
+  async getPublicKey() {
+    return this.provider.request({ method: "zcash_getPublicKey" });
+  }
+  async sendTransaction(params) {
+    return this.provider.request({
+      method: "zcash_sendTransaction",
+      params: [params]
+    });
+  }
+  async signMessage(message) {
+    return this.provider.request({
+      method: "zcash_signMessage",
+      params: [message]
+    });
+  }
+  async switchNetwork(network) {
+    return this.provider.request({
+      method: "zcash_switchNetwork",
+      params: [{ network }]
+    });
+  }
+  async disconnect() {
+    await this.provider.request({ method: "zcash_disconnect" });
+  }
+  on(event, handler) {
+    this.provider.on(event, handler);
+  }
+  removeListener(event, handler) {
+    this.provider.removeListener?.(event, handler);
+  }
+};
+
+// src/chains/zcash/utils.ts
+import bs58 from "bs58";
+import * as hashjs from "hash.js";
+var MAINNET_P2PKH_PREFIX = new Uint8Array([28, 184]);
+var TESTNET_P2PKH_PREFIX = new Uint8Array([29, 37]);
+function sha2562(data) {
+  return new Uint8Array(hashjs.sha256().update(Array.from(data)).digest());
+}
+function ripemd1602(data) {
+  return new Uint8Array(hashjs.ripemd160().update(Array.from(data)).digest());
+}
+function hash160(data) {
+  return ripemd1602(sha2562(data));
+}
+function hexToUint8Array(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+  }
+  return bytes;
+}
+function concatUint8Arrays(...arrays) {
+  const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+function publicKeyToAddress(pubkeyHex, network = "mainnet") {
+  if (!pubkeyHex || typeof pubkeyHex !== "string") {
+    throw new Error("Invalid public key: must be a non-empty hex string");
+  }
+  const cleanHex = pubkeyHex.toLowerCase().replace(/^0x/, "");
+  if (!/^[0-9a-f]+$/.test(cleanHex)) {
+    throw new Error("Invalid public key: must contain only hexadecimal characters");
+  }
+  const pubkeyBytes = hexToUint8Array(cleanHex);
+  if (pubkeyBytes.length !== 33 && pubkeyBytes.length !== 65) {
+    throw new Error(
+      `Invalid public key length: expected 33 (compressed) or 65 (uncompressed) bytes, got ${pubkeyBytes.length}`
+    );
+  }
+  if (pubkeyBytes.length === 33) {
+    const prefix = pubkeyBytes[0];
+    if (prefix !== 2 && prefix !== 3) {
+      throw new Error(
+        `Invalid compressed public key prefix: expected 0x02 or 0x03, got 0x${prefix.toString(16).padStart(2, "0")}`
+      );
+    }
+  } else if (pubkeyBytes.length === 65) {
+    const prefix = pubkeyBytes[0];
+    if (prefix !== 4) {
+      throw new Error(
+        `Invalid uncompressed public key prefix: expected 0x04, got 0x${prefix.toString(16).padStart(2, "0")}`
+      );
+    }
+  }
+  const pubkeyHash = hash160(pubkeyBytes);
+  const versionPrefix = network === "mainnet" ? MAINNET_P2PKH_PREFIX : TESTNET_P2PKH_PREFIX;
+  const payload = concatUint8Arrays(versionPrefix, pubkeyHash);
+  const checksum = sha2562(sha2562(payload)).slice(0, 4);
+  const addressBytes = concatUint8Arrays(payload, checksum);
+  const address = bs58.encode(addressBytes);
+  return address;
+}
+
+export {
+  ZcashAPI,
+  getZcashProvider,
+  detectProvider,
+  getProvider,
+  publicKeyToAddress
+};