@noir-wallet/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,239 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ZcashAPI: () => ZcashAPI,
+  detectProvider: () => detectProvider,
+  getProvider: () => getProvider,
+  getRheaWallet: () => getRheaWallet,
+  getZcashProvider: () => getZcashProvider,
+  isRheaWalletInstalled: () => isRheaWalletInstalled,
+  publicKeyToAddress: () => publicKeyToAddress
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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/provider.ts
+function getRheaWallet() {
+  if (typeof window === "undefined") return null;
+  const rawWallet = window.rheawallet;
+  if (!rawWallet) return null;
+  return {
+    isRheaWallet: rawWallet.isRheaWallet,
+    zcash: new ZcashAPI(rawWallet.zcash)
+  };
+}
+function isRheaWalletInstalled() {
+  return getRheaWallet() !== null;
+}
+
+// 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/utils.ts
+var import_bs58 = __toESM(require("bs58"));
+var hashjs = __toESM(require("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 = import_bs58.default.encode(addressBytes);
+  return address;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ZcashAPI,
+  detectProvider,
+  getProvider,
+  getRheaWallet,
+  getZcashProvider,
+  isRheaWalletInstalled,
+  publicKeyToAddress
+});

package/dist/index.mjs

@@ -0,0 +1,30 @@
+import {
+  ZcashAPI,
+  detectProvider,
+  getProvider,
+  getZcashProvider,
+  publicKeyToAddress
+} from "./chunk-JG4K44MD.mjs";
+
+// src/provider.ts
+function getRheaWallet() {
+  if (typeof window === "undefined") return null;
+  const rawWallet = window.rheawallet;
+  if (!rawWallet) return null;
+  return {
+    isRheaWallet: rawWallet.isRheaWallet,
+    zcash: new ZcashAPI(rawWallet.zcash)
+  };
+}
+function isRheaWalletInstalled() {
+  return getRheaWallet() !== null;
+}
+export {
+  ZcashAPI,
+  detectProvider,
+  getProvider,
+  getRheaWallet,
+  getZcashProvider,
+  isRheaWalletInstalled,
+  publicKeyToAddress
+};

package/dist/provider-DE7vB7SX.d.mts

@@ -0,0 +1,48 @@
+interface ZcashProvider {
+    request(args: RequestArguments): Promise<any>;
+    on(event: string, handler: (...args: any[]) => void): void;
+    removeListener?(event: string, handler: (...args: any[]) => void): void;
+    connect(): Promise<ZcashAddress>;
+    getAccounts(): Promise<ZcashAddress | null>;
+    getBalance(): Promise<Balance>;
+    sendTransaction(params: SendTransactionParams): Promise<string>;
+    signMessage(message: string): Promise<SignMessageResult>;
+    switchNetwork(network: Network): Promise<boolean>;
+    disconnect(): Promise<void>;
+}
+interface RequestArguments {
+    method: string;
+    params?: any[];
+}
+interface ZcashAddress {
+    transparent: string;
+    shielded: string;
+}
+interface Balance {
+    transparent: string;
+    shielded: string;
+}
+interface SendTransactionParams {
+    to: string;
+    amount: string;
+}
+interface TransactionReceipt {
+    txid: string;
+    from: string;
+    to: string;
+    amount: string;
+    type: 'transparent' | 'shielded';
+    timestamp: number;
+}
+interface SignMessageResult {
+    signature: string;
+    pubkey: string;
+    address: string;
+}
+type Network = 'mainnet' | 'testnet';
+
+declare function getZcashProvider(): ZcashProvider | null;
+declare function detectProvider(timeout?: number): Promise<ZcashProvider>;
+declare function getProvider(): ZcashProvider | null;
+
+export { type Balance as B, type Network as N, type RequestArguments as R, type SendTransactionParams as S, type TransactionReceipt as T, type ZcashProvider as Z, getProvider as a, type ZcashAddress as b, type SignMessageResult as c, detectProvider as d, getZcashProvider as g };

package/dist/provider-DE7vB7SX.d.ts

@@ -0,0 +1,48 @@
+interface ZcashProvider {
+    request(args: RequestArguments): Promise<any>;
+    on(event: string, handler: (...args: any[]) => void): void;
+    removeListener?(event: string, handler: (...args: any[]) => void): void;
+    connect(): Promise<ZcashAddress>;
+    getAccounts(): Promise<ZcashAddress | null>;
+    getBalance(): Promise<Balance>;
+    sendTransaction(params: SendTransactionParams): Promise<string>;
+    signMessage(message: string): Promise<SignMessageResult>;
+    switchNetwork(network: Network): Promise<boolean>;
+    disconnect(): Promise<void>;
+}
+interface RequestArguments {
+    method: string;
+    params?: any[];
+}
+interface ZcashAddress {
+    transparent: string;
+    shielded: string;
+}
+interface Balance {
+    transparent: string;
+    shielded: string;
+}
+interface SendTransactionParams {
+    to: string;
+    amount: string;
+}
+interface TransactionReceipt {
+    txid: string;
+    from: string;
+    to: string;
+    amount: string;
+    type: 'transparent' | 'shielded';
+    timestamp: number;
+}
+interface SignMessageResult {
+    signature: string;
+    pubkey: string;
+    address: string;
+}
+type Network = 'mainnet' | 'testnet';
+
+declare function getZcashProvider(): ZcashProvider | null;
+declare function detectProvider(timeout?: number): Promise<ZcashProvider>;
+declare function getProvider(): ZcashProvider | null;
+
+export { type Balance as B, type Network as N, type RequestArguments as R, type SendTransactionParams as S, type TransactionReceipt as T, type ZcashProvider as Z, getProvider as a, type ZcashAddress as b, type SignMessageResult as c, detectProvider as d, getZcashProvider as g };

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@noir-wallet/sdk",
+  "version": "0.1.0",
+  "description": "TypeScript SDK for Noir Wallet dApp integration",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./chains/zcash": {
+      "types": "./dist/chains/zcash/index.d.ts",
+      "import": "./dist/chains/zcash/index.mjs",
+      "require": "./dist/chains/zcash/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/chains/zcash/index.ts --format cjs,esm --dts --out-dir dist",
+    "dev": "tsup src/index.ts src/chains/zcash/index.ts --format cjs,esm --dts --out-dir dist --watch",
+    "type-check": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.3"
+  },
+  "keywords": [
+    "noir",
+    "wallet",
+    "multi-chain",
+    "zcash",
+    "dapp",
+    "web3",
+    "crypto"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Noir Finance",
+  "license": "MIT",
+  "dependencies": {
+    "bs58": "^6.0.0",
+    "hash.js": "^1.1.7"
+  }
+}