@noir-wallet/sdk 0.1.0

package/README.md

@@ -0,0 +1,327 @@
+# @noir-wallet/sdk
+
+TypeScript SDK for integrating with Noir Wallet Chrome Extension.
+
+## Installation
+
+```bash
+npm install @noir-wallet/sdk
+# or
+yarn add @noir-wallet/sdk
+# or
+pnpm add @noir-wallet/sdk
+```
+
+## Usage
+
+### Basic Example
+
+```typescript
+import { getNoirWallet } from '@noir-wallet/sdk'
+
+// Get Noir Wallet
+const noirWallet = getNoirWallet()
+if (!noirWallet) {
+  throw new Error('Noir Wallet not installed')
+}
+
+const zcash = noirWallet.zcash
+
+// Check existing connection (silent, no popup)
+const accounts = await zcash.getAccounts()
+
+// Connect wallet if not connected (shows popup)
+if (!accounts) {
+  const newAccounts = await zcash.connect()
+  console.log('Wallet connected:', newAccounts)
+} else {
+  console.log('Already connected:', accounts)
+}
+
+// Get balance
+const balance = await zcash.getBalance()
+console.log('Transparent:', balance.transparent, 'ZEC')
+console.log('Shielded:', balance.shielded, 'ZEC')
+console.log('Available:', balance.available, 'ZEC') // Precise transferable amount
+
+// Get public key
+const publicKeyInfo = await zcash.getPublicKey()
+if (publicKeyInfo) {
+  console.log('Public Key:', publicKeyInfo.pubkey)
+  console.log('Address:', publicKeyInfo.address)
+}
+
+// Send transaction (uses shielded balance only)
+const txid = await zcash.sendTransaction({
+  to: 'zs1XYZ...',
+  amount: '0.1'
+})
+console.log('Transaction sent:', txid)
+
+// Sign message
+const result = await zcash.signMessage('Hello World')
+console.log('Signature:', result.signature)
+console.log('Address:', result.address)
+```
+
+### Detect Provider
+
+```typescript
+import { getNoirWallet, isNoirWalletInstalled } from '@noir-wallet/sdk'
+
+// Check if installed
+if (isNoirWalletInstalled()) {
+  const noirWallet = getNoirWallet()
+  console.log('Noir Wallet detected')
+} else {
+  console.error('Noir Wallet not found')
+}
+```
+
+### Event Listeners
+
+```typescript
+const noirWallet = getNoirWallet()
+const zcash = noirWallet.zcash
+
+// Connect first
+await zcash.connect()
+
+// Listen to account changes (unlock/lock, switch account)
+zcash.on('accountsChanged', accounts => {
+  console.log('Accounts changed:', accounts)
+  if (accounts.length === 0) {
+    console.log('Wallet locked or disconnected')
+  }
+})
+
+// Listen to chain/network changes
+zcash.on('chainChanged', chainInfo => {
+  console.log('Network changed:', chainInfo)
+})
+```
+
+## API
+
+### Methods
+
+All methods are available on `noirWallet.zcash`:
+
+#### `connect()`
+
+Request wallet connection (shows popup if not authorized).
+
+**Returns**: `Promise<ZcashAddress>` - Address object with transparent and shielded addresses
+
+```typescript
+const accounts = await zcash.connect()
+console.log('Transparent:', accounts.transparent)
+console.log('Shielded:', accounts.shielded)
+```
+
+#### `getAccounts()`
+
+Query existing connection silently (no popup).
+
+**Returns**: `Promise<ZcashAddress | null>` - Address object if connected, null if not connected
+
+```typescript
+const accounts = await zcash.getAccounts()
+if (accounts) {
+  console.log('Connected:', accounts.transparent)
+} else {
+  console.log('Not connected')
+}
+```
+
+#### `getBalance()`
+
+Get wallet balance.
+
+**Returns**: `Promise<Balance>`
+
+```typescript
+const balance = await zcash.getBalance()
+console.log('Shielded:', balance.shielded, 'ZEC')
+console.log('Available:', balance.available, 'ZEC') // Recommended for max send amount
+```
+
+**Balance fields**:
+
+- `transparent`: Transparent address balance
+- `shielded`: Shielded balance (Sapling + Orchard)
+- `total`: Total balance (transparent + shielded)
+- `available`: **Precise transferable amount** - Maximum amount that can be sent considering UTXO selection, dynamic fees, and dust threshold. Calculated during background sync using WASM's `get_max_transferable_amount` method.
+
+#### `getPublicKey()`
+
+Get the public key of the transparent address.
+
+**Returns**: `Promise<{ pubkey: string, address: string } | null>` - Public key info if connected and unlocked, null if locked
+
+```typescript
+const publicKeyInfo = await zcash.getPublicKey()
+if (publicKeyInfo) {
+  console.log('Public Key:', publicKeyInfo.pubkey)
+  console.log('Address:', publicKeyInfo.address)
+} else {
+  console.log('Wallet is locked')
+}
+```
+
+**Note**: This method requires the wallet to be connected but does not trigger an unlock popup. Returns `null` if the wallet is locked.
+
+#### `sendTransaction(params)`
+
+Send a transaction. **Only shielded balance is used for sending.** Transparent balance cannot be spent directly — it must be shielded in the wallet first. Memo is not yet supported.
+
+**Params**:
+
+- `to: string` - Recipient address
+- `amount: string` - Amount in ZEC (deducted from shielded balance)
+
+**Returns**: `Promise<string>` - Transaction ID
+
+> **Note:** All sends use shielded balance. If you have transparent balance, please shield it in the wallet first.
+
+```typescript
+const txid = await zcash.sendTransaction({
+  to: 'zs1XYZ...',
+  amount: '0.1'
+})
+```
+
+#### `signMessage(message)`
+
+Sign a message with the transparent address.
+
+**Params**: `message: string` - Message to sign
+
+**Returns**: `Promise<{ signature: string, pubkey: string, address: string }>`
+
+- `signature`: Hex-encoded ECDSA signature
+- `pubkey`: Hex-encoded public key
+- `address`: Transparent address used for signing
+
+**Note**: Message signing currently only supports transparent addresses.
+
+```typescript
+const result = await zcash.signMessage('Hello World')
+console.log('Signature:', result.signature)
+```
+
+#### `switchNetwork(network)`
+
+Switch between mainnet and testnet.
+
+**Params**: `network: 'mainnet' | 'testnet'`
+
+**Returns**: `Promise<boolean>`
+
+```typescript
+await zcash.switchNetwork('testnet')
+```
+
+### Utility Functions
+
+#### `publicKeyToAddress(pubkey, network)`
+
+Convert a public key to a Zcash transparent address.
+
+**Params**:
+
+- `pubkey: string` - Public key in hexadecimal format (compressed 33 bytes or uncompressed 65 bytes)
+- `network: 'mainnet' | 'testnet'` - Network type (defaults to 'mainnet')
+
+**Returns**: `string` - Zcash transparent address (P2PKH format)
+
+**Throws**: Error if public key format is invalid
+
+```typescript
+import { publicKeyToAddress } from '@noir-wallet/sdk'
+
+// Get public key from wallet
+const { pubkey } = await zcash.getPublicKey()
+
+// Convert to address for verification
+const address = publicKeyToAddress(pubkey, 'mainnet')
+console.log('Address:', address)
+
+// Convert external public key
+const externalPubkey = '03a1b2c3d4e5f6...'
+const externalAddress = publicKeyToAddress(externalPubkey, 'mainnet')
+```
+
+**Public Key Formats**:
+
+- Compressed (33 bytes): Starts with `02` or `03`
+- Uncompressed (65 bytes): Starts with `04`
+
+**Note**: This function implements the Bitcoin/Zcash P2PKH address generation algorithm (SHA256 → RIPEMD160 → Base58Check).
+
+### Events
+
+#### `accountsChanged`
+
+Triggered when accounts change (unlock/lock, switch account).
+
+**Data**: `ZcashAddress | null` - Current addresses (null if locked/disconnected)
+
+#### `chainChanged`
+
+Triggered when network changes.
+
+**Data**: `{ chainId: string, network: string }`
+
+## Types
+
+```typescript
+interface ZcashAddress {
+  transparent: string
+  shielded: string
+}
+
+interface Balance {
+  transparent: string
+  shielded: string
+  total?: string
+  available?: string // Precise max transferable amount
+}
+
+interface SendTransactionParams {
+  to: string
+  amount: string
+}
+
+interface SignMessageResult {
+  signature: string // Hex-encoded ECDSA signature
+  pubkey: string // Hex-encoded public key
+  address: string // Transparent address used for signing
+}
+
+type Network = 'mainnet' | 'testnet'
+```
+
+## Error Handling
+
+```typescript
+const noirWallet = getNoirWallet()
+if (!noirWallet) {
+  console.error('Please install Noir Wallet extension')
+  return
+}
+
+try {
+  await noirWallet.zcash.connect()
+} catch (error) {
+  if (error.code === 4001) {
+    console.error('User rejected the request')
+  } else {
+    console.error('Connection failed:', error.message)
+  }
+}
+```
+
+## License
+
+MIT

package/dist/chains/zcash/index.d.mts

@@ -0,0 +1,65 @@
+interface ZcashProvider {
+    request(args: RequestArguments): Promise<any>;
+    on(event: string, handler: (...args: any[]) => void): void;
+    removeListener?(event: string, handler: (...args: any[]) => void): void;
+    disconnect(): Promise<void>;
+}
+interface RequestArguments {
+    method: string;
+    params?: any[];
+}
+interface ZcashAddress {
+    transparent: string;
+    shielded: string;
+}
+interface Balance {
+    transparent: string;
+    shielded: string;
+    total?: string;
+    available?: 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$1 = 'mainnet' | 'testnet';
+
+declare class ZcashAPI {
+    private provider;
+    constructor(provider: ZcashProvider);
+    connect(): Promise<ZcashAddress>;
+    getAccounts(): Promise<ZcashAddress | null>;
+    getBalance(): Promise<Balance>;
+    getPublicKey(): Promise<{
+        pubkey: string;
+        address: string;
+    } | null>;
+    sendTransaction(params: SendTransactionParams): Promise<string>;
+    signMessage(message: string): Promise<SignMessageResult>;
+    switchNetwork(network: Network$1): Promise<boolean>;
+    disconnect(): Promise<void>;
+    on(event: string, handler: (...args: any[]) => void): void;
+    removeListener(event: string, handler: (...args: any[]) => void): void;
+}
+
+declare function getZcashProvider(): ZcashProvider | null;
+declare function detectProvider(timeout?: number): Promise<ZcashProvider>;
+declare function getProvider(): ZcashProvider | null;
+
+type Network = 'mainnet' | 'testnet';
+declare function publicKeyToAddress(pubkeyHex: string, network?: Network): string;
+
+export { type Balance, type Network$1 as Network, type RequestArguments, type SendTransactionParams, type SignMessageResult, type TransactionReceipt, ZcashAPI, type ZcashAddress, type ZcashProvider, detectProvider, getProvider, getZcashProvider, publicKeyToAddress };

package/dist/chains/zcash/index.d.ts

@@ -0,0 +1,65 @@
+interface ZcashProvider {
+    request(args: RequestArguments): Promise<any>;
+    on(event: string, handler: (...args: any[]) => void): void;
+    removeListener?(event: string, handler: (...args: any[]) => void): void;
+    disconnect(): Promise<void>;
+}
+interface RequestArguments {
+    method: string;
+    params?: any[];
+}
+interface ZcashAddress {
+    transparent: string;
+    shielded: string;
+}
+interface Balance {
+    transparent: string;
+    shielded: string;
+    total?: string;
+    available?: 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$1 = 'mainnet' | 'testnet';
+
+declare class ZcashAPI {
+    private provider;
+    constructor(provider: ZcashProvider);
+    connect(): Promise<ZcashAddress>;
+    getAccounts(): Promise<ZcashAddress | null>;
+    getBalance(): Promise<Balance>;
+    getPublicKey(): Promise<{
+        pubkey: string;
+        address: string;
+    } | null>;
+    sendTransaction(params: SendTransactionParams): Promise<string>;
+    signMessage(message: string): Promise<SignMessageResult>;
+    switchNetwork(network: Network$1): Promise<boolean>;
+    disconnect(): Promise<void>;
+    on(event: string, handler: (...args: any[]) => void): void;
+    removeListener(event: string, handler: (...args: any[]) => void): void;
+}
+
+declare function getZcashProvider(): ZcashProvider | null;
+declare function detectProvider(timeout?: number): Promise<ZcashProvider>;
+declare function getProvider(): ZcashProvider | null;
+
+type Network = 'mainnet' | 'testnet';
+declare function publicKeyToAddress(pubkeyHex: string, network?: Network): string;
+
+export { type Balance, type Network$1 as Network, type RequestArguments, type SendTransactionParams, type SignMessageResult, type TransactionReceipt, ZcashAPI, type ZcashAddress, type ZcashProvider, detectProvider, getProvider, getZcashProvider, publicKeyToAddress };

package/dist/chains/zcash/index.js

@@ -0,0 +1,221 @@
+"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/chains/zcash/index.ts
+var zcash_exports = {};
+__export(zcash_exports, {
+  ZcashAPI: () => ZcashAPI,
+  detectProvider: () => detectProvider,
+  getProvider: () => getProvider,
+  getZcashProvider: () => getZcashProvider,
+  publicKeyToAddress: () => publicKeyToAddress
+});
+module.exports = __toCommonJS(zcash_exports);
+
+// 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
+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,
+  getZcashProvider,
+  publicKeyToAddress
+});

package/dist/chains/zcash/index.mjs

@@ -0,0 +1,14 @@
+import {
+  ZcashAPI,
+  detectProvider,
+  getProvider,
+  getZcashProvider,
+  publicKeyToAddress
+} from "../../chunk-JG4K44MD.mjs";
+export {
+  ZcashAPI,
+  detectProvider,
+  getProvider,
+  getZcashProvider,
+  publicKeyToAddress
+};