secp256k1rb 0.3.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a26cd2beaa9525ea8f7a0db0e411dbb3d049ec976214f4651e787f02ed76f83
-  data.tar.gz: 05c9fce673e0f97e48faa60335cb5de37a3be74a12c50f5cfc541621c11526f2
+  metadata.gz: ecd7e009765f35dce95f533c357900c4a7c4d6018cbd1f9dd3139af22b4e7c85
+  data.tar.gz: 0f6868a1f010cbca12e4ef7b4efe66713ae46fa6a28faf958dc3ee0ec529c8a9
 SHA512:
-  metadata.gz: 71dbb792ccefcf0a852ff5ff96173c2f7c784cff9313489782b03159dd0163860938435d66ec974cccf7fe3755b5bd1ded9bbdf20a77a9d4d41bc2a6b65d63f9
-  data.tar.gz: b5e36b1dae73beb4c7e2420efb792c9185fa08f96acbbd2090b5858fc305b88bd9b8a42197900bf1dfea9d1ff9c4b754d491719a63754e817c1c1854969b3db9
+  metadata.gz: b498f4d026083bd102410e7a8fff7cf2cb59b7f9b0f7033e0bcad9838d9e5fe718f87b9a2c9f8cb2f23439c66a4c612969d6f011fe00c24ce1a426c4a065c661
+  data.tar.gz: 5f1ae0a7a15d18af2c92d35ac93718c5f5d3733fd8236197277d7ba03bef3efb370560671f704f34b7b80d3ae61d80b3fc953a8b88246a4520152ab322b435b1

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## [Unreleased]
 
+## [0.8.0]
+
+- Change versioning policy: the gem's major and minor version now match the
+  supported secp256k1 version. Patch releases are used for gem-side changes.
+- Support secp256k1 v0.8.0.
+- Add `Secp256k1::SilentPayments` module (BIP-352 Silent Payments):
+  `silentpayments_sender_create_outputs`, `silentpayments_create_label`,
+  `silentpayments_create_labeled_spend_pubkey`, `silentpayments_create_prevouts_summary` and
+  `silentpayments_scan_outputs`. Tested against the official BIP-352 test vectors.
+  The silentpayments bindings (and `secp256k1_context_set_sha256_compression`) are attached
+  optionally, so the gem remains loadable with older libsecp256k1 (e.g. v0.7.x) where these
+  features raise `Secp256k1::Error`. Availability can be checked with `silentpayments_available?`.
+- Add FFI binding for `secp256k1_context_set_sha256_compression`.
+- Remove FFI binding for `secp256k1_schnorrsig_sign` which was removed in secp256k1 v0.8.0.
+  Use `secp256k1_schnorrsig_sign32` instead.
+- Fix `generate_pubkey` to return a wrong public key when a binary private key
+  happens to consist of hexadecimal characters (the key was converted twice).
+
 ## [0.3.0]
 
 - Support secp256k1 v0.7.1.

data/Gemfile

@@ -8,3 +8,4 @@ gemspec
 gem "rake", "~> 13.0"
 gem "rspec", "~> 3.0"
 gem "csv", '~> 3.3'
+gem "bech32", "~> 1.5"

data/README.md

@@ -46,9 +46,20 @@ In addition, the following modules are also included, so you can use them as the
 * [SchnorrSig](https://www.rubydoc.info/gems/secp256k1rb/Secp256k1/SchnorrSig)
 * [MuSig](https://www.rubydoc.info/gems/secp256k1rb/Secp256k1/MuSig)
 * [EllSwift](https://www.rubydoc.info/gems/secp256k1rb/Secp256k1/EllSwift)
+* [SilentPayments](https://www.rubydoc.info/gems/secp256k1rb/Secp256k1/SilentPayments)
 
 ### Compatibility
 
+Since v0.8.0, the major and minor version of this gem matches the supported
+secp256k1 version (e.g. secp256k1rb v0.8.x supports secp256k1 v0.8.x).
+Patch releases are used for gem-side changes.
+
+The gem also loads with older libsecp256k1 versions; features that require a newer
+library (e.g. the silentpayments module) raise `Secp256k1::Error` when used.
+Use `silentpayments_available?` to check availability at runtime.
+
+Older versions:
+
 secp256k1 version | secp256k1rb version
 :---:|:---:
 v0.4.0 | v0.1.x

data/lib/secp256k1/c.rb

@@ -45,7 +45,6 @@ module Secp256k1
     attach_function(:secp256k1_ecdsa_signature_normalize, [:pointer, :pointer, :pointer], :int)
     attach_function(:secp256k1_ecdsa_verify, [:pointer, :pointer, :pointer, :pointer], :int)
     attach_function(:secp256k1_schnorrsig_sign32, [:pointer, :pointer, :pointer, :pointer, :pointer], :int)
-    attach_function(:secp256k1_schnorrsig_sign, [:pointer, :pointer, :pointer, :pointer, :pointer], :int)
     attach_function(:secp256k1_schnorrsig_sign_custom, [:pointer, :pointer, :pointer, :size_t, :pointer, :pointer], :int)
     attach_function(:secp256k1_schnorrsig_verify, [:pointer, :pointer, :pointer, :size_t, :pointer], :int)
     attach_function(:secp256k1_keypair_create, [:pointer, :pointer, :pointer], :int)
@@ -94,6 +93,42 @@ module Secp256k1
     attach_function(:secp256k1_musig_partial_sig_verify, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int)
     attach_function(:secp256k1_musig_partial_sig_agg, [:pointer, :pointer, :pointer, :pointer, :size_t], :int)
 
+    # The following functions only exist in libsecp256k1 v0.8.0 or later, so they are
+    # attached optionally to keep this gem loadable with older libraries.
+
+    # for SilentPayments module
+    SILENTPAYMENTS_AVAILABLE = begin
+      attach_function(:secp256k1_silentpayments_sender_create_outputs, [:pointer, :pointer, :pointer, :size_t, :pointer, :pointer, :size_t, :pointer, :size_t], :int)
+      attach_function(:secp256k1_silentpayments_recipient_label_parse, [:pointer, :pointer, :pointer], :int)
+      attach_function(:secp256k1_silentpayments_recipient_label_serialize, [:pointer, :pointer, :pointer], :int)
+      attach_function(:secp256k1_silentpayments_recipient_label_create, [:pointer, :pointer, :pointer, :pointer, :uint32], :int)
+      attach_function(:secp256k1_silentpayments_recipient_create_labeled_spend_pubkey, [:pointer, :pointer, :pointer, :pointer], :int)
+      attach_function(:secp256k1_silentpayments_recipient_prevouts_summary_create, [:pointer, :pointer, :pointer, :pointer, :size_t, :pointer, :size_t], :int)
+      attach_function(:secp256k1_silentpayments_recipient_scan_outputs, [:pointer, :pointer, :pointer, :pointer, :size_t, :pointer, :pointer, :pointer, :pointer, :pointer], :int)
+      true
+    rescue FFI::NotFoundError
+      false
+    end
+
+    SHA256_COMPRESSION_AVAILABLE = begin
+      attach_function(:secp256k1_context_set_sha256_compression, [:pointer, :pointer], :void)
+      true
+    rescue FFI::NotFoundError
+      false
+    end
+
+    # Whether the loaded libsecp256k1 supports the silentpayments module.
+    # @return [Boolean]
+    def self.silentpayments_available?
+      SILENTPAYMENTS_AVAILABLE
+    end
+
+    # Whether the loaded libsecp256k1 supports secp256k1_context_set_sha256_compression.
+    # @return [Boolean]
+    def self.sha256_compression_available?
+      SHA256_COMPRESSION_AVAILABLE
+    end
+
     # Pointer to secp256k1_ellswift_xdh_hash_function_bip324 constant.
     # @return [FFI::Pointer]
     def self.ellswift_xdh_hash_function_bip324

data/lib/secp256k1/silentpayments.rb

@@ -0,0 +1,319 @@
+module Secp256k1
+
+  # Silent Payments module (BIP-352).
+  # This module provides elliptic-curve operations required for sending and
+  # receiving Silent Payments. Note that this is not a full implementation of
+  # BIP-352; higher-level concepts like addresses, output script types or
+  # transactions must be handled by the caller.
+  # @example
+  #   include Secp256k1
+  #
+  #   # Sender side:
+  #   outputs = silentpayments_sender_create_outputs(
+  #     [[scan_pubkey, spend_pubkey]], outpoint_smallest, plain_seckeys: [seckey])
+  #
+  #   # Recipient side:
+  #   prevouts_summary = silentpayments_create_prevouts_summary(
+  #     outpoint_smallest, plain_pubkeys: [pubkey])
+  #   found = silentpayments_scan_outputs(
+  #     outputs, scan_key, prevouts_summary, spend_pubkey)
+  module SilentPayments
+
+    # Size of a serialized Silent Payments label.
+    SP_LABEL_SIZE = 33
+    # Size of an internal Silent Payments label object.
+    SP_LABEL_INTERNAL_SIZE = 68
+    # Size of a Silent Payments prevouts summary object.
+    SP_PREVOUTS_SUMMARY_SIZE = 101
+    # Maximum number of recipients sharing the same scan public key (BIP-352).
+    SP_RECIPIENT_GROUP_LIMIT = 2323
+
+    # Struct mirroring secp256k1_silentpayments_recipient.
+    class Recipient < FFI::Struct
+      layout :scan_pubkey, [:uchar, 64],
+             :spend_pubkey, [:uchar, 64],
+             :index, :size_t
+    end
+
+    # Struct mirroring secp256k1_silentpayments_found_output.
+    class FoundOutput < FFI::Struct
+      layout :output, [:uchar, 64],
+             :tweak, [:uchar, 32],
+             :found_with_label, :int,
+             :label, [:uchar, SP_LABEL_INTERNAL_SIZE]
+    end
+
+    # Whether the loaded libsecp256k1 supports the silentpayments module.
+    # The module is available in libsecp256k1 v0.8.0 or later.
+    # @return [Boolean]
+    def silentpayments_available?
+      C.silentpayments_available?
+    end
+
+    # Create Silent Payments outputs for recipient(s) (sender side).
+    # @param [Array] recipients An array of recipient's key pair. Each element is an array of
+    #   scan public key and (labeled) spend public key with hex format(33 bytes each).
+    # @param [String] outpoint_smallest The smallest outpoint lexicographically from the transaction inputs(36 bytes).
+    # @param [Array] plain_seckeys (Optional) An array of private keys of non-taproot inputs with hex format(32 bytes each).
+    # @param [Array] taproot_seckeys (Optional) An array of private keys of taproot inputs with hex format(32 bytes each).
+    # @return [Array] An array of x-only public keys(hex format) for the taproot outputs, ordered same as +recipients+.
+    # @raise [Secp256k1::Error] If creation failed.
+    # @raise [ArgumentError] If invalid arguments specified.
+    def silentpayments_sender_create_outputs(recipients, outpoint_smallest, plain_seckeys: [], taproot_seckeys: [])
+      check_silentpayments_support!
+      raise ArgumentError, "recipients must be an Array." unless recipients.is_a?(Array)
+      raise ArgumentError, "recipients must not be empty." if recipients.empty?
+      plain_seckeys ||= []
+      taproot_seckeys ||= []
+      raise ArgumentError, "plain_seckeys must be an Array." unless plain_seckeys.is_a?(Array)
+      raise ArgumentError, "taproot_seckeys must be an Array." unless taproot_seckeys.is_a?(Array)
+      if plain_seckeys.empty? && taproot_seckeys.empty?
+        raise ArgumentError, "At least one private key(plain_seckeys or taproot_seckeys) is required."
+      end
+      validate_string!("outpoint_smallest", outpoint_smallest, 36)
+
+      with_context do |context|
+        recipient_structs = recipients.each_with_index.map do |recipient, i|
+          scan_pubkey, spend_pubkey = recipient
+          validate_string!("scan_pubkey", scan_pubkey, 33)
+          validate_string!("spend_pubkey", spend_pubkey, 33)
+          st = Recipient.new
+          st.pointer.put_bytes(0, parse_pubkey_internal(context, hex2bin(scan_pubkey)).read_string(64))
+          st.pointer.put_bytes(64, parse_pubkey_internal(context, hex2bin(spend_pubkey)).read_string(64))
+          st[:index] = i
+          st
+        end
+        recipients_ptr = FFI::MemoryPointer.new(:pointer, recipient_structs.length)
+        recipients_ptr.write_array_of_pointer(recipient_structs.map(&:pointer))
+
+        generated_outputs = Array.new(recipients.length) { FFI::MemoryPointer.new(:uchar, 64) }
+        generated_outputs_ptr = FFI::MemoryPointer.new(:pointer, generated_outputs.length)
+        generated_outputs_ptr.write_array_of_pointer(generated_outputs)
+
+        outpoint_ptr = FFI::MemoryPointer.new(:uchar, 36).put_bytes(0, hex2bin(outpoint_smallest))
+
+        keypairs = taproot_seckeys.map do |sk|
+          validate_string!("taproot_seckey", sk, 32)
+          seckey = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, hex2bin(sk))
+          keypair = FFI::MemoryPointer.new(:uchar, 96)
+          raise Error, "taproot_seckey is invalid." unless secp256k1_keypair_create(context, keypair, seckey) == 1
+          keypair
+        end
+        keypairs_ptr = if keypairs.empty?
+                         nil
+                       else
+                         FFI::MemoryPointer.new(:pointer, keypairs.length).write_array_of_pointer(keypairs)
+                       end
+
+        seckeys = plain_seckeys.map do |sk|
+          validate_string!("plain_seckey", sk, 32)
+          FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, hex2bin(sk))
+        end
+        seckeys_ptr = if seckeys.empty?
+                        nil
+                      else
+                        FFI::MemoryPointer.new(:pointer, seckeys.length).write_array_of_pointer(seckeys)
+                      end
+
+        result = secp256k1_silentpayments_sender_create_outputs(
+          context, generated_outputs_ptr, recipients_ptr, recipients.length, outpoint_ptr,
+          keypairs_ptr, keypairs.length, seckeys_ptr, seckeys.length)
+        raise Error, "secp256k1_silentpayments_sender_create_outputs failed." unless result == 1
+
+        generated_outputs.map { |output| serialize_xonly_pubkey_internal(context, output) }
+      end
+    end
+
+    # Create Silent Payments label tweak and label(recipient side).
+    # @param [String] scan_key The recipient's scan key with hex format(32 bytes).
+    # @param [Integer] m The integer for the m-th label (0 is used for change outputs).
+    # @return [Array(String)] An array of serialized label(33 bytes) and label tweak(32 bytes) with hex format.
+    # @raise [Secp256k1::Error] If creation failed.
+    # @raise [ArgumentError] If invalid arguments specified.
+    def silentpayments_create_label(scan_key, m)
+      check_silentpayments_support!
+      validate_string!("scan_key", scan_key, 32)
+      raise ArgumentError, "m must be Integer." unless m.is_a?(Integer)
+      raise ArgumentError, "m must be between 0 and 2**32-1." if m < 0 || m > 0xffffffff
+
+      with_context do |context|
+        label = FFI::MemoryPointer.new(:uchar, SP_LABEL_INTERNAL_SIZE)
+        label_tweak = FFI::MemoryPointer.new(:uchar, 32)
+        scan_key_ptr = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, hex2bin(scan_key))
+        result = secp256k1_silentpayments_recipient_label_create(context, label, label_tweak, scan_key_ptr, m)
+        raise Error, "secp256k1_silentpayments_recipient_label_create failed." unless result == 1
+        out33 = FFI::MemoryPointer.new(:uchar, SP_LABEL_SIZE)
+        secp256k1_silentpayments_recipient_label_serialize(context, out33, label)
+        [out33.read_string(SP_LABEL_SIZE).unpack1('H*'), label_tweak.read_string(32).unpack1('H*')]
+      end
+    end
+
+    # Create Silent Payments labeled spend public key(recipient side).
+    # @param [String] spend_pubkey The recipient's unlabeled spend public key with hex format(33 bytes).
+    # @param [String] label The serialized label with hex format(33 bytes).
+    # @return [String] The labeled spend public key with hex format(33 bytes).
+    # @raise [Secp256k1::Error] If creation failed.
+    # @raise [ArgumentError] If invalid arguments specified.
+    def silentpayments_create_labeled_spend_pubkey(spend_pubkey, label)
+      check_silentpayments_support!
+      validate_string!("spend_pubkey", spend_pubkey, 33)
+      validate_string!("label", label, SP_LABEL_SIZE)
+
+      with_context do |context|
+        spend_pubkey_ptr = parse_pubkey_internal(context, hex2bin(spend_pubkey))
+        label_ptr = parse_label_internal(context, hex2bin(label))
+        labeled = FFI::MemoryPointer.new(:uchar, 64)
+        result = secp256k1_silentpayments_recipient_create_labeled_spend_pubkey(context, labeled, spend_pubkey_ptr, label_ptr)
+        raise Error, "secp256k1_silentpayments_recipient_create_labeled_spend_pubkey failed." unless result == 1
+        serialize_pubkey_internal(context, labeled, true)
+      end
+    end
+
+    # Compute Silent Payments prevouts summary from prevout public keys and transaction inputs(recipient side).
+    # @param [String] outpoint_smallest The smallest outpoint lexicographically from the transaction inputs(36 bytes).
+    # @param [Array] plain_pubkeys (Optional) An array of public keys of non-taproot inputs with hex format(33 bytes each).
+    # @param [Array] xonly_pubkeys (Optional) An array of x-only public keys of taproot inputs with hex format(32 bytes each).
+    # @return [String] The prevouts summary data with hex format(101 bytes).
+    #   Note that this is an opaque representation which is not guaranteed to be
+    #   portable between different platforms or library versions.
+    # @raise [Secp256k1::Error] If the transaction is not a Silent Payments transaction.
+    # @raise [ArgumentError] If invalid arguments specified.
+    def silentpayments_create_prevouts_summary(outpoint_smallest, plain_pubkeys: [], xonly_pubkeys: [])
+      check_silentpayments_support!
+      plain_pubkeys ||= []
+      xonly_pubkeys ||= []
+      raise ArgumentError, "plain_pubkeys must be an Array." unless plain_pubkeys.is_a?(Array)
+      raise ArgumentError, "xonly_pubkeys must be an Array." unless xonly_pubkeys.is_a?(Array)
+      if plain_pubkeys.empty? && xonly_pubkeys.empty?
+        raise ArgumentError, "At least one public key(plain_pubkeys or xonly_pubkeys) is required."
+      end
+      validate_string!("outpoint_smallest", outpoint_smallest, 36)
+
+      with_context do |context|
+        xonly_ptrs = xonly_pubkeys.map do |pubkey|
+          validate_string!("xonly_pubkey", pubkey, 32)
+          parse_xonly_pubkey_internal(context, hex2bin(pubkey))
+        end
+        plain_ptrs = plain_pubkeys.map do |pubkey|
+          validate_string!("plain_pubkey", pubkey, 33)
+          parse_pubkey_internal(context, hex2bin(pubkey))
+        end
+        xonly_arr = if xonly_ptrs.empty?
+                      nil
+                    else
+                      FFI::MemoryPointer.new(:pointer, xonly_ptrs.length).write_array_of_pointer(xonly_ptrs)
+                    end
+        plain_arr = if plain_ptrs.empty?
+                      nil
+                    else
+                      FFI::MemoryPointer.new(:pointer, plain_ptrs.length).write_array_of_pointer(plain_ptrs)
+                    end
+        outpoint_ptr = FFI::MemoryPointer.new(:uchar, 36).put_bytes(0, hex2bin(outpoint_smallest))
+        prevouts_summary = FFI::MemoryPointer.new(:uchar, SP_PREVOUTS_SUMMARY_SIZE)
+        result = secp256k1_silentpayments_recipient_prevouts_summary_create(
+          context, prevouts_summary, outpoint_ptr, xonly_arr, xonly_ptrs.length, plain_arr, plain_ptrs.length)
+        raise Error, "secp256k1_silentpayments_recipient_prevouts_summary_create failed." unless result == 1
+        prevouts_summary.read_string(SP_PREVOUTS_SUMMARY_SIZE).unpack1('H*')
+      end
+    end
+
+    # Scan for Silent Payments transaction outputs(recipient side).
+    # @param [Array] tx_outputs An array of the transaction's x-only public key outputs with hex format(32 bytes each),
+    #   in their original transaction (vout) order.
+    # @param [String] scan_key The recipient's scan key with hex format(32 bytes).
+    # @param [String] prevouts_summary The prevouts summary data created by #silentpayments_create_prevouts_summary
+    #   with hex format(101 bytes).
+    # @param [String] spend_pubkey The recipient's unlabeled spend public key with hex format(33 bytes).
+    # @param [Hash] labels (Optional) The recipient's label cache. A hash whose key is a serialized label(33 bytes)
+    #   and whose value is the corresponding label tweak(32 bytes), both with hex format.
+    #   Can be created with #silentpayments_create_label.
+    # @return [Array] An array of found outputs. Each element is a hash with the following keys:
+    #   - :output x-only public key of the found output with hex format(32 bytes).
+    #   - :tweak The 32-byte tweak needed to spend the output with hex format.
+    #   - :label The serialized label(33 bytes with hex format) if the output was sent to a labeled address, otherwise nil.
+    # @raise [Secp256k1::Error] If the transaction is not a Silent Payments transaction or arguments are invalid.
+    # @raise [ArgumentError] If invalid arguments specified.
+    def silentpayments_scan_outputs(tx_outputs, scan_key, prevouts_summary, spend_pubkey, labels: nil)
+      check_silentpayments_support!
+      raise ArgumentError, "tx_outputs must be an Array." unless tx_outputs.is_a?(Array)
+      raise ArgumentError, "tx_outputs must not be empty." if tx_outputs.empty?
+      validate_string!("scan_key", scan_key, 32)
+      validate_string!("prevouts_summary", prevouts_summary, SP_PREVOUTS_SUMMARY_SIZE)
+      validate_string!("spend_pubkey", spend_pubkey, 33)
+      raise ArgumentError, "labels must be a Hash." if labels && !labels.is_a?(Hash)
+
+      with_context do |context|
+        output_ptrs = tx_outputs.map do |output|
+          validate_string!("tx_output", output, 32)
+          parse_xonly_pubkey_internal(context, hex2bin(output))
+        end
+        tx_outputs_ptr = FFI::MemoryPointer.new(:pointer, output_ptrs.length).write_array_of_pointer(output_ptrs)
+
+        found_outputs = Array.new(tx_outputs.length) { FoundOutput.new }
+        found_outputs_ptr = FFI::MemoryPointer.new(:pointer, found_outputs.length)
+        found_outputs_ptr.write_array_of_pointer(found_outputs.map(&:pointer))
+        n_found = FFI::MemoryPointer.new(:uint32)
+
+        scan_key_ptr = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, hex2bin(scan_key))
+        prevouts_summary_ptr = FFI::MemoryPointer.new(:uchar, SP_PREVOUTS_SUMMARY_SIZE).
+          put_bytes(0, hex2bin(prevouts_summary))
+        spend_pubkey_ptr = parse_pubkey_internal(context, hex2bin(spend_pubkey))
+
+        label_lookup = nil
+        if labels
+          # Keep tweak pointers referenced in this hash so they remain valid while scanning.
+          tweak_cache = {}
+          labels.each do |label, tweak|
+            validate_string!("label", label, SP_LABEL_SIZE)
+            validate_string!("label_tweak", tweak, 32)
+            tweak_cache[hex2bin(label)] = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, hex2bin(tweak))
+          end
+          label_lookup = FFI::Function.new(:pointer, [:pointer, :pointer]) do |label33, _|
+            tweak_cache[label33.read_string(SP_LABEL_SIZE)] || FFI::Pointer::NULL
+          end
+        end
+
+        result = secp256k1_silentpayments_recipient_scan_outputs(
+          context, found_outputs_ptr, n_found, tx_outputs_ptr, tx_outputs.length,
+          scan_key_ptr, prevouts_summary_ptr, spend_pubkey_ptr, label_lookup, nil)
+        raise Error, "secp256k1_silentpayments_recipient_scan_outputs failed." unless result == 1
+
+        Array.new(n_found.read_uint32) do |i|
+          found = found_outputs[i]
+          label = if found[:found_with_label] != 0
+                    out33 = FFI::MemoryPointer.new(:uchar, SP_LABEL_SIZE)
+                    secp256k1_silentpayments_recipient_label_serialize(
+                      context, out33, found.pointer + FoundOutput.offset_of(:label))
+                    out33.read_string(SP_LABEL_SIZE).unpack1('H*')
+                  end
+          {
+            output: serialize_xonly_pubkey_internal(context, found.pointer),
+            tweak: found.pointer.get_bytes(FoundOutput.offset_of(:tweak), 32).unpack1('H*'),
+            label: label
+          }
+        end
+      end
+    end
+
+    private
+
+    # @raise [Secp256k1::Error] If the loaded libsecp256k1 does not support the silentpayments module.
+    def check_silentpayments_support!
+      unless C.silentpayments_available?
+        raise Error, "The loaded libsecp256k1 does not support the silentpayments module. libsecp256k1 v0.8.0 or later is required."
+      end
+    end
+
+    # Parse a serialized label into an internal label pointer.
+    # @param [FFI::Pointer] context secp256k1 context.
+    # @param [String] label serialized label with binary format(33 bytes).
+    # @return [FFI::Pointer] internal label pointer(68 bytes).
+    # @raise [Secp256k1::Error] If the label is invalid.
+    def parse_label_internal(context, label)
+      label_ptr = FFI::MemoryPointer.new(:uchar, SP_LABEL_SIZE).put_bytes(0, label)
+      internal = FFI::MemoryPointer.new(:uchar, SP_LABEL_INTERNAL_SIZE)
+      raise Error, 'An invalid label was specified.' unless secp256k1_silentpayments_recipient_label_parse(context, internal, label_ptr) == 1
+      internal
+    end
+  end
+end

data/lib/secp256k1/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Secp256k1
-  VERSION = "0.3.0"
+  VERSION = "0.8.0"
 end

data/lib/secp256k1.rb

@@ -9,6 +9,7 @@ require_relative 'secp256k1/recovery'
 require_relative 'secp256k1/ellswift'
 require_relative 'secp256k1/schnorrsig'
 require_relative 'secp256k1/musig'
+require_relative 'secp256k1/silentpayments'
 
 # Binding for secp256k1 (https://github.com/bitcoin-core/secp256k1/)
 # @example
@@ -36,6 +37,7 @@ module Secp256k1
   include SchnorrSig
   include EllSwift
   include MuSig
+  include SilentPayments
 
   FLAGS_TYPE_MASK = ((1 << 8) - 1)
   FLAGS_TYPE_CONTEXT = (1 << 0)
@@ -88,8 +90,8 @@ module Secp256k1
         private_key = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, SecureRandom.random_bytes(32))
         ret = secp256k1_ec_seckey_verify(context, private_key)
       end
-      private_key =  private_key.read_string(32).unpack1('H*')
-      [private_key , generate_pubkey_in_context(context,  private_key, compressed: compressed) ]
+      private_key = private_key.read_string(32)
+      [private_key.unpack1('H*'), generate_pubkey_in_context(context, private_key, compressed: compressed)]
     end
   end
 
@@ -323,9 +325,12 @@ module Secp256k1
     output.read_string(X_ONLY_PUBKEY_SIZE).unpack1('H*')
   end
 
+  # Generate public key from +private_key+ using given +context+.
+  # +private_key+ must be a 32-byte binary string, not hex, to avoid a second
+  # hex conversion corrupting binary keys that happen to look like hex strings.
   def generate_pubkey_in_context(context, private_key, compressed: true)
     internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
-    priv_ptr = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, hex2bin(private_key))
+    priv_ptr = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, private_key)
     result = secp256k1_ec_pubkey_create(context, internal_pubkey, priv_ptr)
     raise 'error creating pubkey' unless result
     serialize_pubkey_internal(context, internal_pubkey, compressed)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: secp256k1rb
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.8.0
 platform: ruby
 authors:
 - azuchi
@@ -51,6 +51,7 @@ files:
 - lib/secp256k1/musig/session.rb
 - lib/secp256k1/recovery.rb
 - lib/secp256k1/schnorrsig.rb
+- lib/secp256k1/silentpayments.rb
 - lib/secp256k1/version.rb
 - secp256k1rb.gemspec
 - sig/secp256k1.rbs