nwc-ruby 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d4c011d51eac1622cceede610301765731ca586ffddea5a3e99cbeba7fdd28e
-  data.tar.gz: 68b349cd70ae9d423111a6d4b04c3c6bf088e100a6cad066c93504b0cd078ca0
+  metadata.gz: eb3477afba784c35d4e2db68ea408f30efec1330516c24f368471b123dcc7ddc
+  data.tar.gz: aabf55cb7cbeb1263945e457aab8f2908f39e560f0297d7406adc31ba7e56a73
 SHA512:
-  metadata.gz: da57ea11db970c08836488cd99a617b85ddff08242facb3c5f2d5984957507ab87597f5b6d9844134550f46b209c97e13163345b2c419b2968392c486848a637
-  data.tar.gz: fb90130f2bdd51bb5e650e2b772979ce5573dcd19363d5a8bcebb5f5df17baab29c51401faea95fb9eca64ec06e5335078d95a373556664b715813b61e77730c
+  metadata.gz: 9c52a015142aec41f912b9f3881f56e5ce8289be0106f000be2786677320426e250ac73b70a9905c691e082ac293286caf169aac453af92886380053b7e34461
+  data.tar.gz: 73035a32f7fe34602f527f44941703ebecf7c505319f5e4899e8a6168350b2ae5d108f3be1e8c661d2854b05c087e752f44d6960a9f401ac880be0776d6a6166

data/CHANGELOG.md

@@ -7,6 +7,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] — 2026-10-20
+
+### Changed
+
+- **Each connection now derives its encryption key once, not on every
+  message.** NIP-04 and NIP-44 v2 both start from an ECDH that this gem runs
+  as pure-Ruby scalar multiplication: about 33 ms on an Apple-silicon laptop,
+  more on a typical server vCPU. Every request ran it twice (encrypting the
+  request, decrypting the response) and every notification once. The result
+  depends only on the client secret and the wallet pubkey, both fixed when the
+  connection string is parsed, so `ConnectionString#conversation` now computes
+  it on first use and keeps it. A `Client` reused across calls pays for ECDH
+  once in its lifetime. Nonces and IVs are still drawn fresh for every
+  message, and the wire format is unchanged.
+- A response that fails NIP-44 decryption and falls back to NIP-04 reuses the
+  same ECDH instead of running it a second time.
+
+### Added
+
+- `NwcRuby::Crypto::Conversation`: the NIP-04 and NIP-44 v2 keys for one
+  (private key, public key) pair, derived lazily and cached. A bad key raises
+  at first use, as before, and a failure is not cached.
+- `NIP44::Cipher.encrypt_with` / `decrypt_with` and
+  `NIP04::Cipher.encrypt_with` / `decrypt_with`, which take a `Conversation`
+  in place of the two hex keys. The existing `encrypt` / `decrypt` signatures
+  are unchanged.
+- An optional `conversation:` keyword on `NIP47::Request.build`,
+  `NIP47::Response.parse` and `NIP47::Notification.parse`.
+- Specs against paulmillr's `get_conversation_key` and `encrypt_decrypt`
+  NIP-44 vectors.
+
 ## [0.3.1] — 2026-10-05
 
 ### Fixed

data/README.md

@@ -528,6 +528,11 @@ the request is written to the relay are retried across every `relay` in the
 connection string, with 0.25 s / 1 s backoff, inside `request_timeout`.
 Nothing is ever retried after the request is written.
 
+Build one `Client` per connection string and reuse it. It caches the wallet's
+info event and the connection's encryption key, so only its first call pays
+for the ECDH (tens of milliseconds in pure Ruby); a `Client` built per request
+pays it on every call.
+
 Introspection:
 
 | Method            | Returns                                  |

data/lib/nwc_ruby/client.rb

@@ -207,7 +207,8 @@ module NwcRuby
         last_seen_at = event.created_at if event.created_at && event.created_at > last_seen_at
 
         begin
-          notification = NIP47::Notification.parse(event, @connection_string.secret, @connection_string.wallet_pubkey)
+          notification = NIP47::Notification.parse(event, @connection_string.secret, @connection_string.wallet_pubkey,
+                                                   conversation: @connection_string.conversation)
         rescue EncryptionError => e
           @logger.warn("[nwc] could not decrypt notification: #{e.message}")
           next
@@ -282,7 +283,8 @@ module NwcRuby
         params: params,
         client_privkey: @connection_string.secret,
         wallet_pubkey: @connection_string.wallet_pubkey,
-        encryption: @info.preferred_encryption
+        encryption: @info.preferred_encryption,
+        conversation: @connection_string.conversation
       )
 
       response = with_relays(deadline) { |url| send_request(url, deadline, method, request_event) }
@@ -328,7 +330,8 @@ module NwcRuby
         event = relay_event(parsed, sub_id)
         next unless event && event.kind == NIP47::Methods::KIND_RESPONSE && response_to?(event, request_id)
 
-        return NIP47::Response.parse(event, @connection_string.secret, @connection_string.wallet_pubkey)
+        return NIP47::Response.parse(event, @connection_string.secret, @connection_string.wallet_pubkey,
+                                     conversation: @connection_string.conversation)
       end
       raise TransportError, 'relay closed the connection before the wallet responded'
     end

data/lib/nwc_ruby/connection_string.rb

@@ -53,6 +53,13 @@ module NwcRuby
       @client_pubkey ||= Crypto::Keys.public_key_from_private(@secret)
     end
 
+    # Encryption keys for this client/wallet pair. Both inputs are fixed at
+    # parse time, so the ECDH behind them runs once per connection string
+    # rather than on every request, response and notification.
+    def conversation
+      @conversation ||= Crypto::Conversation.new(@secret, @wallet_pubkey)
+    end
+
     def to_s
       params = { 'relay' => @relays, 'secret' => [@secret] }
       params['lud16'] = [@lud16] if @lud16

data/lib/nwc_ruby/crypto/conversation.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module NwcRuby
+  module Crypto
+    # The symmetric keys for one (our private key, their public key) pair.
+    #
+    # NIP-04 and NIP-44 v2 both start from the same ECDH, which is the slow
+    # step here (pure-Ruby scalar multiplication, tens of milliseconds) and
+    # depends only on the two keys. This object runs it once, on first use,
+    # and keeps the result. Per-message randomness is unaffected: NIP-44 still
+    # draws a fresh nonce and NIP-04 a fresh IV on every encrypt.
+    #
+    # Nothing is computed in `initialize`, so a bad key raises at first use,
+    # exactly where the uncached path raises it, and a failure is not cached.
+    class Conversation
+      def initialize(privkey_hex, pubkey_hex)
+        @privkey_hex = privkey_hex
+        @pubkey_hex  = pubkey_hex
+      end
+
+      # NIP-04's AES-256 key: the raw shared X coordinate.
+      def nip04_key
+        @nip04_key ||= ECDH.shared_x(@privkey_hex, @pubkey_hex)
+      end
+
+      # NIP-44 v2's conversation key: HKDF-extract over the same shared X.
+      def nip44_key
+        @nip44_key ||= NIP44::Cipher.hkdf_extract(NIP44::Cipher::SALT.b, nip04_key)
+      end
+    end
+  end
+end

data/lib/nwc_ruby/nip04/cipher.rb

@@ -14,11 +14,17 @@ module NwcRuby
       module_function
 
       def encrypt(plaintext, privkey_hex, pubkey_hex)
-        key = Crypto::ECDH.shared_x(privkey_hex, pubkey_hex)
-        iv  = SecureRandom.bytes(16)
+        encrypt_with(plaintext, Crypto::Conversation.new(privkey_hex, pubkey_hex))
+      end
+
+      # `encrypt`, reusing the conversation's cached key instead of redoing ECDH.
+      #
+      # @param conversation [Crypto::Conversation]
+      def encrypt_with(plaintext, conversation)
+        iv = SecureRandom.bytes(16)
 
         cipher = OpenSSL::Cipher.new('aes-256-cbc').encrypt
-        cipher.key = key
+        cipher.key = conversation.nip04_key
         cipher.iv  = iv
         ct = cipher.update(plaintext.encode('UTF-8')) + cipher.final
 
@@ -26,6 +32,14 @@ module NwcRuby
       end
 
       def decrypt(payload, privkey_hex, pubkey_hex)
+        decrypt_with(payload, Crypto::Conversation.new(privkey_hex, pubkey_hex))
+      end
+
+      # `decrypt`, reusing the conversation's cached key instead of redoing
+      # ECDH. The payload is checked before the key is touched.
+      #
+      # @param conversation [Crypto::Conversation]
+      def decrypt_with(payload, conversation)
         raise EncryptionError, 'malformed NIP-04 payload' unless payload.include?('?iv=')
 
         ct_b64, iv_b64 = payload.split('?iv=', 2)
@@ -33,10 +47,8 @@ module NwcRuby
         iv = Base64.strict_decode64(iv_b64)
         raise EncryptionError, 'invalid IV length' unless iv.bytesize == 16
 
-        key = Crypto::ECDH.shared_x(privkey_hex, pubkey_hex)
-
         cipher = OpenSSL::Cipher.new('aes-256-cbc').decrypt
-        cipher.key = key
+        cipher.key = conversation.nip04_key
         cipher.iv  = iv
         (cipher.update(ct) + cipher.final).force_encoding('UTF-8')
       rescue OpenSSL::Cipher::CipherError, ArgumentError => e

data/lib/nwc_ruby/nip44/cipher.rb

@@ -37,12 +37,19 @@ module NwcRuby
       # @param nonce [String, nil] optional 32-byte nonce (for tests); random if nil
       # @return [String] base64 payload
       def encrypt(plaintext, privkey_hex, pubkey_hex, nonce: nil)
+        encrypt_with(plaintext, Crypto::Conversation.new(privkey_hex, pubkey_hex), nonce: nonce)
+      end
+
+      # `encrypt`, reusing the conversation's cached key instead of redoing ECDH.
+      #
+      # @param conversation [Crypto::Conversation]
+      def encrypt_with(plaintext, conversation, nonce: nil)
         pt_bytes = plaintext.to_s.dup.force_encoding('UTF-8').b
         if pt_bytes.bytesize < MIN_PLAINTEXT || pt_bytes.bytesize > MAX_PLAINTEXT
           raise EncryptionError, 'plaintext length must be 1..65535 bytes'
         end
 
-        conversation_key = derive_conversation_key(privkey_hex, pubkey_hex)
+        conversation_key = conversation.nip44_key
         nonce ||= SecureRandom.bytes(32)
         raise EncryptionError, 'nonce must be 32 bytes' unless nonce.bytesize == 32
 
@@ -56,7 +63,16 @@ module NwcRuby
 
       # @param payload [String] base64 NIP-44 payload
       # @return [String] UTF-8 plaintext
-      def decrypt(payload, privkey_hex, pubkey_hex) # rubocop:disable Metrics/AbcSize
+      def decrypt(payload, privkey_hex, pubkey_hex)
+        decrypt_with(payload, Crypto::Conversation.new(privkey_hex, pubkey_hex))
+      end
+
+      # `decrypt`, reusing the conversation's cached key instead of redoing
+      # ECDH. The payload is fully checked before the key is touched, so a
+      # malformed one is rejected without paying for ECDH.
+      #
+      # @param conversation [Crypto::Conversation]
+      def decrypt_with(payload, conversation) # rubocop:disable Metrics/AbcSize
         raise EncryptionError, 'payload is nil or empty' if payload.nil? || payload.empty?
         raise EncryptionError, "payload starts with '#' (not encrypted)" if payload.start_with?('#')
 
@@ -77,8 +93,7 @@ module NwcRuby
         mac        = raw.byteslice(raw.bytesize - 32, 32)
         ciphertext = raw.byteslice(33, raw.bytesize - 33 - 32)
 
-        conversation_key = derive_conversation_key(privkey_hex, pubkey_hex)
-        chacha_key, chacha_nonce, hmac_key = derive_message_keys(conversation_key, nonce)
+        chacha_key, chacha_nonce, hmac_key = derive_message_keys(conversation.nip44_key, nonce)
 
         expected_mac = OpenSSL::HMAC.digest('SHA256', hmac_key, nonce + ciphertext)
         raise EncryptionError, 'NIP-44 MAC verification failed' unless secure_compare(mac, expected_mac)
@@ -90,8 +105,7 @@ module NwcRuby
       # --- Internals ------------------------------------------------------
 
       def derive_conversation_key(privkey_hex, pubkey_hex)
-        shared = Crypto::ECDH.shared_x(privkey_hex, pubkey_hex)
-        hkdf_extract(SALT.b, shared)
+        Crypto::Conversation.new(privkey_hex, pubkey_hex).nip44_key
       end
 
       def derive_message_keys(conversation_key, nonce)

data/lib/nwc_ruby/nip47/notification.rb

@@ -32,12 +32,15 @@ module NwcRuby
         @type == 'payment_sent'
       end
 
-      def self.parse(event, client_privkey, wallet_pubkey)
+      # @param conversation [Crypto::Conversation, nil] cached keys for this
+      #   client/wallet pair; derived from the two keys when nil
+      def self.parse(event, client_privkey, wallet_pubkey, conversation: nil)
+        conversation ||= Crypto::Conversation.new(client_privkey, wallet_pubkey)
         plaintext = case event.kind
                     when Methods::KIND_NOTIFICATION_NIP44
-                      NIP44::Cipher.decrypt(event.content, client_privkey, wallet_pubkey)
+                      NIP44::Cipher.decrypt_with(event.content, conversation)
                     when Methods::KIND_NOTIFICATION_NIP04
-                      NIP04::Cipher.decrypt(event.content, client_privkey, wallet_pubkey)
+                      NIP04::Cipher.decrypt_with(event.content, conversation)
                     else
                       raise ArgumentError, "not a notification kind: #{event.kind}"
                     end

data/lib/nwc_ruby/nip47/request.rb

@@ -13,12 +13,16 @@ module NwcRuby
       # @param wallet_pubkey [String] hex
       # @param encryption [Symbol] :nip44_v2 or :nip04
       # @param expiration [Integer, nil] optional unix timestamp
+      # @param conversation [Crypto::Conversation, nil] cached keys for this
+      #   client/wallet pair; derived from the two keys above when nil
       # @return [Event]
-      def build(method:, params:, client_privkey:, wallet_pubkey:, encryption: :nip44_v2, expiration: nil)
+      def build(method:, params:, client_privkey:, wallet_pubkey:, encryption: :nip44_v2, expiration: nil,
+                conversation: nil)
+        conversation ||= Crypto::Conversation.new(client_privkey, wallet_pubkey)
         payload = JSON.generate({ 'method' => method, 'params' => params })
         ciphertext = case encryption
-                     when :nip44_v2 then NIP44::Cipher.encrypt(payload, client_privkey, wallet_pubkey)
-                     when :nip04    then NIP04::Cipher.encrypt(payload, client_privkey, wallet_pubkey)
+                     when :nip44_v2 then NIP44::Cipher.encrypt_with(payload, conversation)
+                     when :nip04    then NIP04::Cipher.encrypt_with(payload, conversation)
                      else raise ArgumentError, "unknown encryption: #{encryption}"
                      end
 

data/lib/nwc_ruby/nip47/response.rb

@@ -29,13 +29,16 @@ module NwcRuby
       # @param event [Event] the kind 23195 event (already signature-verified)
       # @param client_privkey [String] hex
       # @param wallet_pubkey [String] hex
+      # @param conversation [Crypto::Conversation, nil] cached keys for this
+      #   client/wallet pair; derived from the two keys above when nil
       # @return [Response]
-      def self.parse(event, client_privkey, wallet_pubkey)
+      def self.parse(event, client_privkey, wallet_pubkey, conversation: nil)
         # Tags: ["p", client_pubkey], ["e", request_event_id]
         e_tag = event.tags.find { |t| t[0] == 'e' }
         request_id = e_tag && e_tag[1]
 
-        plaintext = decrypt(event.content, client_privkey, wallet_pubkey)
+        conversation ||= Crypto::Conversation.new(client_privkey, wallet_pubkey)
+        plaintext = decrypt_with(event.content, conversation)
         data = JSON.parse(plaintext)
 
         new(
@@ -47,11 +50,17 @@ module NwcRuby
         )
       end
 
-      # Try NIP-44 v2 first; fall back to NIP-04 if the version byte is wrong.
       def self.decrypt(content, client_privkey, wallet_pubkey)
-        NIP44::Cipher.decrypt(content, client_privkey, wallet_pubkey)
+        decrypt_with(content, Crypto::Conversation.new(client_privkey, wallet_pubkey))
+      end
+
+      # Try NIP-44 v2 first; fall back to NIP-04 if the version byte is wrong.
+      # Both attempts share the conversation, so the fallback reuses any ECDH
+      # the NIP-44 attempt already ran.
+      def self.decrypt_with(content, conversation)
+        NIP44::Cipher.decrypt_with(content, conversation)
       rescue EncryptionError
-        NIP04::Cipher.decrypt(content, client_privkey, wallet_pubkey)
+        NIP04::Cipher.decrypt_with(content, conversation)
       end
     end
   end

data/lib/nwc_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NwcRuby
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 end

data/lib/nwc_ruby.rb

@@ -12,6 +12,7 @@ require_relative 'nwc_ruby/errors'
 require_relative 'nwc_ruby/crypto/keys'
 require_relative 'nwc_ruby/crypto/schnorr'
 require_relative 'nwc_ruby/crypto/ecdh'
+require_relative 'nwc_ruby/crypto/conversation'
 require_relative 'nwc_ruby/nip04/cipher'
 require_relative 'nwc_ruby/nip44/cipher'
 require_relative 'nwc_ruby/event'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nwc-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - MegalithicBTC
@@ -183,6 +183,7 @@ files:
 - lib/nwc_ruby.rb
 - lib/nwc_ruby/client.rb
 - lib/nwc_ruby/connection_string.rb
+- lib/nwc_ruby/crypto/conversation.rb
 - lib/nwc_ruby/crypto/ecdh.rb
 - lib/nwc_ruby/crypto/keys.rb
 - lib/nwc_ruby/crypto/schnorr.rb
@@ -222,7 +223,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby client for Nostr Wallet Connect (NIP-47) with safe long-running relay
   connections.