btcruby 0.0.0 → 1.0.0

data/documentation/key.md

@@ -0,0 +1,177 @@
+[Index](index.md)
+
+BTC::Key
+========
+
+Class BTC::Key encapsulates a pair of public and private keys (or a public key only)
+and provides methods to sign messages and verify signatures.
+
+**Private key** is a 256-bit integer encoded in a 32-byte big-endian binary string (always padded with zeros from the left).
+Private key is used to sign messages. Private key can be `nil` for *public-only* BTC::Key instances.
+
+**Public key** is a 33-byte or 65-byte binary string encoding coordinates of a point on
+the elliptic curve [secp256k1](https://en.bitcoin.it/wiki/Secp256k1).
+Public key is used to verify signatures.
+
+Public key can be **compressed** (33 bytes) or **uncompressed** (65 bytes).
+Compressed public key contains only an X coordinate of a point and recovers Y coordinate with extra arithmetic operations.
+Uncompressed public key contains both X and Y coordinates. Both versions are equally capable of verifying signatures, but
+resulting [addresses](p2pkh.md) are different (because hashes are different). [BIP32](keychain.md) standard uses only compressed public key for compactness and consistency.
+
+If the BTC::Key instance contains only a public key, it can only verify signatures, but cannot create them.
+
+Class Methods
+-------------
+
+#### validate\_private\_key\_range(*private_key*)
+
+Returns `true` if data representing a private key is within a valid range for elliptic curve *secp256k1*.
+
+#### validate\_public\_key(*public_key*)
+
+Returns `true` if the raw binary public key is valid and well-formed.
+Accepts both compressed and uncompressed public keys.
+Logs detailed info using [BTC::Diagnostics](diagnostics.md).
+
+#### validate\_script\_signature(*data*, verify\_lower\_s: true)
+
+Returns `true` if the [script signature](signature.md) is valid.
+
+If `verify_lower_s` is `true` (it is by default), then this method also verifies if the signature is canonical.
+
+#### validate\_and\_normalize\_script\_signature(*script_sig*)
+
+Validates [script signature](signature.md) and normalizes it if needed.
+
+Returns `nil` if script signature is not valid (e.g. DER encoding is invalid, or [hash type](signature.md) is invalid).
+
+Returns `script_sig` if it is a valid, canonical signature.
+
+Returns a normalized ("lower s") version of `script_sig` if it is non-canonical.
+
+#### normalized_signature(*signature*)
+
+Returns a `sig` or a normalized version of `sig`.
+Assumes signature is a valid plain DER-encoded ECDSA signature, otherwise raises `BTCError`.
+
+Initializers
+------------
+
+#### random(public\_key\_compressed: *true|false*, network: *BTC::Network*)
+
+Returns a new `BTC::Key` instance with a random `private_key`.
+
+If `public_key_compressed` is not specified, `true` is used.
+
+If `network` is not specified, [BTC::Network.default](network.md#default) is used.
+
+
+#### new(private\_key: *String*, public\_key\_compressed: *true|false*, network: *BTC::Network*)
+
+Returns a new `BTC::Key` instance with a given binary `private_key`.
+
+If `private_key` is not within a valid range, raises `FormatError`.
+
+If `public_key_compressed` is not specified, `true` is used.
+
+If `network` is not specified, [BTC::Network.default](network.md#default) is used.
+
+
+#### new(public_key: *String*, network: *BTC::Network*)
+
+Returns a new `BTC::Key` instance with a given binary `public_key`.
+This instance does not contain a private key and can only be used to verify signatures.
+
+If `public_key` is not a valid compressed or uncompressed public key, raises `FormatError`.
+
+If `network` is not specified, [BTC::Network.default](network.md#default) is used.
+
+
+#### new(wif: *String*)
+
+Returns a new `BTC::Key` instance with a private key decoded from [WIF](wif.md) string.
+
+If `wif` is not a valid WIF-encoded string, raises `FormatError`.
+
+Public key compression and `network` attributes are inherited from WIF.
+
+
+Instance Methods
+----------------
+
+#### ecdsa_signature(*hash*)
+
+Returns a binary DER-encoded ECDSA signature for a given binary string `hash` (typically 32-byte long).
+Signature is normalized and uses deterministic nonce `k` based on private key and the `hash`.
+
+Raises `ArgumentError` if receiver's private key is `nil`.
+
+#### verify\_ecdsa\_signature(*signature*, *hash*)
+
+Returns `true` if the binary DER-encoded `signature` for a given binary string `hash` is correctly verified
+against the public key of the receiver.
+
+#### public\_key\_compressed
+
+Returns `true` or `false` depending on whether public key is compressed.
+
+#### compressed_key
+
+Returns a new `BTC::Key` instance with `public_key_compressed` set to `true`.
+
+#### uncompressed_key
+
+Returns a new `BTC::Key` instance with `public_key_compressed` set to `false`.
+
+#### private_key
+
+Returns a raw 32-byte private key or `nil` if it is a public-only key.
+
+#### public_key
+
+Returns a raw 33- or 65-byte public key depending on `public_key_compressed` value.
+
+#### compressed\_public\_key
+
+Returns a raw compressed 33-byte public key.
+
+#### uncompressed\_public\_key
+
+Returns a raw uncompressed 65-byte public key.
+
+#### network
+
+Returns a [BTC::Network](network.md) instance used by `address` method (mainnet or testnet).
+
+#### address(network: *BTC::Network*)
+
+Returns a [BTC::PublicKeyAddress](p2pkh.md) instance with a given `network`.
+
+If `network` is not specified, `self.network` is used.
+
+#### to_wif(network: *BTC::Network*)
+
+Returns `private_key` encoded in [WIF](wif.md).
+
+Returns nil if `private_key` is nil.
+
+If `network` is not specified, `self.network` is used.
+
+#### dup
+
+Returns a new `BTC::Key` instance with the same `private_key`, `public_key` and `network`.
+
+#### ==
+
+Returns `true` if both instances have equal private and public keys.
+
+
+
+
+
+
+
+
+
+
+

data/documentation/keychain.md

@@ -0,0 +1,180 @@
+[Index](index.md)
+
+BTC::Keychain
+=============
+
+BTC::Keychain is an implementation of BIP32 "[Hierarchical Deterministic Wallets](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki)" (HD Wallets).
+
+Keychain encapsulates either a pair of "extended" keys (private and public), or only a public extended key.
+**Extended key** means the key (private or public) is accompanied by an extra 256 bits of entropy
+called **chain code** and some metadata about its position in a tree of keys (depth, parent fingerprint, index).
+
+Keychain allows to derive [keys](key.md) using an unsigned 32-bit integer called **index**.
+
+Keychain has two modes of operation:
+
+1. **Normal derivation** which allows to derive public keys separately from the private ones.
+2. **Hardened derivation** which derives keys from the private keychain.
+
+Derivation can be treated as a single key or as a new branch of keychains.
+BIP43 and BIP44 propose a way for wallets to organize streams of keys using Keychain.
+
+Examples
+--------
+
+Create a keychain with a seed, derive keychains and keys:
+
+```ruby
+keychain = Keychain.new(seed: "secret seed")
+keychain.derived_keychain(0).xpub     # => "xpub68YTawrm7..."
+keychain.derived_key(0).address.to_s  # => "1HosjTCbRD9og..."
+```
+
+You can derive keys using hardened method (`hardened` is `false` by default):
+
+```ruby
+keychain.derived_keychain(0, hardened: true).xpub     # => "xpub68YTawruT..."
+keychain.derived_key(0, hardened: true).address.to_s  # => "14ELmCNCnku1Y..."
+```
+
+You can specify entire paths:
+
+```ruby
+keychain.derived_key("44'/0'/0'/0/0").address.to_s # => "1fY2x5v63a..."
+```
+
+Initializers
+------------
+
+#### new(seed: *String*, network: *BTC::Network*)
+
+Returns a new `BTC::Keychain` instance initialized with a binary string `seed`.
+
+To generate `seed`, you may use [BTC::Data.random_data](data.md#random_data)(16).
+
+If `network` is not specified, [BTC::Network.default](network.md#default) is used.
+
+#### new(extended_key: *String*)
+
+Returns a new `BTC::Keychain` instance initialized with a given extended public or private key (`"xpub..."` or `"xprv..."`).
+
+`network` attribute is set based on the encoding of the extended key. If `"tpub..."` or `"tprv..."` is used, `Network.testnet` is assigned.
+
+#### new(xpub: *String*)
+
+An alias to `new(extended_key: ...)`.
+
+#### new(xprv: *String*)
+
+An alias to `new(extended_key: ...)`.
+
+
+Instance Methods
+----------------
+
+#### key
+
+Instance of [BTC::Key](key.md) that is a "head" of this keychain.
+If the keychain is public-only, `key` does not have a private component.
+
+#### chain_code
+
+A 32-byte binary "chain code" string used as an additional entropy in derivation procedure.
+
+#### extended\_public\_key
+
+A [Base58Check](base58.md)-encoded extended public key.
+Starts with `xpub` for mainnet and `tpub` for testnet.
+
+#### xpub
+
+An alias to `extended_public_key`.
+
+#### extended\_private\_key
+
+A [Base58Check](base58.md)-encoded extended private key.
+Starts with `xprv` for mainnet and `tprv` for testnet.
+
+#### xprv
+
+An alias to `extended_private_key`.
+
+#### identifier
+
+A 160-bit binary identifier (aka "hash") of the keychain.
+Equals `RIPEMD160(SHA256(key.public_key))`
+
+#### fingerprint
+
+32-bit unsigned integer extracted from `identifier`.
+
+#### parent_fingerprint
+
+A fingerprint of the parent keychain. Returns 0 for the master (root) keychain.
+
+#### index
+
+Index of this keychain (uint32) in the parent keychain. Returns 0 for master (root) keychain.
+
+#### depth
+
+Depth in the hierarchy (uint32). Returns 0 for master (root) keychain.
+
+#### network
+
+Returns a [BTC::Network](network.md) instance used to format extended public and private keys.
+
+#### private?
+
+Returns `true` if this keychain contains a private component (can derive both public and private keys).
+
+#### public?
+
+Returns `true` if this keychain does not contain a private component (can only derive public keys).
+
+#### hardened?
+
+Returns `true` if this keychain was derived using *hardened* method from its parent.
+For master (root) keychain returns `false`.
+
+#### public_keychain
+
+Returns a public-only copy of the keychain.
+
+#### derived_keychain(*index*, hardened: *false | true*)
+
+Returns a derived keychain with a given `index`.
+
+Raises `ArgumentError` if `index` is below zero or higher than 0x7fffffff.
+
+If `hardened` is `true`, uses private key for hardened derivation.
+If this is a public-only keychain, raises `BTCError`. Default value is `false`.
+
+#### derived_keychain(*path*)
+
+Returns a derived keychain with a given string `path`.
+Path is specified as a sequence of integers separated by a forward slash `/`.
+Integers can be suffixed with `'` to specify hardened derivation.
+Path can be optionally prefixed with `m/`.
+
+Raises `ArgumentError` if `path` is not a well-formed derivation path.
+
+The following are equivalent:
+
+```ruby
+k.derived_keychain(0) == k.derived_keychain("m/0")
+k.derived_keychain(1) == k.derived_keychain("1")
+k.derived_keychain(2, hardened: true) == k.derived_keychain("2'")
+k.derived_keychain(3).derived_keychain(4) == k.derived_keychain("3/4")
+k.derived_keychain(5, hardened: true).derived_keychain(6) == k.derived_keychain("m/5'/6")
+```
+
+#### derived_key(*index*, hardened: *false | true*)
+
+Equivalent to `derived_keychain(...).key`
+
+#### derived_key(*path*)
+
+Equivalent to `derived_keychain(path).key`
+
+

data/documentation/network.md

@@ -0,0 +1,75 @@
+[Index](index.md)
+
+BTC::Network
+============
+
+Network object specifies one of Bitcoin networks: `mainnet` or `testnet`.
+Network affects formatting of [addresses](address.md), private keys in [WIF](wif.md) format and
+extended private and public keys in [BIP32 Keychains](keychain.md).
+
+You typically use network by asking a specific object whether it belongs to mainnet or testnet:
+
+```ruby
+Address.parse("1A39uDWJkaPT2o5qr5dVBdvhZtNXeSNXM4").network.mainnet? # => true
+Address.parse("mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn").network.testnet? # => true
+WIF.parse("L3p8oAcQTtuokSCRHQ7i4MhjWc9zornvpJLfmg62sYpLRJF9woSu").network.testnet? # => false
+Keychain.new(xpub: "tpubD6NzVbkrYhZ4YFb9G...").network.mainnet? # => false
+```
+
+Class Methods
+-------------
+
+#### default
+
+Current default network used when creating a [BTC::Key](key.md) or [BTC::Keychain](keychain.md) without specifying network explicitly.
+By default equals `BTC::Network.mainnet`.
+
+You may use this to validate user input:
+
+```ruby
+address = Address.parse(user_entered_address)
+if address.network != Network.default
+  raise "Entered address is not compatible with the network used by application!"
+end
+```
+
+#### default=(network)
+
+Sets the default network to be used for all new objects that do not explicitly specify network.
+This setting does not affect already created objects that have some network specified.
+
+#### mainnet
+
+Returns a singleton object representing the "main" Bitcoin network.
+
+#### testnet
+
+Returns a singleton object representing the "testnet3" Bitcoin network.
+
+
+Instance Methods
+----------------
+
+#### name
+
+Returns a name of the network (`"mainnet"` or `"testnet"`).
+
+#### mainnet?
+
+Returns `true` if this network is mainnet.
+
+#### testnet?
+
+Returns `true` if this network is testnet3.
+
+#### genesis_block
+
+Returns an instance of `BTC::Block` containing the genesis block for this network.
+
+#### genesis\_block\_header
+
+Returns an instance of `BTC::BlockHeader` containing a header of the genesis block for this network.
+
+#### max_target
+
+Returns a maximum target for this network (as native Bignum type). See also [proof of work conversion methods](proof_of_work.md).

data/documentation/opcode.md

@@ -0,0 +1,220 @@
+[Index](index.md)
+
+BTC::Opcode
+===========
+
+**Operator** is a basic building block of the [script](script.md).
+It is a one-byte command (*opcode*) that performs a certain action during script evaluation.
+Module `BTC::Opcode` defines all available opcodes and conversion methods.
+
+There are two kinds of opcodes:
+
+* **Pushdata** — an opcode that pushes arbitrary data on stack.
+All opcodes with value less or equal `OP_PUSHDATA4` are *pushdata* opcodes (this includes `OP_0`, but does not include `OP_1`, `OP_2` etc.)
+* **Operation** — an opcode that performs some operation. This includes integer-pushing opcodes starting with `OP_1`.
+
+Module Functions
+----------------
+
+#### name\_for\_opcode(opcode)
+
+Returns a name for a given opcode value. For unknwon opcode returns `"OP_UNKNOWN"`
+
+```ruby
+Opcode.name_for_opcode(OP_VERIFY) # => "OP_VERIFY"
+```
+
+#### opcode\_for\_name(name)
+
+Returns an opcode value for a given name. For unknwon names returns `OP_INVALIDOPCODE` (0xFF).
+
+```ruby
+Opcode.opcode_for_name("OP_VERIFY") # => OP_VERIFY
+```
+
+#### opcode\_for\_small\_integer(int)
+
+Returns an opcode corresponding to a small integer (-1, 0, 1, ... 16).
+For invalid integer returns `OP_INVALIDOPCODE`.
+
+```ruby
+Opcode.opcode_for_small_integer(-1) # => OP_1NEGATE
+```
+
+#### small\_integer\_from\_opcode(opcode)
+
+Returns a small integer (-1, 0, 1, ... 16) corresponding to a given opcode.
+For invalid integer returns `nil`.
+
+```ruby
+Opcode.small_integer_from_opcode(OP_16) # => 16
+```
+
+
+Operators
+---------
+
+### 1. Operators pushing data on stack
+
+Name            | Value       |  Description
+:---------------|:------------|:-----------------------------------
+OP_FALSE        | 0x00        | Pushes byte `0` on the stack.
+OP_0            | 0x00        | Pushes byte `0` on the stack.
+OP_PUSHDATA*N*  | 0x01..0x4b  | Any opcode with value < `OP_PUSHDATA1` is a length of the string to be pushed on the stack. So opcode 0x01 is followed by 1 byte of data, 0x09 by 9 bytes and so on up to 0x4b (75 bytes).
+OP_PUSHDATA1    | 0x4c        | Followed by a 1-byte length of the string to push (allows pushing 0..255 bytes).
+OP_PUSHDATA2    | 0x4d        | Followed by a 2-byte length of the string to push (allows pushing 0..65535 bytes).
+OP_PUSHDATA4    | 0x4e        | Followed by a 4-byte length of the string to push (allows pushing 0..4294967295 bytes).
+OP_1NEGATE      | 0x4f        | Pushes number `-1` on the stack.
+OP_RESERVED     | 0x50        | Not assigned. If executed, transaction is invalid.
+OP_TRUE         | 0x51        | Pushes number `1` on the stack.
+OP_1            | 0x51        | Pushes number `1` on the stack.
+OP_2            | 0x52        | Pushes number `2` on the stack.
+OP_3            | 0x53        | Pushes number `3` on the stack.
+OP_4            | 0x54        | Pushes number `4` on the stack.
+OP_5            | 0x55        | Pushes number `5` on the stack.
+OP_6            | 0x56        | Pushes number `6` on the stack.
+OP_7            | 0x57        | Pushes number `7` on the stack.
+OP_8            | 0x58        | Pushes number `8` on the stack.
+OP_9            | 0x59        | Pushes number `9` on the stack.
+OP_10           | 0x5a        | Pushes number `10` on the stack.
+OP_11           | 0x5b        | Pushes number `11` on the stack.
+OP_12           | 0x5c        | Pushes number `12` on the stack.
+OP_13           | 0x5d        | Pushes number `13` on the stack.
+OP_14           | 0x5e        | Pushes number `14` on the stack.
+OP_15           | 0x5f        | Pushes number `15` on the stack.
+OP_16           | 0x60        | Pushes number `16` on the stack.
+
+
+### 2. Control Flow Operators
+
+Bitcoin executes all operators from `OP_IF` to `OP_ENDIF` even inside "non-executed" branch (to keep track of nesting).
+Since `OP_VERIF` and `OP_VERNOTIF` are not assigned, even inside a non-executed branch they will fall in "default:" switch case
+and cause the script to fail. Some other operators like `OP_VER` can be present inside non-executed branch because they'll be skipped.
+
+Name            | Value       |  Description
+:---------------|:------------|:-----------------------------------
+OP_NOP          | 0x61        | Does nothing.
+OP_VER          | 0x62        | Not assigned. If executed, transaction is invalid.
+OP_IF           | 0x63        | If the top stack value is not 0, the statements are executed. The top stack value is removed.
+OP_NOTIF        | 0x64        | If the top stack value is 0, the statements are executed. The top stack value is removed.
+OP_VERIF        | 0x65        | Not assigned. Script is invalid with that opcode (even if inside non-executed branch).
+OP_VERNOTIF     | 0x66        | Not assigned. Script is invalid with that opcode (even if inside non-executed branch).
+OP_ELSE         | 0x67        | Executes code if the previous `OP_IF` or `OP_NOTIF` was not executed.
+OP_ENDIF        | 0x68        | Finishes if/else block.
+OP_VERIFY       | 0x69        | Removes item from the stack if it's not 0x00 or 0x80 (negative zero). Otherwise, marks script as invalid.
+OP_RETURN       | 0x6a        | Marks transaction as invalid.
+
+### 3. Stack Operators
+
+Name            | Value       |  Description
+:---------------|:------------|:-----------------------------------
+OP_TOALTSTACK   | 0x6b        | Moves item from the stack to altstack.
+OP_FROMALTSTACK | 0x6c        | Moves item from the altstack to stack.
+OP_2DROP        | 0x6d        | Removes top 2 items from stack. Fails if less than 2 items are available.
+OP_2DUP         | 0x6e        | (a b → a b a b)
+OP_3DUP         | 0x6f        | (a b c → a b c a b c)
+OP_2OVER        | 0x70        | (a b c d → a b c d a b) 
+OP_2ROT         | 0x71        | (a b c d e f → c d e f a b)
+OP_2SWAP        | 0x72        | (a b c d → c d a b)
+OP_IFDUP        | 0x73        | Duplicates the top value only if it's not zero or negative zero (0x80).
+OP_DEPTH        | 0x74        | Adds size of the stack as a signed little-endian integer on stack.
+OP_DROP         | 0x75        | Removes the top value on stack.
+OP_DUP          | 0x76        | Duplicates the top value.
+OP_NIP          | 0x77        | Removes the value below the top one. Fails if less than 2 items are available.
+OP_OVER         | 0x78        | (a b → a b a)
+OP_PICK         | 0x79        | (x(n) ... x2 x1 x0 n → x(n) ... x2 x1 x0 x(n))
+OP_ROLL         | 0x7a        | (x(n) ... x2 x1 x0 n → x(n-1) ... x2 x1 x0 x(n))
+OP_ROT          | 0x7b        | (a b c → b c a)
+OP_SWAP         | 0x7c        | (a b → b a)
+OP_TUCK         | 0x7d        | (a b → b a b)
+
+
+### 4. Splice Operators
+
+Name            | Value       |  Description
+:---------------|:------------|:-----------------------------------
+OP_CAT          | 0x7e        | Disabled opcode. If executed, transaction is invalid.
+OP_SUBSTR       | 0x7f        | Disabled opcode. If executed, transaction is invalid.
+OP_LEFT         | 0x80        | Disabled opcode. If executed, transaction is invalid.
+OP_RIGHT        | 0x81        | Disabled opcode. If executed, transaction is invalid.
+OP_SIZE         | 0x82        | Adds byte length of the top item as a signed little-endian integer.
+
+
+### 5. Logic Operators
+
+Name            | Value       |  Description
+:---------------|:------------|:-----------------------------------
+OP_INVERT       | 0x83        | Disabled opcode. If executed, transaction is invalid.
+OP_AND          | 0x84        | Disabled opcode. If executed, transaction is invalid.
+OP_OR           | 0x85        | Disabled opcode. If executed, transaction is invalid.
+OP_XOR          | 0x86        | Disabled opcode. If executed, transaction is invalid.
+OP_EQUAL        | 0x87        | Last two items are removed from the stack and compared. Result (`true` or `false`) is pushed to the stack.
+OP\_EQUALVERIFY | 0x88        | Same as `OP_EQUAL`, but removes the result from the stack if it's true or marks script as invalid.
+OP_RESERVED1    | 0x89        | Disabled opcode. If executed, transaction is invalid.
+OP_RESERVED2    | 0x8a        | Disabled opcode. If executed, transaction is invalid.
+
+### 6. Numeric Operators
+
+Name                  | Value |  Description
+:---------------------|:------|:-----------------------------------
+OP_1ADD               | 0x8b  | Adds 1 to last item, pops it from stack and pushes result.
+OP_1SUB               | 0x8c  | Substracts 1 to last item, pops it from stack and pushes result.
+OP_2MUL               | 0x8d  | Disabled opcode. If executed, transaction is invalid.
+OP_2DIV               | 0x8e  | Disabled opcode. If executed, transaction is invalid.
+OP_NEGATE             | 0x8f  | Negates the number, pops it from stack and pushes result.
+OP_ABS                | 0x90  | Replaces number with its absolute value
+OP_NOT                | 0x91  | Replaces number with True if it's zero, False otherwise.
+OP_0NOTEQUAL          | 0x92  | Replaces number with True if it's not zero, False otherwise.
+OP_ADD                | 0x93  | (x y → x+y)
+OP_SUB                | 0x94  | (x y → x-y)
+OP_MUL                | 0x95  | Disabled opcode. If executed, transaction is invalid.
+OP_DIV                | 0x96  | Disabled opcode. If executed, transaction is invalid.
+OP_MOD                | 0x97  | Disabled opcode. If executed, transaction is invalid.
+OP_LSHIFT             | 0x98  | Disabled opcode. If executed, transaction is invalid.
+OP_RSHIFT             | 0x99  | Disabled opcode. If executed, transaction is invalid.
+OP_BOOLAND            | 0x9a  | (x y → x and y)
+OP_BOOLOR             | 0x9b  | (x y → x or y)
+OP_NUMEQUAL           | 0x9c  | (x y → x == y)
+OP_NUMEQUALVERIFY     | 0x9d  | Same as `OP_NUMEQUAL OP_VERIFY`.
+OP_NUMNOTEQUAL        | 0x9e  | (x y → x ≠ y)
+OP_LESSTHAN           | 0x9f  | (x y → x < y)
+OP_GREATERTHAN        | 0xa0  | (x y → x > y)
+OP_LESSTHANOREQUAL    | 0xa1  | (x y → x ≤ y)
+OP_GREATERTHANOREQUAL | 0xa2  | (x y → x ≥ y)
+OP_MIN                | 0xa3  | (x y → min(x,y))
+OP_MAX                | 0xa4  | (x y → max(x,y))
+OP_WITHIN             | 0xa5  | (x min max → min ≤ x < max)
+
+### 7. Crypto Operators
+
+
+Name                   | Value       |  Description
+:----------------------|:------------|:-----------------------------------
+OP_RIPEMD160           | 0xa6        | Replaces top value with its [RIPEMD-160](http://en.wikipedia.org/wiki/RIPEMD) hash.
+OP_SHA1                | 0xa7        | Replaces top value with its [SHA-1](http://en.wikipedia.org/wiki/SHA-1) hash.
+OP_SHA256              | 0xa8        | Replaces top value with its [SHA-256](http://en.wikipedia.org/wiki/SHA-2) hash.
+OP_HASH160             | 0xa9        | Replaces top value with the result of `RIPEMD-160(SHA-256(string)`.
+OP_HASH256             | 0xaa        | Replaces top value with the result of `SHA-256(SHA-256(string))`.
+OP_CODESEPARATOR       | 0xab        | This opcode is obsolete and does effectively nothing.
+OP_CHECKSIG            | 0xac        | (*signature* *pubkey* → true/false) Verifies transaction signature (with [hashtype](signature.md) byte) with a given public key.
+OP_CHECKSIGVERIFY      | 0xad        | Same as `OP_CHECKSIG OP_VERIFY`
+OP_CHECKMULTISIG       | 0xae        | (OP\_0 *signatures* *M* *pubkeys* *N* → true/false) Verifies transaction signatures (each must have a [hashtype](signature.md) byte) against the given public keys. Signatures must be provided in the same order as corresponding public keys.
+OP_CHECKMULTISIGVERIFY | 0xaf        | Same as `OP_CHECKMULTISIG OP_VERIFY`
+
+
+### 8. Expansion Opcodes
+
+Name                   | Value       |  Description
+:----------------------|:------------|:-----------------------------------
+OP_NOP1                | 0xb0        | Does nothing.
+OP_NOP2                | 0xb1        | Does nothing.
+OP_NOP3                | 0xb2        | Does nothing.
+OP_NOP4                | 0xb3        | Does nothing.
+OP_NOP5                | 0xb4        | Does nothing.
+OP_NOP6                | 0xb5        | Does nothing.
+OP_NOP7                | 0xb6        | Does nothing.
+OP_NOP8                | 0xb7        | Does nothing.
+OP_NOP9                | 0xb8        | Does nothing.
+OP_NOP10               | 0xb9        | Does nothing.
+OP_INVALIDOPCODE       | 0xff        | Invalid opcode. If executed, transaction is invalid.
+

data/documentation/openssl.md

@@ -0,0 +1,7 @@
+[Index](index.md)
+
+BTC::OpenSSL
+===============
+
+A module containing FFI bindings to native OpenSSL functions. 
+Implements low-level primitives to create ECDSA signatures, transform public keys, perform arithmetic with big integers.