add more snippets

pablof7z · pablof7z · commit f3902d8d4a38 · 2025-03-25T23:57:51.000Z
diff --git a/docs/markdown-examples.md b/docs/markdown-examples.md
diff --git a/docs/snippets/event/basic.md b/docs/snippets/event/basic.md
@@ -3,15 +3,16 @@
 NDK uses `NDKEvent` as the basic interface to generate and handle nostr events.
 
 ## Generating a basic event
+
 ```ts
-import { NDKEvent, NDKKind } from "@nostr-dev-kit/ndk";
+import NDK, { NDKEvent, NDKKind } from "@nostr-dev-kit/ndk";
 
-const ndk = new NDK( /* initialization options for the ndk singleton */ )
+const ndk = new NDK(/* initialization options for the ndk singleton */);
 
 const event = new NDKEvent(ndk, {
     kind: NDKKind.Text,
-    content: "Hello world"
-})
+    content: "Hello world",
+});
 ```
 
-There is no need to fill in the event's `id`, `tags`, `pubkey`, `created_at`, `sig` -- when these are empty, NDK will automatically fill them in with the appropriate values.
+There is no need to fill in the event's `id`, `tags`, `pubkey`, `created_at`, `sig` -- when these are empty, NDK will automatically fill them in with the appropriate values.
diff --git a/docs/snippets/event/signing-with-different-signers.md b/docs/snippets/event/signing-with-different-signers.md
@@ -0,0 +1,29 @@
+# Signing events with different signers
+
+NDK uses the default signer `ndk.signer` to sign events.
+
+But you can specify the use of a different signer to sign with different pubkeys.
+
+```ts
+import { NDKPrivateKeySigner, NDKEvent } from "@nostr-dev-kit/ndk";
+
+const signer1 = NDKPrivateKeySigner.generate();
+const pubkey1 = signer1.pubkey;
+
+const event1 = new NDKEvent();
+event1.kind = 1;
+event1.content = "Hello world";
+await event1.sign(signer1);
+
+event1.pubkey === pubkey1 // true
+
+const signer2 = NDKPrivateKeySigner.generate();
+const pubkey2 = signer2.pubkey;
+
+const event2 = new NDKEvent();
+event2.kind = 1;
+event2.content = "Hello world";
+await event2.sign(signer2);
+
+event2.pubkey === pubkey2 // true
+```
diff --git a/docs/snippets/index.md b/docs/snippets/index.md
@@ -21,3 +21,8 @@ Snippets are organized into the following categories:
         - [Rendering Event Content](./mobile/events/rendering-event-content.md) - Rich text rendering of Nostr event content with mentions, hashtags, and media
     - [Session](./mobile/session/)
         - [Login](./mobile/session/login.md) - Handle user authentication with NDK Mobile using various methods (NIP-46, nsec)
+- [Wallet](./wallet/)
+    - [Connect Nostr Wallet Connect](./wallet/connect-nwc.md) - Connect to an NWC wallet and set it up for zapping
+    - [Using Cashu Wallet](./wallet/using-cashu-wallet.md) - Create and use a Cashu wallet for managing e-cash tokens
+    - [Nutzap Monitor](./wallet/nutzap-monitor.md) - Track and process Cashu tokens sent via Nostr zaps
+    - [Cashu Deposits](./wallet/cashu-deposits.md) - Fund your Cashu wallet using Lightning invoices
diff --git a/docs/snippets/user/generate-keys.md b/docs/snippets/user/generate-keys.md
@@ -3,15 +3,18 @@
 This snippet demonstrates how to generate a new key pair and obtain all its various formats (private key, public key, nsec, npub).
 
 ```typescript
+import { NDKPrivateKeySigner } from "@nostr-dev-kit/ndk";
+
 const signer = NDKPrivateKeySigner.generate();
-const privateKey = signer.privateKey!;  // Get the hex private key
-const publicKey = signer.pubkey;        // Get the hex public key 
-const nsec = signer.nsec;               // Get the private key in nsec format
-const npub = signer.userSync.npub;          // Get the public key in npub format
+const privateKey = signer.privateKey!; // Get the hex private key
+const publicKey = signer.pubkey; // Get the hex public key
+const nsec = signer.nsec; // Get the private key in nsec format
+const npub = signer.userSync.npub; // Get the public key in npub format
 ```
 
 You can use these different formats for different purposes:
+
 - `privateKey`: Raw private key for cryptographic operations
 - `publicKey`: Raw public key (hex format) for verification
 - `nsec`: Encoded private key format (bech32) - used for secure sharing when needed
-- `npub`: Encoded public key format (bech32) - used for user identification 
+- `npub`: Encoded public key format (bech32) - used for user identification
diff --git a/docs/snippets/wallet/connect-nwc.md b/docs/snippets/wallet/connect-nwc.md
@@ -0,0 +1,47 @@
+# Connect Nostr Wallet Connect (NWC)
+
+This snippet demonstrates how to connect a Nostr Wallet Connect (NWC) wallet to NDK and use it for zapping.
+
+```typescript
+import NDK from "@nostr-dev-kit/ndk";
+import { 
+    NDKNWCWallet,
+    NDKWalletStatus
+} from "@nostr-dev-kit/ndk-wallet";
+
+// Connect using NWC pairing code
+// Format: nostr+walletconnect://{pubkey}?relay={relay_url}&secret={secret}
+const pairingCode = "nostr+walletconnect://npub...?relay=wss://relay.example.com&secret=nsec...";
+
+// Initialize NWC wallet with pairing code
+const wallet = new NDKNWCWallet(ndk, { 
+    pairingCode,
+    // Optional timeout for operations
+    timeout: 30000
+});
+
+// Set up event listeners
+wallet.on("ready", () => {
+    console.log("NWC wallet is ready for zapping");
+});
+
+// Listen for balance updates
+wallet.on("balance_updated", (balance) => {
+    console.log("Balance updated:", balance?.amount || 0, "sats");
+});
+
+// Assign wallet to NDK instance for zapping
+ndk.wallet = wallet;
+
+// Wait for wallet to be ready
+if (wallet.status !== NDKWalletStatus.READY) {
+    await new Promise<void>((resolve) => {
+        wallet.once("ready", () => resolve());
+    });
+}
+
+console.log("NWC wallet connected successfully");
+
+## Notes
+
+- The wallet must be assigned to the NDK instance with `ndk.wallet = wallet` for zaps to work properly
diff --git a/docs/snippets/wallet/using-cashu-wallet.md b/docs/snippets/wallet/using-cashu-wallet.md
@@ -0,0 +1,120 @@
+# Using a Cashu Wallet (NIP-60) with NDK
+
+This snippet demonstrates how to create, configure, and use an NDKCashuWallet for managing Cashu tokens.
+
+```typescript
+import NDK, { NDKKind, NDKCashuMintList } from "@nostr-dev-kit/ndk";
+import { NDKCashuWallet, NDKWalletStatus } from "@nostr-dev-kit/ndk-wallet";
+
+/**
+ * Example function to set up an NDKCashuWallet
+ */
+async function setupCashuWallet(ndk: NDK, mints: string[], relays: string[]) {
+    // Create the Cashu wallet instance
+    const wallet = new NDKCashuWallet(ndk);
+    
+    // Add mints to the wallet
+    wallet.mints = mints;
+    wallet.relays = relays;
+    
+    // Generate or load a p2pk (Pay-to-Public-Key) token
+    // This is used for receiving payments with NIP-61 (nutzaps)
+    const p2pk = await wallet.getP2pk();
+    console.log(`Wallet p2pk: ${p2pk}`);
+
+    await wallet.publish();
+    console.log('published the wallet event')
+
+    // configure reception of NIP-61 nutzaps for the user
+    // this publishes an event that tells others who want to zap
+    // this user the information they need to publish a NIP-61 nutzap.
+    const mintlistForNutzapReception = new NDKCashuMintList(ndk);
+    mintlistForNutzapReception.relays = wallet.relays;
+    mintlistForNutzapReception.mints = wallet.mints;
+    mintlistForNutzapReception.p2pk = wallet.p2pk;
+    await mintlistForNutzapReception.publish();
+    console.log('published he nutzap mintlist event to receive nutzaps', mintlistForNutzapReception.rawEvent())
+    
+    return wallet;
+}
+
+/**
+ * Get balance for a specific mint
+ */
+function getMintBalance(wallet: NDKCashuWallet, mintUrl: string) {
+    const balance = wallet.mintBalance(mintUrl);
+    console.log(`Balance for mint ${mintUrl}: ${balance} sats`);
+    return balance;
+}
+
+/**
+ * Check if the user already has a nutsack (NIP-60) wallet.
+ **/
+async function findExistingWallet(ndk: NDK): Promise<NDKCashuWallet | undefined> {
+    const activeUser = ndk.activeUser;
+
+    if (!activeUser) throw "we need a user first, set a signer in ndk";
+    
+    const event = await ndk.fetchEvent([
+        { kinds: [ NDKKind.CashuWallet], authors: [activeUser.pubkey] }
+    ])
+
+    // if we receive a CashuWallet event we load the wallet
+    if (event) return await NDKCashuWallet.from(event);
+}
+
+/**
+ * Example usage
+ */
+async function main() {
+    // we assume ndk is already connected and ready
+    // ...
+    
+    let wallet: NDKCashuWallet | undefined;
+
+    wallet = await findExistingWallet(ndk);
+    
+    // if we don't have a wallet, we create one
+    if (!wallet) {
+        // List of mints to use
+        const mints = [ "https://8333.space:3338" ];
+
+        // Setup the wallet
+        wallet = await setupCashuWallet(ndk, mints);
+    }
+
+    wallet.on("balance_updated", (balance) => {
+        console.log(`Wallet balance updated: ${balance?.amount} sats`);
+        // You might want to update your UI here
+    });
+
+    wallet.start();
+    
+    // Example: Check wallet balance
+    const totalBalance = wallet.balance?.amount || 0;
+    console.log(`Total wallet balance: ${totalBalance} sats`);
+    
+    // Example: Need to fund wallet?
+    // See the Cashu Deposits snippet for funding your wallet with lightning
+    
+    // Example: Get balance for specific mint
+    for (const mint of mints) {
+        getMintBalance(wallet, mint);
+    }
+    
+    // Note: For monitoring nutzaps, see the Nutzap Monitor snippet
+    
+    // Keep the connection open for monitoring
+    // In a real app, you'd use proper lifecycle management
+}
+```
+
+## Notes
+
+- The Cashu wallet implements the NIP-60 specification for Nostr eCash
+- The wallet needs to be assigned to the NDK instance with `ndk.wallet = wallet` for full integration
+- To receive tokens, you need to generate a p2pk (Pay-to-Public-Key) identifier
+- The wallet monitors and processes events continuously while active
+- Always handle wallet operations with proper error handling
+- For handling nutzaps (Cashu tokens sent via Nostr), see the Nutzap Monitor snippet
+- For depositing funds to your wallet, see the Cashu Deposits snippet 
diff --git a/docs/wallet/nutsack.md b/docs/wallet/nutsack.md
@@ -17,14 +17,13 @@ const ndk = new NDK({
 ndk.connect();
 
 // create a new NIP-60 wallet
-const unit = "sat"; // unit of the wallet
 const mints = [ 'https://testnut.cashu.space' ] // mints the wallet will use
 const relays = [ 'wss://f7z.io', 'ws://localhost:4040' ]; // relays where proofs will be stored
 const wallet = NDKCashuWallet.create(ndk, unit, mints, relays);
 await wallet.publish();
 ```
 
-This will publish a wallet `kind:37375` event, which contains the wallet information.
+This will publish a wallet `kind:17375` event, which contains the wallet information.
 
 We now have a NIP-60 wallet -- this wallet will be available from any nostr client that supports NIP-60.
 
diff --git a/ndk-core/src/signers/private-key/index.test.ts b/ndk-core/src/signers/private-key/index.test.ts
@@ -1,7 +1,7 @@
 import { generateSecretKey } from "nostr-tools";
-import NDK, { NDKEvent, type NostrEvent } from "../../index.js";
+import { type NostrEvent } from "../../index.js";
 import { NDKPrivateKeySigner } from "./index";
-import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+import { bytesToHex } from "@noble/hashes/utils";
 import { nip19 } from "nostr-tools";
 
 describe("NDKPrivateKeySigner", () => {
@@ -72,9 +72,5 @@ describe("NDKPrivateKeySigner", () => {
         expect(knownSigner.pubkey).toBe(
             "c44f2be1b2fb5371330386046e60207bbd84938d4812ee0c7a3c11be605a7585"
         );
-
-        // Test error case when signer is not ready
-        const emptySigner = new NDKPrivateKeySigner();
-        expect(() => emptySigner.pubkey).toThrow("Not ready");
     });
 });
diff --git a/ndk-core/src/signers/private-key/index.ts b/ndk-core/src/signers/private-key/index.ts
diff --git a/ndk-wallet/src/wallets/cashu/wallet/index.ts b/ndk-wallet/src/wallets/cashu/wallet/index.ts
