rbsecp256k1 3.0.1 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 529c72afdaa5cd79bc685fd28661d367be89a019366e9b9d46bb9db7dd99e499
-  data.tar.gz: 21d2af92f7c0c696f2a36b6a6de4c330f0dac30078a1d61327e3e22bb80bd4ef
+  metadata.gz: 911e42c1184881dc8aa0fd52c833b5c5cc092d5ef04c1d264755acfa9668545b
+  data.tar.gz: 808c994ea9dd8965deb16feb82393a044a69fdeeada0654f64031fa74e4b4761
 SHA512:
-  metadata.gz: 2d32348b294c9e75ac950f1be1ae2dc0de0c1a31a3038da397426dc56f5cde637a453037f0e5dab0c6bb7bc1761f9afc6934c2f804d328bb4f31279754ec1584
-  data.tar.gz: '03028eee4ffcf8d8df75488444a8fc963ffa2e10fceb0ac4ac9fb8762f5c403594d74eafedf110ff2c955091fb2d9f76257a5517c7f80fdd2bccc6e2274d6882'
+  metadata.gz: 8038fffce14eb3e4b5fdb41f7001349823f4cf0a2b291fca66e6d024e75e4f5e58c1286d7d8473f5daf05016740c61e7d056b6c2c6b118e367bf3a532451e78c
+  data.tar.gz: 5430aaefc5a6c8e8ea348d39a425ce48943f3a467744182f68a170bc8784877b95d07c4d66c0351cb7860de4f01b71661d87e70e422a1f382fe0a48dae89e663

data/README.md

@@ -1,11 +1,12 @@
 # rbsecp256k1
 
-[![Build Status](https://travis-ci.com/etscrivner/rbsecp256k1.svg?branch=master)](https://travis-ci.com/etscrivner/rbsecp256k1) [![Gem Version](https://badge.fury.io/rb/rbsecp256k1.svg)](https://badge.fury.io/rb/rbsecp256k1)
+[![Spec](https://github.com/etscrivner/rbsecp256k1/actions/workflows/spec.yml/badge.svg?branch=master)](https://github.com/etscrivner/rbsecp256k1/actions/workflows/spec.yml) [![Gem Version](https://badge.fury.io/rb/rbsecp256k1.svg)](https://badge.fury.io/rb/rbsecp256k1) [![Maintainability](https://api.codeclimate.com/v1/badges/d4b6e27bfa00030ca412/maintainability)](https://codeclimate.com/github/etscrivner/rbsecp256k1/maintainability)
 
-Compiled Ruby extension gem for [libsecp256k1](https://github.com/bitcoin-core/secp256k1). In rbsecp256k1 3.0.0
-and later libsecp256k1 is bundled with the gem.
+Native extension gem for secp256k1 ECDSA. Wraps [libsecp256k1](https://github.com/bitcoin-core/secp256k1). In
+rbsecp256k1 3.0.0 and later libsecp256k1 is bundled with the gem.
 
-[Documentation](documentation/index.md)
+* [Documentation](https://github.com/etscrivner/rbsecp256k1/blob/master/documentation/index.md)
+* [Examples](https://github.com/etscrivner/rbsecp256k1/blob/master/examples/README.md)
 
 ### Why wrap libsecp256k1?
 
@@ -16,6 +17,9 @@ faster than the OpenSSL implementation of the same curve. It is the only library
 that provides constant time signing of this curve and has been deployed as part
 of Bitcoin since [v0.10.0](https://bitcoin.org/en/release/v0.10.0#improved-signing-security)
 
+Natively wrapping the library in an extension gem means users don't have to
+worry about compiling or locating the library, unlike many [FFI](https://github.com/ffi/ffi) based gems.
+
 ## Installation
 
 The simplest installation:
@@ -55,7 +59,7 @@ brew install openssl libtool pkg-config gmp libffi
 
 ## Features
 
-See [rbsecp256k1 documentation](documentation/index.md) for examples and complete list of supported functionality.
+See [rbsecp256k1 documentation](https://github.com/etscrivner/rbsecp256k1/blob/master/documentation/index.md) for examples and complete list of supported functionality.
 
 ## Development
 
@@ -108,6 +112,12 @@ To test with both disabled run:
 make test WITH_RECOVERY=0 WITH_ECDH=0
 ```
 
+Testing for memory leaks with valgrind:
+
+```
+make memcheck
+```
+
 ### Building Gem
 
 ```

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rake/extensiontask"
 
 Rake::ExtensionTask.new "rbsecp256k1" do |ext|

data/documentation/context.md

@@ -0,0 +1,81 @@
+[Index](index.md)
+
+Secp256k1::Context
+==================
+
+Secp256k1::Context represents a libsecp256k1 context object. Contexts are
+thread-safe and initialization is expensive, so a single context should be used
+for multiple operations as much as possible.
+
+Initializers
+------------
+
+#### new(context_randomization_bytes: nil)
+
+Returns a newly initialized libsecp256k1 context. The context is randomized at
+initialization if given `context_randomization_bytes`. The
+`context_randomization_bytes` argument can optionally take a string containing
+32 bytes of random data, if not provided then the Context is not randomized and
+may be vulnerable to side-channel attacks.
+
+Class Methods
+-------------
+
+#### create
+
+Creates and returns a new randomized `Context` using `SecureRandom` for the
+random initialization bytes. This is the recommended method for initialization.
+
+#### create_unrandomized
+
+Creates a new unrandomized `Context`.
+
+Instance Methods
+----------------
+
+#### ecdh(point, scalar)
+
+**Requires:** libsecp256k1 was built with the experimental ECDH module.
+
+Takes a `point` ([PublicKey](public_key.md)) and a `scalar` ([PrivateKey](private_key.md)) and returns a new
+[SharedSecret](shared_secret.md) containing the 32-byte shared secret. Raises a `Secp256k1::Error` if
+the `scalar` is invalid (zero or causes an overflow).
+
+#### generate_key_pair
+
+Generates and returns a new [KeyPair](key_pair.md) using a cryptographically
+secure random number generator (CSRNG) provided by OpenSSL.
+
+#### key_pair_from_private_key(private_key_data)
+
+Returns a new [KeyPair](key_pair.md) from the given `private_key_data`. The
+`private_key_data` is expected to be a binary string. Raises a `Secp256k1::Error`
+if the private key is invalid or key derivation fails.
+
+#### recoverable_signature_from_compact(compact_signature, recovery_id)
+
+**Requires:** libsecp256k1 was build with recovery module.
+
+Attempts to load a [RecoverableSignature](recoverable_signature.md) from the given `compact_signature`
+and `recovery_id`. Raises a `Secp256k1::DeserializationError` if the signature data or recovery ID are invalid.
+
+#### sign(private_key, hash32)
+
+Signs the SHA-256 hash given by `hash32` using `private_key` and returns a new
+[Signature](signature.md). The `private_key` is expected to be a [PrivateKey](private_key.md)
+object and `data` can be either a binary string or text.
+
+#### sign_recoverable(private_key, hash32)
+
+**Requires:** libsecp256k1 was build with recovery module.
+
+Signs the data represented by the SHA-256 hash `hash32` using `private_key` and returns a
+new [RecoverableSignature](recoverable_signature.md). The `private_key` is expected to be a [PrivateKey](private_key.md) and
+`data` can be either a binary string or text.
+
+#### verify(signature, public_key, hash32)
+
+Verifies the given `signature` ([Signature](signature.md)) was signed by
+the private key corresponding to `public_key` ([PublicKey](public_key.md)) and signed `hash32`. Returns `true`
+if `signature` is valid or `false` otherwise. Note that `data` can be either a
+text or binary string.

data/documentation/index.md

@@ -0,0 +1,319 @@
+rbsecp256k1 Reference
+=====================
+
+Find your topic in the index, or refer to one of the examples below.
+
+Classes and Modules
+-------------------
+
+| Module                     | Classes                                          | Utilities
+|----------------------------|:-------------------------------------------------|:--------------------------------
+| [Secp256k1](secp256k1.md)  | [Context](context.md)                            | [Util](util.md)
+|                            | [KeyPair](key_pair.md)                           |
+|                            | [PublicKey](public_key.md)                       |
+|                            | [PrivateKey](private_key.md)                     |
+|                            | [SharedSecret](shared_secret.md)                 |
+|                            | [Signature](signature.md)                        |
+|                            | [RecoverableSignature](recoverable_signature.md) |
+
+Glossary
+--------
+
+**[Context](context.md)** is a libsecp256k1 library context. It contains
+pre-computed tables and values to make ECDSA signing and verification more
+efficient.
+
+**[KeyPair](key_pair.md)** is a Secp256k1 elliptic-curve key pair.
+
+**[PublicKey](public_key.md)** is a Secp256k1 public key. It can come in either
+compressed or uncompressed format.
+
+**[PrivateKey](private_key.md)** is a 64-byte Secp256k1 private key.
+
+**[SharedSecret](shared_secret.md)** A 32-byte shared secret computed from a
+public key (point) and private key (scalar).
+
+**[Signature](signature.md)** is an ECDSA signature of the SHA-256 message hash
+of a piece of data.
+
+**[RecoverableSignature](recoverable_signature.md)** is a recoverable ECDSA signature of the SHA-256 message
+hash of a piece of data.
+
+Examples
+--------
+
+### 1. Creating a libsecp256k1 context
+
+This example demonstrates how to create a new libsecp256k1 context. This is the
+first step of using this library:
+
+```ruby
+context = Secp256k1::Context.create
+# => #<Secp256k1::Context:0x0000559b0bd8f5d0>
+```
+
+### 2. Generating a key pair
+
+This example shows how to generate a new public-private key pair:
+
+```ruby
+context = Secp256k1::Context.create
+key_pair = context.generate_key_pair
+# => #<Secp256k1::KeyPair:0x0000559b0bc876b0 @public_key=#<Secp256k1::PublicKey:0x0000559b0bc876d8>, @private_key=#<Secp256k1::PrivateKey:0x0000559b0bc87700 @data="\r\xA7\xB3<\x92\xCDw\xC1\xDB\xEB[BB;=\x80\xB83\xA8]\x06\xD9\x90\xF8v\xFFi\xF0/\x1E\x96\xF9">>
+```
+
+### 3. Getting compressed and uncompressed public key representations
+
+This example shows how to generate compressed and uncompressed public keys:
+
+```ruby
+context = Secp256k1::Context.create
+key_pair = context.generate_key_pair
+
+# 1. Get the binary representation of compressed public key
+key_pair.public_key.compressed
+# => "\x03D\x88\xD6 3|3\x836\xCB(\x9CW%\xF4T\xB7\xCD\x8AF T\xE7\xE8\xCE\xB0\xC7c{\xE2:\xFE"
+
+# 2. Show hex representation of compressed public key
+Secp256k1::Util.bin_to_hex(key_pair.public_key.compressed)
+# => "034488d620337c338336cb289c5725f454b7cd8a462054e7e8ceb0c7637be23afe"
+
+# 3. Get the binary representation of uncompressed public key
+key_pair.public_key.uncompressed
+# => "\x04D\x88\xD6 3|3\x836\xCB(\x9CW%\xF4T\xB7\xCD\x8AF T\xE7\xE8\xCE\xB0\xC7c{\xE2:\xFE XRew\x1F\e\x05\xC8\xDC\xA7\xE3\x8C\xBD\x91s?\xFCW\xD5\xB3\xA8aaCCG\xD4\x94m\xA5c"
+
+# 4. Show hex representation of uncompressed public key
+Secp256k1::Util.bin_to_hex(key_pair.public_key.uncompressed)
+# => "044488d620337c338336cb289c5725f454b7cd8a462054e7e8ceb0c7637be23afe20585265771f1b05c8dca7e38cbd91733ffc57d5b3a86161434347d4946da563"
+```
+
+### 3. Signing a message
+
+This example shows how to sign a message using your private key:
+
+```ruby
+require 'digest'
+
+context = Secp256k1::Context.create
+key_pair = context.generate_key_pair
+
+signature = context.sign(key_pair.private_key, Digest::SHA256.digest("test message"))
+# => #<Secp256k1::Signature:0x0000559b0bc79358>
+```
+
+### 4. Getting DER and Compact signature encodings
+
+This example shows you how to get the DER encoded and compact encoded
+representations of a signature:
+
+```ruby
+require 'digest'
+
+context = Secp256k1::Context.create
+key_pair = context.generate_key_pair
+
+signature = context.sign(key_pair.private_key, Digest::SHA256.digest("test message"))
+
+# 1. Get the compact binary representation
+signature.compact
+# => "\xAB#e6_\x866\e\xAC\e\x92W\xC8a\x84N\xD4\xB6\x88\xF8\xEE\xDF\xFBC\xE8j\xB2\xF0\x10\xB8\xA0\x89\x13L\e\x9E\x91cB\xD7\xAC\x11\xF7\x02,Y&TM\xA5zp\xFD\xB3\xB1\xDCIV\xBB\\\xAF\x16@\xFC\x00"
+
+# 2. Get the compact hex representation
+Secp256k1::Util.bin_to_hex(signature.compact)
+# => "ab2365365f86361bac1b9257c861844ed4b688f8eedffb43e86ab2f010b8a089134c1b9e916342d7ac11f7022c5926544da57a70fdb3b1dc4956bb5caf1640fc00"
+
+# 3. Get the DER binary representation
+signature.der_encoded
+# => "0E\x02!\x00\xAB#e6_\x866\e\xAC\e\x92W\xC8a\x84N\xD4\xB6\x88\xF8\xEE\xDF\xFBC\xE8j\xB2\xF0\x10\xB8\xA0\x89\x02 \x13L\e\x9E\x91cB\xD7\xAC\x11\xF7\x02,Y&TM\xA5zp\xFD\xB3\xB1\xDCIV\xBB\\\xAF\x16@\xFC"
+
+# 4. Get the DER hex representation
+Secp256k1::Util.bin_to_hex(signature.der_encoded)
+# => "3045022100ab2365365f86361bac1b9257c861844ed4b688f8eedffb43e86ab2f010b8a0890220134c1b9e916342d7ac11f7022c5926544da57a70fdb3b1dc4956bb5caf1640fc"
+```
+
+### 5. Verifying a signature
+
+This example shows how to verify a signature using a public key:
+
+```ruby
+require 'digest'
+
+context = Secp256k1::Context.create
+key_pair = context.generate_key_pair
+hash = Digest::SHA256.digest("test message")
+
+signature = context.sign(key_pair.private_key, hash)
+
+# 1. Verify signature against matching message
+context.verify(signature, key_pair.public_key, hash)
+# => true
+
+# 2. Verify signature against different message
+context.verify(signature, key_pair.public_key, hash)
+# => false
+```
+
+### 6. Loading a private key or key pair from private key data
+
+This example shows how to load a key pair from raw binary private key data:
+
+```ruby
+context = Secp256k1::Context.create
+
+#1. Load private key alone
+private_key = Secp256k1::PrivateKey.from_data("I\nX\x85\xAEz}\n\x9B\xA4\\\x81)\xD4\x9Aq\xFDH\t\xBE\x8EP\xC5.\xC6\x1F7-\x86\xA0\xCB\xF9")
+# => #<Secp256k1::PrivateKey:0x00005647df1bcd30 @data="I\nX\x85\xAEz}\n\x9B\xA4\\\x81)\xD4\x9Aq\xFDH\t\xBE\x8EP\xC5.\xC6\x1F7-\x86\xA0\xCB\xF9">
+
+# 2. Load key pair from private key data
+key_pair = context.key_pair_from_private_key("I\nX\x85\xAEz}\n\x9B\xA4\\\x81)\xD4\x9Aq\xFDH\t\xBE\x8EP\xC5.\xC6\x1F7-\x86\xA0\xCB\xF9")
+# => #<Secp256k1::KeyPair:0x0000559b0bbf9a90 @public_key=#<Secp256k1::PublicKey:0x0000559b0bbf9ab8>, @private_key=#<Secp256k1::PrivateKey:0x0000559b0bbf9ae0 @data="I\nX\x85\xAEz}\n\x9B\xA4\\\x81)Ԛq\xFDH\t\xBE\x8EP\xC5.\xC6\u001F7-\x86\xA0\xCB\xF9">>
+```
+
+### 7. Loading a public key from binary data
+
+This example shows how to load a public key from binary data:
+
+```ruby
+# 1. Load public key from uncompressed pubkey
+public_key = Secp256k1::PublicKey.from_data("\x04$\xA2\xE7\xBB1\xC4|tN\xE6\xE4J-\xED\x9A[\xAFf-<\x14\x84^QQ\"\x14\xC3\x91\xE4\xF2\xB5\xEEEj\xAB\xD9\xFE\b\e7Zk\xC5{k\x12\xE3\xEA\xA2\xA5\xD7\xC1\xA5&\xE5|:K\xA9 X\xA3\x90")
+# => #<Secp256k1::PublicKey:0x0000559b0bdc72f0>
+
+# 2. Load public key from compressed pubkey
+public_key = Secp256k1::PublicKey.from_data("\x02$\xA2\xE7\xBB1\xC4|tN\xE6\xE4J-\xED\x9A[\xAFf-<\x14\x84^QQ\"\x14\xC3\x91\xE4\xF2\xB5")
+# => #<Secp256k1::PublicKey:0x0000559b0bdd3668>
+```
+
+### 8. Loading a DER or compact encoded signature
+
+This example shows how to load signatures from binary data:
+
+```ruby
+# 1. From DER encoded signature
+signature = Secp256k1::Signature.from_der_encoded("0D\x02 <\xC6\x7F/\x921l\x89Z\xFBs\x89p\xEE\x18u\x8B\x92\x9D\xA6\x84\xC5Y<t\xB7\xF1\f\xEE\f\x81J\x02 \t\"\xDF]\x1D\xA7W@^\xAAokH\b\x00\xE2L\xCF\x82\xA3\x05\x1E\x00\xF9\xFC\xB19\x0F\x93|\xB1f")
+# => #<Secp256k1::Signature:0x0000559b0b823d58>
+
+# 2. From compact signature
+signature = Secp256k1::Signature.from_compact("<\xC6\x7F/\x921l\x89Z\xFBs\x89p\xEE\x18u\x8B\x92\x9D\xA6\x84\xC5Y<t\xB7\xF1\f\xEE\f\x81J\t\"\xDF]\x1D\xA7W@^\xAAokH\b\x00\xE2L\xCF\x82\xA3\x05\x1E\x00\xF9\xFC\xB19\x0F\x93|\xB1f\x00")
+# => #<Secp256k1::Signature:0x0000559b0bdcaa68>
+```
+
+Recoverable Signature Examples
+------------------------------
+
+### 1. Checking for recovery module
+
+To check if you have compiled the recovery module into your local libsecp256k1
+run the following:
+
+```ruby
+Secp256k1.have_recovery?
+# => true
+```
+
+### 2. Sign data producing recoverable signature
+
+You can sign data producing a recoverable signature as follows:
+
+```ruby
+require 'digest'
+
+hash = Digest::SHA256.digest('test message')
+context = Secp256k1::Context.create
+key_pair = context.generate_key_pair
+
+signature = context.sign_recoverable(key_pair.private_key, hash)
+# => #<Secp256k1::RecoverableSignature:0x000055f2ea76e548>
+```
+
+### 3. Serialize recoverable signature as compact representation
+
+You can produce the compact binary serialization of a recoverable signature:
+
+```ruby
+require 'digest'
+
+hash = Digest::SHA256.digest('test message')
+context = Secp256k1::Context.create
+key_pair = context.generate_key_pair
+
+signature = context.sign_recoverable(key_pair.private_key, hash)
+compact_data, recovery_id = signature.compact
+# => ["D,\x9C\xA6%I\x14-\xCA\xC0\x11\x0F\xEB\x1E\xB0\xB6\\-\xE2\b\x98\xFB\xEA\xD5\x9BZ\xE6\xDF#\xC1\x1A\xEEL\xF02\xB1\xE9{\r\xEBhh<\\\xCF\xB6\x98\xEA\x8F\xF65\xF2\xBF\x84\xD8\xE5x\xF0\xA5)\xA2Wb\x9D", 1]
+```
+
+### 4. Recoverable signature from compact representation
+
+You can load a recoverable signature give its compact representation and
+recovery ID:
+
+```ruby
+context = Secp256k1::Context.create
+
+compact_data = "D,\x9C\xA6%I\x14-\xCA\xC0\x11\x0F\xEB\x1E\xB0\xB6\\-\xE2\b\x98\xFB\xEA\xD5\x9BZ\xE6\xDF#\xC1\x1A\xEEL\xF02\xB1\xE9{\r\xEBhh<\\\xCF\xB6\x98\xEA\x8F\xF65\xF2\xBF\x84\xD8\xE5x\xF0\xA5)\xA2Wb\x9D"
+recovery_id = 1
+
+signature = context.recoverable_signature_from_compact(compact_data, recovery_id)
+# => #<Secp256k1::RecoverableSignature:0x000055f2ea7615c8>
+```
+
+### 5. Convert recoverable signature to non-recoverable signature
+
+You can convert a recoverable signature to a non-recoverable signature suitable
+for use by all methods that take a [Signature](signature.md) object:
+
+```ruby
+require 'digest'
+
+hash = Digest::SHA256.digest('test message')
+context = Secp256k1::Context.create
+key_pair = context.generate_key_pair
+
+recoverable_signature = context.sign_recoverable(key_pair.private_key, hash)
+signature = recoverable_signature.to_signature
+# => #<Secp256k1::Signature:0x000055f2ea8ca4f0>
+```
+
+### 6. Recover public key from recoverable signature
+
+You can recover the [PublicKey](public_key.md) associated with a recoverable signature:
+
+```ruby
+require 'digest'
+
+hash = Digest::SHA256.digest('test message')
+context = Secp256k1::Context.create
+key_pair = context.generate_key_pair
+
+recoverable_signature = context.sign_recoverable(key_pair.private_key, hash)
+public_key = recoverable_signature.recover_public_key(hash)
+# => #<Secp256k1::PublicKey:0x000055f2ea756678>
+
+public_key == key_pair.public_key
+# => true
+```
+
+EC Diffie-Hellman
+-----------------
+
+### 1. Checking for ECDH module
+
+To check if you have compiled the ECDH module into your local libsecp256k1 run
+the following:
+
+```ruby
+Secp256k1.have_ecdh?
+# => true
+```
+
+### 2. Generating a shared secret
+
+To generate a shared secret run the following:
+
+```ruby
+context = Secp256k1::Context.create
+key_pair = context.generate_key_pair
+
+shared_secret = context.ecdh(key_pair.public_key, key_pair.private_key)
+shared_secret.data
+# => "\x1FQ\x90X\xA5\xF2\xAEx;\xD7i\xB6\\T,2[\x90\xD1)a$\x1CA\x17\x8F\e\x91\xE3\x06C\x93"
+```

data/documentation/key_pair.md

@@ -0,0 +1,28 @@
+[Index](index.md)
+
+Secp256k1::KeyPair
+==================
+
+Secp256k1::KeyPair represents a public-private Secp256k1 key pair.
+
+Initializers
+------------
+
+#### new(public_key, private_key)
+
+Initializes a new key pair with `public_key` (type: [PublicKey](public_key.md)) and `private_key` (type: [PrivateKey](private_key.md)).
+
+Instance Methods
+----------------
+
+#### public_key
+
+Returns the [PublicKey](public_key.md) part of this key pair.
+
+#### private_key
+
+Returns the [PrivateKey](private_key.md) part of this key pair.
+
+#### ==(other)
+
+Returns `true` if the `other` has the same public and private key.

data/documentation/private_key.md

@@ -0,0 +1,25 @@
+[Index](index.md)
+
+Secp256k1::PrivateKey
+=====================
+
+Secp256k1::PrivateKey represents the private key part of a public-private key pair.
+
+Class Methods
+-------------
+
+#### from_data(private_key_data)
+
+Loads new private key from the given binary `private_key_data` string. Raises
+`Secp256k1::Error` if the given data is invalid.
+
+Instance Methods
+----------------
+
+#### data
+
+Returns the binary private key data as a `String`.
+
+#### ==(other)
+
+Returns `true` if this private key matches `other`.

data/documentation/public_key.md

@@ -0,0 +1,32 @@
+[Index](index.md)
+
+Secp256k1::PublicKey
+====================
+
+Secp256k1::PublicKey represents the public key part of a public-private key pair.
+
+See: [KeyPair](key_pair.md)
+
+Class Methods
+-------------
+
+#### from_data(public_key_data)
+
+Parses compressed or uncompressed from binary string `public_key_data` and
+creates and returns a new public key from it. Raises a `Secp256k1::DeserializationError`
+if the given public key data is invalid.
+
+Instance Methods
+----------------
+
+#### compressed
+
+Returns the binary compressed representation of this public key.
+
+#### uncompressed
+
+Returns the binary uncompressed representation of this public key.
+
+#### ==(other)
+
+Return `true` if this public key matches `other`.

data/documentation/recoverable_signature.md

@@ -0,0 +1,30 @@
+[Index](index.md)
+
+Secp256k1::RecoverableSignature
+===============================
+
+**Requires:** libsecp256k1 was build with recovery module.
+
+Secp256k1::RecoverableSignature represents a recoverable ECDSA signature
+signing the 32-byte SHA-256 hash of some data.
+
+Instance Methods
+----------------
+
+#### compact
+
+Returns an array whose first element is the 64-byte compact signature as a
+binary string and whose second element is the integer recovery ID.
+
+#### recover_public_key
+
+Recovers the public key corresponding to the recoverable signature. Returns a
+[PublicKey](public_key.md).
+
+#### to_signature
+
+Converts a recoverable signature to a non-recoverable [Signature](signature.md) object.
+
+#### ==(other)
+
+Returns `true` if this recoverable signature matches `other`.

data/documentation/secp256k1.md

@@ -0,0 +1,19 @@
+[Index](index.md)
+
+Secp256k1
+=========
+
+Secp256k1 is the top-level module for this library.
+
+Class Methods
+-------------
+
+#### have_recovery?
+
+Returns `true` if the recovery module was built with libsecp256k1, `false`
+otherwise.
+
+#### have_ecdh?
+
+Returns `true` if the EC Diffie-Hellman module was built with libsecp256k1,
+`false` otherwise.

data/documentation/shared_secret.md

@@ -0,0 +1,16 @@
+[Index](index.md)
+
+Secp256k1::SharedSecret
+=======================
+
+**Requires:** libsecp256k1 was build with ECDH module.
+
+Secp256k1::SharedSecret represents a 32-byte shared secret computed from a
+public key (point) and private key (scalar).
+
+Instance Methods
+----------------
+
+#### data
+
+Binary string containing the 32-byte shared secret.

data/documentation/signature.md

@@ -0,0 +1,42 @@
+[Index](index.md)
+
+Secp256k1::Signature
+====================
+
+Secp256k1::Signature represents an ECDSA signature signing the 32-byte SHA-256
+hash of some data.
+
+Class Methods
+-------------
+
+#### from_compact(compact_signature)
+
+Parses a signature from binary string `compact_signature`. Raises a
+`Secp256k1::DeserializationError` if the signature data is invalid.
+
+#### from_der_encoded(der_encoded_signature)
+
+Parses a signature from binary string `der_encoded_signature`. Raises a
+`Secp256k1::DeserializationError` if the signature data is invalid.
+
+Instance Methods
+----------------
+
+#### der_encoded
+
+Returns the DER encoded representation of this signature.
+
+#### compact
+
+Returns the compact 64-byte representation of this signature.
+
+#### normalized
+
+Returns an array containing two elements. The first is a Boolean indicating
+whether or not the signature was normalized, false if it was already in lower-S
+normal form. The second element is a `Signature` containing the normalized
+signature object.
+
+#### ==(other)
+
+Returns `true` if this signature matches `other`.

data/documentation/util.md

@@ -0,0 +1,17 @@
+[Index](index.md)
+
+Secp256k1::Util
+===============
+
+Secp256k1::Util in a module containing generally useful methods for using the library.
+
+Class Methods
+-------------
+
+#### bin_to_hex(binary_data)
+
+Returns the hexadecimal string representation of `binary_data`
+
+#### hex_to_bin(hex_string)
+
+Returns the binary string representation of `hex_string`