libsecp256k1 0.6.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9a570f278310d4598aa3af6b5fb2d5e5c08ba9f792bf0ebec5b49b0d388a34fa
+  data.tar.gz: 86ca304f39e32483add4bee960cdc17f3dc53647381f6ee52861c7c26b0f2521
+SHA512:
+  metadata.gz: c545a8e88097e54885674990b05ee6d5e9487af50cc099f53d10c2071f2becc0b710c6fcc123ceb8c39b142436994ce2778731954fdaca68ae72f916bfe72de9
+  data.tar.gz: e976925274fc79cae6bd626a4a0527f6cfefb1ffc3a0a6419ff3de9edfbadbd5532fef5b2cb9ef35b6093a4705d75496d9ff6b97e78139f5d53e41ce5b170cc0

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+
+# Changelog
+
+## 0.6.1
+
+- Republish yanked version
+
+## 0.6.0 (yanked)
+
+- The first rewritten version, superseding [ruby-bitcoin-secp256k1](https://github.com/cryptape/ruby-bitcoin-secp256k1).

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Weiliang Li
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# libsecp256k1-rb
+
+A Ruby FFI binding for bitcoin's secp256k1 library, superseding [ruby-bitcoin-secp256k1](https://github.com/cryptape/ruby-bitcoin-secp256k1).
+
+## Prerequisite
+
+In order to use this gem, bitcoins's [secp256k1](https://github.com/bitcoin-core/secp256k1) dynamic library (`libsecp256k1.dylib`) must be discoverable.
+
+### Install secp256k1
+
+Use Homebrew:
+
+```bash
+brew install secp256k1
+```
+
+Or build locally:
+
+```bash
+git submodule update --init --recursive
+./make.sh
+./test.sh
+```
+
+## Install
+
+```bash
+gem i libsecp256k1
+```
+
+Then `require "secp256k1"` in your source code.
+
+You need to set `C_INCLUDE_PATH` and `LD_LIBRARY_PATH` (or `SECP256K1_LIB_PATH`) environment variables, see [test.sh](./test.sh) for usage.
+
+## Examples
+
+Check [test](./tests/) for examples.
+
+## LICENSE
+
+[MIT License](./LICENSE)

data/lib/secp256k1/bindings.rb

@@ -0,0 +1,105 @@
+require "ffi"
+require "ffi/tools/const_generator"
+
+module Secp256k1
+  module Bindings
+    extend FFI::Library
+
+    class << self
+      def capabilities
+        @capabilities ||= Hash.new(false)
+      end
+
+      def module_enabled?(feature)
+        capabilities.fetch(feature) { false }
+      end
+
+      def ensure_capability!(feature)
+        return if module_enabled?(feature)
+
+        message = "libsecp256k1 #{feature} module is not enabled"
+        if defined?(Secp256k1::LoadModuleError)
+          raise Secp256k1::LoadModuleError, message
+        else
+          raise LoadError, message
+        end
+      end
+
+      private
+
+      def track_capability(feature, enabled)
+        capabilities[feature] = enabled
+      end
+
+      def attach_optional_group(feature)
+        yield
+        track_capability(feature, true)
+      rescue FFI::NotFoundError
+        track_capability(feature, false)
+      end
+    end
+
+    ffi_lib(ENV["SECP256K1_LIB_PATH"] || "libsecp256k1")
+
+    Constants = FFI::ConstGenerator.new("Secp256k1", required: true) do |gen|
+      gen.include "secp256k1.h"
+
+      gen.const(:SECP256K1_EC_COMPRESSED)
+      gen.const(:SECP256K1_EC_UNCOMPRESSED)
+
+      gen.const(:SECP256K1_CONTEXT_SIGN)
+      gen.const(:SECP256K1_CONTEXT_VERIFY)
+      gen.const(:SECP256K1_CONTEXT_NONE)
+    end
+
+    class Pubkey < FFI::Struct
+      layout :data, [:uchar, 64]
+    end
+
+    class ECDSASignature < FFI::Struct
+      layout :data, [:uchar, 64]
+    end
+
+    class ECDSARecoverableSignature < FFI::Struct
+      layout :data, [:uchar, 65]
+    end
+
+    attach_function :secp256k1_context_create, [:uint], :pointer
+    attach_function :secp256k1_context_destroy, [:pointer], :void
+    attach_function :secp256k1_ec_pubkey_parse, [:pointer, :pointer, :pointer, :size_t], :int
+    attach_function :secp256k1_ec_pubkey_create, [:pointer, :pointer, :pointer], :int
+    attach_function :secp256k1_ec_pubkey_serialize, [:pointer, :pointer, :pointer, :pointer, :uint], :int
+    attach_function :secp256k1_ec_seckey_verify, [:pointer, :pointer], :int
+    attach_function :secp256k1_ecdsa_signature_serialize_der, [:pointer, :pointer, :pointer, :pointer], :int
+    attach_function :secp256k1_ecdsa_signature_serialize_compact, [:pointer, :pointer, :pointer], :int
+    attach_function :secp256k1_ecdsa_signature_parse_der, [:pointer, :pointer, :pointer, :size_t], :int
+    attach_function :secp256k1_ecdsa_signature_parse_compact, [:pointer, :pointer, :pointer], :int
+    attach_function :secp256k1_ecdsa_sign, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int
+    attach_function :secp256k1_ecdsa_verify, [:pointer, :pointer, :pointer, :pointer], :int
+    attach_function :secp256k1_ecdsa_signature_normalize, [:pointer, :pointer, :pointer], :int
+    attach_function :secp256k1_ec_pubkey_tweak_add, [:pointer, :pointer, :pointer], :int
+    attach_function :secp256k1_ec_pubkey_tweak_mul, [:pointer, :pointer, :pointer], :int
+    attach_function :secp256k1_ec_seckey_tweak_add, [:pointer, :pointer, :pointer], :int
+    attach_function :secp256k1_ec_seckey_tweak_mul, [:pointer, :pointer, :pointer], :int
+
+    attach_optional_group(:recovery) do
+      attach_function :secp256k1_ecdsa_recoverable_signature_parse_compact, [:pointer, :pointer, :pointer, :int], :int
+      attach_function :secp256k1_ecdsa_recoverable_signature_convert, [:pointer, :pointer, :pointer], :int
+      attach_function :secp256k1_ecdsa_recoverable_signature_serialize_compact, [:pointer, :pointer, :pointer, :pointer], :int
+      attach_function :secp256k1_ecdsa_sign_recoverable, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int
+      attach_function :secp256k1_ecdsa_recover, [:pointer, :pointer, :pointer, :pointer], :int
+    end
+
+    attach_optional_group(:ecdh) do
+      attach_function :secp256k1_ecdh, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int
+    end
+
+    def self.module_recovery_enabled?
+      module_enabled?(:recovery)
+    end
+
+    def self.module_ecdh_enabled?
+      module_enabled?(:ecdh)
+    end
+  end
+end

data/lib/secp256k1/c.rb

@@ -0,0 +1,5 @@
+require "secp256k1/bindings"
+
+module Secp256k1
+  C = Bindings unless const_defined?(:C)
+end

data/lib/secp256k1/ecdsa.rb

@@ -0,0 +1,99 @@
+module Secp256k1
+  module ECDSA
+    SIZE_SERIALIZED = 74
+    SIZE_COMPACT = 64
+
+    def ecdsa_serialize(raw_sig)
+      output = pointer(:uchar, SIZE_SERIALIZED)
+      outputlen = size_pointer(SIZE_SERIALIZED)
+
+      res = C.secp256k1_ecdsa_signature_serialize_der(@ctx, output, outputlen, raw_sig)
+      raise AssertError, "failed to seriazlie signature" unless res == 1
+
+      read_bytes(output, outputlen.read_uint)
+    end
+
+    def ecdsa_deserialize(ser_sig)
+      raw_sig = C::ECDSASignature.new.pointer
+
+      res = C.secp256k1_ecdsa_signature_parse_der(@ctx, raw_sig, ser_sig, ser_sig.size)
+      raise AssertError, "raw signature parse failed" unless res == 1
+
+      raw_sig
+    end
+
+    def ecdsa_serialize_compact(raw_sig)
+      output = pointer(:uchar, SIZE_COMPACT)
+
+      res = C.secp256k1_ecdsa_signature_serialize_compact(@ctx, output, raw_sig)
+      raise AssertError, "failed to seriazlie compact signature" unless res == 1
+
+      read_bytes(output, SIZE_COMPACT)
+    end
+
+    def ecdsa_deserialize_compact(ser_sig)
+      raise ArgumentError, "invalid signature length" unless ser_sig.size == 64
+
+      raw_sig = C::ECDSASignature.new.pointer
+
+      res = C.secp256k1_ecdsa_signature_parse_compact(@ctx, raw_sig, ser_sig)
+      raise AssertError, "failed to deserialize compact signature" unless res == 1
+
+      raw_sig
+    end
+
+    ##
+    # Check and optionally convert a signature to a normalized lower-S form. If
+    # check_only is `true` then the normalized signature is not returned.
+    #
+    # This function always return a tuple containing a boolean (`true` if not
+    # previously normalized or `false` if signature was already normalized),
+    # and the normalized signature. When check_only is `true`, the normalized
+    # signature returned is always `nil`.
+    #
+    def ecdsa_signature_normalize(raw_sig, check_only: false)
+      sigout = check_only ? nil : C::ECDSASignature.new.pointer
+      res = C.secp256k1_ecdsa_signature_normalize(@ctx, sigout, raw_sig)
+      [res == 1, sigout]
+    end
+
+    def ecdsa_recover(msg, recover_sig, raw: false, digest: Digest::SHA256)
+      raise AssertError, "instance not configured for ecdsa recover" if (@flags & ALL_FLAGS) != ALL_FLAGS
+
+      msg32 = hash32 msg, raw, digest
+      pubkey = C::Pubkey.new.pointer
+
+      res = C.secp256k1_ecdsa_recover(@ctx, pubkey, recover_sig, msg32)
+      raise AssertError, "failed to recover ECDSA public key" unless res == 1
+
+      pubkey
+    end
+
+    def ecdsa_recoverable_serialize(recover_sig)
+      output = pointer(:uchar, SIZE_COMPACT)
+      recid = pointer(:int)
+
+      C.secp256k1_ecdsa_recoverable_signature_serialize_compact(@ctx, output, recid, recover_sig)
+
+      [read_bytes(output, SIZE_COMPACT), recid.read_int]
+    end
+
+    def ecdsa_recoverable_deserialize(ser_sig, rec_id)
+      raise ArgumentError, "invalid rec_id" if rec_id < 0 || rec_id > 3
+      raise ArgumentError, "invalid signature length" if ser_sig.size != 64
+
+      recover_sig = C::ECDSARecoverableSignature.new.pointer
+
+      res = C.secp256k1_ecdsa_recoverable_signature_parse_compact(@ctx, recover_sig, ser_sig, rec_id)
+      raise AssertError, "failed to parse ECDSA compact sig" unless res == 1
+
+      recover_sig
+    end
+
+    def ecdsa_recoverable_convert(recover_sig)
+      normal_sig = C::ECDSASignature.new.pointer
+      C.secp256k1_ecdsa_recoverable_signature_convert(@ctx, normal_sig, recover_sig)
+      normal_sig
+    end
+  end
+end

data/lib/secp256k1/key.rb

@@ -0,0 +1,271 @@
+require "digest"
+require "securerandom"
+
+module Secp256k1
+  class BaseKey
+    def initialize(ctx, flags)
+      @destroy = false
+
+      unless ctx
+        raise ArgumentError, "invalid flags" unless [NO_FLAGS, FLAG_SIGN, FLAG_VERIFY, ALL_FLAGS].include?(flags)
+        ctx = FFI::AutoPointer.new C.secp256k1_context_create(flags), C.method(:secp256k1_context_destroy)
+        @destroy = true
+      end
+
+      @flags = flags
+      @ctx = ctx
+    end
+  end
+
+  class PublicKey < BaseKey
+    include Utils
+    include ECDSA
+
+    attr_accessor :public_key
+
+    def initialize(pubkey: nil, raw: false, flags: FLAG_VERIFY, ctx: nil)
+      super(ctx, flags)
+
+      if pubkey
+        if raw
+          raise ArgumentError, "raw pubkey must be bytes" unless pubkey.instance_of?(String)
+          @public_key = deserialize pubkey
+        else
+          @public_key = pubkey
+        end
+      else
+        @public_key = nil
+      end
+    end
+
+    def serialize(compressed: true)
+      raise AssertError, "No public key defined" unless @public_key
+
+      len_compressed = compressed ? 33 : 65
+      res_compressed = pointer(:char, len_compressed)
+      outlen = size_pointer(len_compressed)
+      compflag = compressed ? EC_COMPRESSED : EC_UNCOMPRESSED
+
+      res = C.secp256k1_ec_pubkey_serialize(@ctx, res_compressed, outlen, @public_key, compflag)
+      raise AssertError, "pubkey serialization failed" unless res == 1
+
+      read_bytes(res_compressed, len_compressed)
+    end
+
+    def deserialize(pubkey_ser)
+      raise ArgumentError, "unknown public key size (expected 33 or 65)" unless [33, 65].include?(pubkey_ser.size)
+
+      pubkey = C::Pubkey.new.pointer
+
+      res = C.secp256k1_ec_pubkey_parse(@ctx, pubkey, pubkey_ser, pubkey_ser.size)
+      raise AssertError, "invalid public key" unless res == 1
+
+      @public_key = pubkey
+      pubkey
+    end
+
+    ##
+    # Add a number of public keys together.
+    #
+    def combine(pubkeys)
+      raise ArgumentError, "must give at least 1 pubkey" if pubkeys.empty?
+
+      outpub = C::Pubkey.new.pointer
+      pointers = pubkeys.map { |item| extract_pubkey_pointer(item) }
+
+      pubkey_ptrs = FFI::MemoryPointer.new(:pointer, pointers.size)
+      pubkey_ptrs.write_array_of_pointer(pointers)
+
+      res = C.secp256k1_ec_pubkey_combine(@ctx, outpub, pubkey_ptrs, pointers.size)
+      raise AssertError, "failed to combine public keys" unless res == 1
+
+      @public_key = outpub
+      outpub
+    end
+
+    ##
+    # Tweak the current public key by adding a 32 byte scalar times the
+    # generator to it and return a new PublicKey instance.
+    #
+    def tweak_add(scalar)
+      tweak_public :secp256k1_ec_pubkey_tweak_add, scalar
+    end
+
+    ##
+    # Tweak the current public key by multiplying it by a 32 byte scalar and
+    # return a new PublicKey instance.
+    #
+    def tweak_mul(scalar)
+      tweak_public :secp256k1_ec_pubkey_tweak_mul, scalar
+    end
+
+    def ecdsa_verify(msg, raw_sig, raw: false, digest: Digest::SHA256)
+      raise AssertError, "No public key defined" unless @public_key
+      raise AssertError, "instance not configured for sig verification" if (@flags & FLAG_VERIFY) != FLAG_VERIFY
+
+      msg32 = hash32 msg, raw, digest
+
+      C.secp256k1_ecdsa_verify(@ctx, raw_sig, msg32, @public_key) == 1
+    end
+
+    def ecdh(scalar)
+      raise AssertError, "No public key defined" unless @public_key
+      raise ArgumentError, "scalar must be composed of 32 bytes" unless scalar.instance_of?(String) && scalar.size == 32
+
+      C.ensure_capability!(:ecdh)
+
+      result = pointer(:uchar, 32)
+      scalar_ptr = bytes_pointer(scalar)
+
+      res = C.secp256k1_ecdh @ctx, result, @public_key, scalar_ptr, nil, nil
+      raise AssertError, "invalid scalar (#{scalar})" unless res == 1
+      read_bytes(result, 32)
+    end
+
+    private
+
+    def extract_pubkey_pointer(value)
+      case value
+      when nil
+        raise ArgumentError, "pubkey cannot be nil"
+      when self.class
+        value.public_key
+      when C::Pubkey
+        value.pointer
+      else
+        value.respond_to?(:pointer) ? value.pointer : value
+      end
+    end
+
+    def tweak_public(meth, scalar)
+      raise ArgumentError, "scalar must be composed of 32 bytes" unless scalar.instance_of?(String) && scalar.size == 32
+      raise AssertError, "No public key defined." unless @public_key
+
+      newpub = self.class.new pubkey: serialize, raw: true
+
+      scalar_ptr = bytes_pointer(scalar)
+
+      res = C.send meth, @ctx, newpub.public_key, scalar_ptr
+      raise AssertError, "Tweak is out of range" unless res == 1
+
+      newpub
+    end
+  end
+
+  class PrivateKey < BaseKey
+    include Utils
+    include ECDSA
+
+    attr_reader :pubkey
+
+    def initialize(privkey: nil, raw: true, flags: ALL_FLAGS, ctx: nil)
+      raise AssertError, "invalid flags" unless [ALL_FLAGS, FLAG_SIGN].include?(flags)
+
+      super(ctx, flags)
+
+      @pubkey = nil
+      @private_key = nil
+
+      if privkey
+        if raw
+          raise ArgumentError, "privkey must be composed of 32 bytes" unless privkey.instance_of?(String) && privkey.size == 32
+          set_raw_privkey privkey
+        else
+          deserialize privkey
+        end
+      else
+        set_raw_privkey generate_private_key
+      end
+    end
+
+    def ecdsa_sign(msg, raw: false, digest: Digest::SHA256)
+      msg32 = hash32 msg, raw, digest
+      raw_sig = C::ECDSASignature.new.pointer
+
+      res = C.secp256k1_ecdsa_sign @ctx, raw_sig, msg32, @private_key, nil, nil
+      raise AssertError, "failed to sign" unless res == 1
+
+      raw_sig
+    end
+
+    def ecdsa_sign_recoverable(msg, raw: false, digest: Digest::SHA256)
+      C.ensure_capability!(:recovery)
+
+      msg32 = hash32 msg, raw, digest
+      raw_sig = C::ECDSARecoverableSignature.new.pointer
+
+      res = C.secp256k1_ecdsa_sign_recoverable @ctx, raw_sig, msg32, @private_key, nil, nil
+      raise AssertError, "failed to sign" unless res == 1
+
+      raw_sig
+    end
+
+    def set_raw_privkey(privkey)
+      raise ArgumentError, "invalid private key" unless C.secp256k1_ec_seckey_verify(@ctx, privkey)
+      @private_key = privkey
+      update_public_key
+    end
+
+    ##
+    # Tweak the current private key by adding a 32 bytes scalar to it and
+    # return a new raw private key composed of 32 bytes.
+    #
+    def tweak_add(scalar)
+      tweak_private :secp256k1_ec_seckey_tweak_add, scalar
+    end
+
+    ##
+    # Tweak the current private key by multiplying it by a 32 byte scalar and
+    # return a new raw private key composed of 32 bytes.
+    #
+    def tweak_mul(scalar)
+      tweak_private :secp256k1_ec_seckey_tweak_mul, scalar
+    end
+
+    private
+
+    def tweak_private(meth, scalar)
+      raise ArgumentError, "scalar must be composed of 32 bytes" unless scalar.instance_of?(String) && scalar.size == 32
+
+      key = bytes_pointer(@private_key)
+
+      scalar_ptr = bytes_pointer(scalar)
+
+      res = C.send meth, @ctx, key, scalar_ptr
+      raise AssertError, "Tweak is out of range" unless res == 1
+
+      read_bytes(key, 32)
+    end
+
+    def update_public_key
+      public_key = generate_public_key @private_key
+      @pubkey = PublicKey.new pubkey: public_key, raw: false, ctx: @ctx, flags: @flags
+    end
+
+    def generate_public_key(privkey)
+      pubkey_ptr = C::Pubkey.new.pointer
+
+      res = C.secp256k1_ec_pubkey_create @ctx, pubkey_ptr, privkey
+      raise AssertError, "failed to generate public key" unless res == 1
+
+      pubkey_ptr
+    end
+
+    def generate_private_key
+      SecureRandom.random_bytes(32)
+    end
+
+    def serialize
+      encode_hex @private_key
+    end
+
+    def deserialize(privkey_serialized)
+      raise ArgumentError, "invalid private key" unless privkey_serialized.size == 64
+
+      rawkey = decode_hex privkey_serialized
+      set_raw_privkey rawkey
+
+      @private_key
+    end
+  end
+end

data/lib/secp256k1/utils.rb

@@ -0,0 +1,38 @@
+require "ffi"
+
+module Secp256k1
+  module Utils
+    extend self
+
+    def pointer(type, count = 1)
+      FFI::MemoryPointer.new(type, count)
+    end
+
+    def size_pointer(initial_value)
+      pointer(:size_t).tap { |ptr| ptr.write_uint(initial_value) }
+    end
+
+    def bytes_pointer(bytes)
+      raise ArgumentError, "bytes must be a String" unless bytes.is_a?(String)
+      pointer(:uchar, bytes.bytesize).tap { |ptr| ptr.put_bytes(0, bytes) }
+    end
+
+    def read_bytes(buffer, length)
+      buffer.read_bytes(length)
+    end
+
+    def hash32(msg, raw, digest)
+      msg32 = raw ? msg : digest.digest(msg)
+      raise AssertError, "digest function must produce 256 bits" unless msg32.size == 32
+      msg32
+    end
+
+    def encode_hex(b)
+      b.unpack1("H*")
+    end
+
+    def decode_hex(s)
+      [s].pack("H*")
+    end
+  end
+end

data/lib/secp256k1.rb

@@ -0,0 +1,19 @@
+# -*- encoding : ascii-8bit -*-
+
+require "secp256k1/c"
+require "secp256k1/utils"
+require "secp256k1/ecdsa"
+require "secp256k1/key"
+
+module Secp256k1
+  EC_COMPRESSED = C::Constants["SECP256K1_EC_COMPRESSED"].to_i
+  EC_UNCOMPRESSED = C::Constants["SECP256K1_EC_UNCOMPRESSED"].to_i
+
+  FLAG_SIGN = C::Constants["SECP256K1_CONTEXT_SIGN"].to_i
+  FLAG_VERIFY = C::Constants["SECP256K1_CONTEXT_VERIFY"].to_i
+  NO_FLAGS = C::Constants["SECP256K1_CONTEXT_NONE"].to_i
+  ALL_FLAGS = FLAG_SIGN | FLAG_VERIFY
+
+  class AssertError < StandardError; end
+  class LoadModuleError < StandardError; end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: libsecp256k1
+version: !ruby/object:Gem::Version
+  version: 0.6.1
+platform: ruby
+authors:
+- Weiliang Li
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+description: A Ruby FFI binding for bitcoin's secp256k1 library, superseding ruby-bitcoin-secp256k1.
+email: to.be.impressive@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/secp256k1.rb
+- lib/secp256k1/bindings.rb
+- lib/secp256k1/c.rb
+- lib/secp256k1/ecdsa.rb
+- lib/secp256k1/key.rb
+- lib/secp256k1/utils.rb
+homepage: https://github.com/ecies/libsecp256k1-rb
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A Ruby FFI binding for bitcoin's secp256k1 library
+test_files: []