sigma_rb 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2da1237215d9dd9b9734403cb13606b66cd3e80ea128a1d301180aec84720739
-  data.tar.gz: 8e7d5e940c16718d66fbfaaa3ac71c751ae107d925783e25ec163781acc2e06e
+  metadata.gz: e3900571641a51eca478e3ab63bad7ff89be2f71b9dcbd29718a969203f4edec
+  data.tar.gz: 269840887d7914e8a22ea0127a70456956851d9afc7078d7a38c6a33e712d40d
 SHA512:
-  metadata.gz: 2111272de78b3807f966f984d1986c904e6f34543c06365bfddee20a8a9269d91cad6fd8b8147e9148ffcc500105f35fdf73bd100c69cf43151910622fcb14fb
-  data.tar.gz: 1a0d61d66d6d706b05c9e2c81142bbe28e90f0584d4d555b16e08218286f05d20eee572e0ff158b134918a202bd7556d1aa45875290d71dbae2a1d09e96dd78c
+  metadata.gz: d6d5b264166b3fdff4d72560ddc80c2908e33de7d27b2780b7d07943eea78ac11c434914aa5ab5001fbe781bfc85cce45e37bac9824405c957a52bca836b485e
+  data.tar.gz: 421c9a38cc1bcf2852e99d7d4e4f0c0a6c5886c5a6c101fc8e7779bc965f8d210c940e29a1fa9c801df963cd56962acc54f32577e8e009fc459f9f28e43830b5

data/README.md

@@ -1,9 +1,71 @@
 # sigma_rb
-Ruby bindings for https://github.com/ergoplatform/sigma-rust
+Ruby wrapper around C bindings for ErgoLib from [Sigma-Rust](https://github.com/ergoplatform/sigma-rust)
 
+# Installation
+This project wraps the C bindings of Sigma-Rust and so they are required for using this gem. As the Sigma-Rust API changes over time, gem versions are tied to specific Sigma-Rust versions.
 
-### TODO
-- [ ] Package up into gem
-- [ ] Add installation instructions and target platforms to README
-- [ ] Add pointers to example usage to README
-- [ ] Add YARD documentation so docs can be generated and viewed at https://www.rubydoc.info/
+| Sigma_rb Version | Sigma-Rust Version |
+| ---------------- | -------------------|
+| 0.1.3            | 0.16.0             |
+
+
+## Build ErgoLib Dependencies
+Checkout the supported Sigma-Rust version on the [releases](https://github.com/ergoplatform/sigma-rust/releases) page .
+
+### Build the ergo-lib-c bindings
+I will provide instructions below but it may be worth reading over the [directions in Sigma-Rust too](https://github.com/ergoplatform/sigma-rust/tree/develop/bindings/ergo-lib-c)  
+
+Sigma-Rust uses Rust to generate these C bindings and so you will need Rust. I recommend downloading the nightly version of Rust as you will need nightly Rust for the next step.   
+
+After checking out the proper Sigma-Rust and starting at it's root directory:
+```
+cd bindings/ergo-lib-c
+cargo build --release -p ergo-lib-c
+```
+
+This will build a release version of `libergo.a` located at `target/release/libergo.a` from the root directory.  You will need to copy/move this to a C LIBRARY search path on your system. For my system I can use `/usr/local/lib` . This usually depends on OS.   
+
+So I did this to copy `libergo.a` to `/usr/local/lib` :  
+```
+sudo cp ../../target/release/libergo.a /usr/local/lib/
+```  
+
+### Build ergo-lib-c header file
+While still in the `bindings/ergo-lib_c` directory you can generate the header file with:
+```
+cbindgen --config cbindgen.toml --crate ergo-lib-c --output h/ergo_lib.h
+```
+
+You will need to copy/move this header to a C INCLUDE search path. On my system I can use `/usr/local/include` . So I ran the following command to copy the header:  
+```  
+sudo cp h/ergo_lib.h /usr/local/include/
+```
+
+## Add to Gemfile
+Once you have `libergo.a` and `ergo_lib.h` downloaded and placed in locations your C compiler can find you should be able to to install the gem.  
+
+In Gemfile
+```
+gem 'sigma_rb', '0.1.3'
+```
+
+Run bundle to install
+```
+bundle
+```
+
+After a successful install you can use it by requiring `sigma`  
+```
+require 'sigma'
+
+puts Sigma::BoxValue.units_per_ergo
+```
+
+# Examples
+Check out `tests/sigma` for usage examples. The transaction tests are probably the most involved, located at [tests/sigma/transaction_test.rb](https://github.com/thedlop/sigma_rb/blob/master/tests/sigma/transaction_test.rb).  
+
+# Documentation
+Generated documentation can be viewed on [RubyDoc](https://www.rubydoc.info/gems/sigma_rb). 
+
+# Thank You
+Thank you to the Ergo Development community for consistent words of encouragement. Big thanks to Sigma-Rust maintainers for providing the C bindings which made this possible. Thank you to the iOS bindings developers as it was a constant reference for this work.

data/lib/sigma/address.rb

@@ -3,6 +3,48 @@ require_relative './util.rb'
 require 'ffi-compiler/loader'
 
 module Sigma
+  #
+  # An address is a short string corresponding to some script used to protect a box. Unlike (string-encoded) binary
+  # representation of a script, an address has some useful characteristics:
+  #
+  # - Integrity of an address could be checked., as it is incorporating a checksum.
+  # - A prefix of address is showing network and an address type.
+  # - An address is using an encoding (namely, Base58) which is avoiding similarly l0Oking characters, friendly to
+  # double-clicking and line-breaking in emails.
+  #
+  #
+  #
+  # An address is encoding network type, address type, checksum, and enough information to watch for a particular scripts.
+  #
+  # Possible network types are:  
+  # Mainnet - 0x00  
+  # Testnet - 0x10  
+  #
+  # For an address type, we form content bytes as follows:
+  #
+  # P2PK - serialized (compressed) public key  
+  # P2SH - first 192 bits of the Blake2b256 hash of serialized script bytes  
+  # P2S  - serialized script  
+  #                                                                                                                                                             
+  # Address examples for testnet:  
+  # 3   - P2PK (3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN)  
+  # ?   - P2SH (rbcrmKEYduUvADj9Ts3dSVSG27h54pgrq5fPuwB)  
+  # ?   - P2S (Ms7smJwLGbUAjuWQ)  
+  #
+  # for mainnet:  
+  #
+  # 9  - P2PK (9fRAWhdxEsTcdb8PhGNrZfwqa65zfkuYHAMmkQLcic1gdLSV5vA)  
+  # ?  - P2SH (8UApt8czfFVuTgQmMwtsRBZ4nfWquNiSwCWUjMg)  
+  # ?  - P2S (4MQyML64GnzMxZgm, BxKBaHkvrTvLZrDcZjcsxsF7aSsrN73ijeFZXtbj4CXZHHcvBtqSxQ)  
+  #
+  #
+  # Prefix byte = network type + address type  
+  #
+  # checksum = blake2b256(prefix byte ++ content bytes)  
+  #
+  # address = prefix byte ++ content bytes ++ checksum
+  #
+  #
   class Address
     extend FFI::Library
     ffi_lib FFI::Compiler::Loader.find('csigma')
@@ -15,10 +57,17 @@ module Sigma
     attach_function :ergo_lib_address_type_prefix, [:pointer], :uint8
     attr_accessor :pointer
 
-    def self.with_raw_pointer(unread_pointer)
-      init(unread_pointer)
+    # Takes ownership of an existing Address Pointer.
+    # @note A user of sigma_rb generally does not need to call this function
+    # @param pointer [FFI::MemoryPointer]
+    # @return [Address]
+    def self.with_raw_pointer(pointer)
+      init(pointer)
     end
 
+    # Decode (base58) testnet address from string and create Address, checking that address is from the testnet
+    # @param address_str [String]
+    # @return [Address]
     def self.with_testnet_address(address_str)
       pointer = FFI::MemoryPointer.new(:pointer)
       error = ergo_lib_address_from_testnet(address_str, pointer)
@@ -27,6 +76,9 @@ module Sigma
       init(pointer)
     end
 
+    # Decode (base58) mainnet address from string and create Address, checking that address is from the testnet
+    # @param address_str [String]
+    # @return [Address]
     def self.with_mainnet_address(address_str)
       pointer = FFI::MemoryPointer.new(:pointer)
       error = ergo_lib_address_from_mainnet(address_str, pointer)
@@ -35,6 +87,9 @@ module Sigma
       init(pointer)
     end
 
+    # Decode (base58) address from string and create Address, no checking of network prefix
+    # @param address_str [String]
+    # @return [Address]
     def self.with_base58_address(address_str)
       pointer = FFI::MemoryPointer.new(:pointer)
       error = ergo_lib_address_from_base58(address_str, pointer)
@@ -43,6 +98,10 @@ module Sigma
       init(pointer)
     end
 
+    # Encode Address to a base58 string
+    # @see Sigma::NETWORK_PREFIX_ENUM
+    # @param network_prefix [Integer]
+    # @return [String]
     def to_base58(network_prefix)
       s_ptr = FFI::MemoryPointer.new(:pointer, 1)
       pointer = FFI::MemoryPointer.new(:pointer)
@@ -53,6 +112,9 @@ module Sigma
       str
     end
 
+    # Get the Network Prefix type of Address
+    # @see Sigma::NETWORK_PREFIX_ENUM
+    # @return [Integer]
     def type_prefix
       ergo_lib_address_type_prefix(self.pointer)
     end

data/lib/sigma/block_header.rb

@@ -3,6 +3,7 @@ require_relative './util.rb'
 require 'ffi-compiler/loader'
 
 module Sigma
+  # Represents data available of the Block Header in Sigma propositions.
   class BlockHeader
     extend FFI::Library
     ffi_lib FFI::Compiler::Loader.find('csigma')
@@ -12,6 +13,9 @@ module Sigma
     attach_function :ergo_lib_block_header_eq, [:pointer, :pointer], :bool
     attr_accessor :pointer
 
+    # Parse BlockHeader array from json (NODE API)
+    # @param json [String]
+    # @return [BlockHeader]
     def self.with_json(json)
       pointer = FFI::MemoryPointer.new(:pointer) 
       error = ergo_lib_block_header_from_json(json, pointer)
@@ -19,16 +23,25 @@ module Sigma
       init(pointer)
     end
 
+    # Takes ownership of an existing BlockHeader Pointer.
+    # @note A user of sigma_rb generally does not need to call this function
+    # @param pointer [FFI::MemoryPointer]
+    # @return [BlockHeader]
     def self.with_raw_pointer(pointer)
       init(pointer)
     end
 
+    # Get BlockId of BlockHeader
+    # @return [BlockId]
     def get_block_id
       pointer = FFI::MemoryPointer.new(:pointer) 
       ergo_lib_block_header_id(self.pointer, pointer)
       Sigma::BlockId.with_raw_pointer(:pointer)
     end
 
+    # Equality check between two BlockHeaders 
+    # @param bh_two [BlockHeader]
+    # @return [bool]
     def ==(bh_two)
       ergo_lib_block_header_eq(self.pointer, bh_two.pointer)
     end
@@ -47,6 +60,7 @@ module Sigma
     end
   end
 
+  # An ordered collection of BlockHeader
   class BlockHeaders
     extend FFI::Library
     ffi_lib FFI::Compiler::Loader.find('csigma')
@@ -58,10 +72,16 @@ module Sigma
     attach_function :ergo_lib_block_headers_get, [:pointer, :uint8, :pointer], ReturnOption.by_value
     attr_accessor :pointer
 
+    # Takes ownership of an existing BlockHeaders Pointer.
+    # @note A user of sigma_rb generally does not need to call this function
+    # @param pointer [FFI::MemoryPointer]
+    # @return [BlockHeaders]
     def self.with_raw_pointer(unread_pointer)
       init(unread_pointer)
     end
 
+    # Create an empty collection
+    # @return [BlockHeaders]
     def self.create
       pointer = FFI::MemoryPointer.new(:pointer)
       ergo_lib_block_headers_new(pointer)
@@ -69,7 +89,9 @@ module Sigma
       init(pointer)
     end
 
-    # Parameter is an ARRAY of JSON Strings
+    # Parse BlockHeaders from array of JSON
+    # @param array_of_json_elements [Array<String>]
+    # @return [BlockHeaders]
     def self.from_json(array_of_json_elements)
       headers = array_of_json_elements.map do |json|
         Sigma::BlockHeader.with_json(json)
@@ -81,14 +103,21 @@ module Sigma
       container
     end
 
+    # Get length of BlockHeaders
+    # @return [Integer]
     def len
       ergo_lib_block_headers_len(self.pointer)
     end
 
+    # Add a BlockHeader
+    # @param block_header [BlockHeader]
     def add(block_header)
       ergo_lib_block_headers_add(block_header.pointer, self.pointer)
     end
 
+    # Get item at specified index or return nil if no item exists
+    # @params index [Integer]
+    # @return [BlockHeader, nil]
     def get(index)
       pointer = FFI::MemoryPointer.new(:pointer)
       res = ergo_lib_block_headers_get(self.pointer, index, pointer)
@@ -114,6 +143,7 @@ module Sigma
     end
   end
 
+  # Represents the Id of a BlockHeader
   class BlockId
     extend FFI::Library
     ffi_lib FFI::Compiler::Loader.find('csigma')
@@ -121,6 +151,10 @@ module Sigma
     attach_function :ergo_lib_block_id_delete, [:pointer], :void
     attr_accessor :pointer
 
+    # Takes ownership of an existing BlockId Pointer.
+    # @note A user of sigma_rb generally does not need to call this function
+    # @param pointer [FFI::MemoryPointer]
+    # @return [BlockId]
     def self.with_raw_pointer(pointer)
       init(pointer)
     end
@@ -139,6 +173,7 @@ module Sigma
     end
   end
 
+  # An ordered collection of BlockId
   class BlockIds
     extend FFI::Library
     ffi_lib FFI::Compiler::Loader.find('csigma')
@@ -150,10 +185,16 @@ module Sigma
     attach_function :ergo_lib_block_ids_get, [:pointer, :uint8, :pointer], ReturnOption.by_value
     attr_accessor :pointer
 
+    # Takes ownership of an existing BlockIds Pointer.
+    # @note A user of sigma_rb generally does not need to call this function
+    # @param pointer [FFI::MemoryPointer]
+    # @return [BlockIds]
     def self.with_raw_pointer(unread_pointer)
       init(unread_pointer)
     end
 
+    # Create an empty collection
+    # @return [BlockIds]
     def self.create
       pointer = FFI::MemoryPointer.new(:pointer)
       ergo_lib_block_ids_new(pointer)
@@ -161,14 +202,21 @@ module Sigma
       init(pointer)
     end
 
+    # Get length of collection
+    # @return [Integer]
     def len
       ergo_lib_block_ids_len(self.pointer)
     end
 
+    # Add to collection
+    # @param block_id [BlockId]
     def add(block_id)
       ergo_lib_block_ids_add(block_id.pointer, self.pointer)
     end
 
+    # Get item at specified index or return nil if no item exists
+    # @param index [Integer]
+    # @return [BlockId, nil]
     def get(index)
       pointer = FFI::MemoryPointer.new(:pointer)
       res = ergo_lib_block_ids_get(self.pointer, index, pointer)

data/lib/sigma/box_selection.rb

@@ -3,6 +3,8 @@ require_relative './util.rb'
 require 'ffi-compiler/loader'
 
 module Sigma
+  # Selected boxes with change boxes. Instances of this class are created by SimpleBoxSelector.
+  # @see SimpleBoxSelector
   class BoxSelection
     extend FFI::Library
     ffi_lib FFI::Compiler::Loader.find('csigma')
@@ -15,28 +17,43 @@ module Sigma
 
     attr_accessor :pointer
 
+    # Create a selection to inject custom select algorithms
+    # @param ergo_boxes [ErgoBoxes]
+    # @param change_ergo_boxes [ErgoBoxAssetsDataList]
+    # @return [BoxSelection]
     def self.create(ergo_boxes:, change_ergo_boxes:)
       pointer = FFI::MemoryPointer.new(:pointer)
       ergo_lib_box_selection_new(ergo_boxes.pointer, change_ergo_boxes.pointer, pointer)
       init(pointer)
     end
 
+    # Takes ownership of an existing BoxSelection Pointer.
+    # @note A user of sigma_rb generally does not need to call this function
+    # @param pointer [FFI::MemoryPointer]
+    # @return [BoxSelection]
     def self.with_raw_pointer(pointer)
       init(pointer)
     end
 
+    # Selected Boxes to spend as transaction inputs
+    # @return [ErgoBoxes]
     def get_boxes
       pointer = FFI::MemoryPointer.new(:pointer)
       ergo_lib_box_selection_boxes(self.pointer, pointer)
       Sigma::ErgoBoxes.with_raw_pointer(pointer)
     end
 
+    # Selected Boxes to use as change
+    # @return [ErgoBoxAssetsDataList]
     def get_change_boxes
       pointer = FFI::MemoryPointer.new(:pointer)
       ergo_lib_box_selection_change(self.pointer, pointer)
       Sigma::ErgoBoxAssetsDataList.with_raw_pointer(pointer)
     end
 
+    # Equality check between two BoxSelections
+    # @param bs_two [BoxSelection]
+    # @return [bool]
     def ==(bs_two)
       ergo_lib_box_selection_eq(self.pointer, bs_two.pointer)
     end
@@ -55,6 +72,7 @@ module Sigma
     end
   end
 
+  # Naive box selector, collects inputs until target balace is reached
   class SimpleBoxSelector
     extend FFI::Library
     ffi_lib FFI::Compiler::Loader.find('csigma')
@@ -65,12 +83,19 @@ module Sigma
 
     attr_accessor :pointer
 
+    # Create an empty SimpleBoxSelector
+    # @return [SimpleBoxSelector]
     def self.create
       pointer = FFI::MemoryPointer.new(:pointer)
       ergo_lib_simple_box_selector_new(pointer)
       init(pointer)
     end
 
+    # Selects inputs to satisfy target balance and tokens
+    # @param inputs [ErgoBoxes] Available inputs (returns error if empty)
+    # @param target_balance [BoxValue] coins (in nanoERGs) needed
+    # @param target_tokens [Tokens] amount of tokens needed
+    # @return [BoxSelection] selected inputs and box assets(value + tokens) with change
     def select(inputs:, target_balance:, target_tokens:)
       pointer = FFI::MemoryPointer.new(:pointer)
       error = ergo_lib_simple_box_selector_select(
@@ -84,6 +109,10 @@ module Sigma
       Sigma::BoxSelection.with_raw_pointer(pointer)
     end
 
+    # Takes ownership of an existing SimpleBoxSelector Pointer.
+    # @note A user of sigma_rb generally does not need to call this function
+    # @param pointer [FFI::MemoryPointer]
+    # @return [SimpleBoxSelector]
     def self.with_raw_pointer(pointer)
       init(pointer)
     end

data/lib/sigma/byte_array.rb

@@ -3,6 +3,7 @@ require_relative './util.rb'
 require 'ffi-compiler/loader'
 
 module Sigma
+  # Array of Bytes
   class ByteArray
     extend FFI::Library
     ffi_lib FFI::Compiler::Loader.find('csigma')
@@ -11,6 +12,9 @@ module Sigma
     attach_function :ergo_lib_byte_array_from_raw_parts, [:pointer, :uint, :pointer], :error_pointer
     attr_accessor :pointer
 
+    # Create ByteArray of Array of unsigned 8-bit ints (bytes)
+    # @param bytes [Array<uint8>] Array of 8-bit integers (0-255)
+    # @return [ByteArray]
     def self.from_bytes(bytes)
       pointer = FFI::MemoryPointer.new(:pointer)
       b_ptr = FFI::MemoryPointer.new(:uint8, bytes.size)
@@ -20,6 +24,10 @@ module Sigma
       init(pointer)
     end
 
+    # Takes ownership of an existing ByteArray Pointer.
+    # @note A user of sigma_rb generally does not need to call this function
+    # @param pointer [FFI::MemoryPointer]
+    # @return [ByteArray]
     def self.with_raw_pointer(pointer)
       init(pointer)
     end
@@ -38,6 +46,7 @@ module Sigma
     end
   end
 
+  # An ordered collection of ByteArray
   class ByteArrays
     extend FFI::Library
     ffi_lib FFI::Compiler::Loader.find('csigma')
@@ -50,10 +59,16 @@ module Sigma
 
     attr_accessor :pointer
 
+    # Takes ownership of an existing ByteArrays Pointer.
+    # @note A user of sigma_rb generally does not need to call this function
+    # @param pointer [FFI::MemoryPointer]
+    # @return [ByteArrays]
     def self.with_raw_pointer(unread_pointer)
       init(unread_pointer)
     end
 
+    # Create an empty collection
+    # @return [ByteArrays]
     def self.create
       pointer = FFI::MemoryPointer.new(:pointer)
       ergo_lib_byte_arrays_new(pointer)
@@ -61,14 +76,21 @@ module Sigma
       init(pointer)
     end
 
+    # Get length of collection
+    # @return [Integer]
     def len
       ergo_lib_byte_arrays_len(self.pointer)
     end
 
+    # Add an item to collection
+    # @param byte_array [ByteArray]
     def add(byte_array)
       ergo_lib_byte_arrays_add(byte_array.pointer, self.pointer)
     end
 
+    # Get item at specified index or return nil if no item exists
+    # @params index [Integer]
+    # @return [ByteArray, nil]
     def get(index)
       pointer = FFI::MemoryPointer.new(:pointer)
       res = ergo_lib_byte_arrays_get(self.pointer, index, pointer)

data/lib/sigma/constant.rb

@@ -3,6 +3,7 @@ require_relative './util.rb'
 require 'ffi-compiler/loader'
 
 module Sigma
+  # Ergo constant (evaluated) values
   class Constant
     extend FFI::Library
     ffi_lib FFI::Compiler::Loader.find('csigma')
@@ -20,6 +21,9 @@ module Sigma
     attach_function :ergo_lib_constant_delete, [:pointer], :void
     attr_accessor :pointer
 
+    # Create from ergo_box value
+    # @param ergo_box [ErgoBox]
+    # @return [Constant]
     def self.with_ergo_box(ergo_box)
       c_ptr = FFI::MemoryPointer.new(:pointer)
       ergo_lib_constant_from_ergo_box(ergo_box.pointer, c_ptr)
@@ -27,6 +31,9 @@ module Sigma
       init(c_ptr)
     end
 
+    # Create from byte array
+    # @param bytes [Array<uint8>] Array of unsigned 8-bit (0-255) integers
+    # @return [Constant]
     def self.with_bytes(bytes)
       c_ptr = FFI::MemoryPointer.new(:pointer)
       b_ptr = FFI::MemoryPointer.new(:uint8, bytes.size)
@@ -37,6 +44,9 @@ module Sigma
       init(c_ptr)
     end
 
+    # Parse raw EcPoint value from bytes and make ProveDlog constant
+    # @param bytes [Array<uint8>] Array of unsigned 8-bit (0-255) integers
+    # @return [Constant]
     def self.with_ecpoint_bytes(bytes)
       c_ptr = FFI::MemoryPointer.new(:pointer)
       b_ptr = FFI::MemoryPointer.new(:uint8, bytes.size)
@@ -47,20 +57,9 @@ module Sigma
       init(c_ptr)
     end
 
-    def self.with_raw_pointer(constant_pointer)
-      init(constant_pointer)
-    end
-
-    def to_base16_string
-      s_ptr = FFI::MemoryPointer.new(:pointer, 1)
-      error = ergo_lib_constant_to_base16(self.pointer, s_ptr)
-      Util.check_error!(error)
-      s_ptr = s_ptr.read_pointer()
-      str = s_ptr.read_string().force_encoding('UTF-8')
-      Util.ergo_lib_delete_string(s_ptr)
-      str
-    end
-
+    # Create from 32-bit integer
+    # @param int [Integer]
+    # @return [Constant]
     def self.with_i32(int)
       pointer = FFI::MemoryPointer.new(:pointer)
       error = ergo_lib_constant_from_i32(int, pointer)
@@ -69,6 +68,9 @@ module Sigma
       init(pointer)
     end
 
+    # Create from 64-bit integer
+    # @param int [Integer]
+    # @return [Constant]
     def self.with_i64(int)
       pointer = FFI::MemoryPointer.new(:pointer)
       error = ergo_lib_constant_from_i64(int, pointer)
@@ -85,18 +87,45 @@ module Sigma
       init(c_ptr)
     end
 
+    # Takes ownership of an existing Constant Pointer.
+    # @note A user of sigma_rb generally does not need to call this function
+    # @param pointer [FFI::MemoryPointer]
+    # @return [Constant]
+    def self.with_raw_pointer(constant_pointer)
+      init(constant_pointer)
+    end
+
+    # Encode as Base16-encoded ErgoTree serialized value or throw an error if serialization failed
+    # @return [String] Base-16 encoded ErgoTree serialized value
+    def to_base16_string
+      s_ptr = FFI::MemoryPointer.new(:pointer, 1)
+      error = ergo_lib_constant_to_base16(self.pointer, s_ptr)
+      Util.check_error!(error)
+      s_ptr = s_ptr.read_pointer()
+      str = s_ptr.read_string().force_encoding('UTF-8')
+      Util.ergo_lib_delete_string(s_ptr)
+      str
+    end
+
+    # Extract 32-bit integer value, throw error if wrong type
+    # @return [Integer]
     def to_i32
       res = ergo_lib_constant_to_i32(self.pointer)
       Util.check_error!(res[:error])
       res[:value]
     end
 
+    # Extract 64-bit integer value, throw error if wrong type
+    # @return [Integer]
     def to_i64
       res = ergo_lib_constant_to_i64(self.pointer)
       Util.check_error!(res[:error])
       res[:value]
     end
 
+    # Equality check for two Constants
+    # @param constant_two [Constant]
+    # @return [bool]
     def ==(constant_two)
       ergo_lib_constant_eq(self.pointer, constant_two.pointer)
     end

data/lib/sigma/context_extension.rb

@@ -3,6 +3,7 @@ require_relative './util.rb'
 require 'ffi-compiler/loader'
 
 module Sigma
+  # User-defined variables to be put into context
   class ContextExtension
     extend FFI::Library
     ffi_lib FFI::Compiler::Loader.find('csigma')
@@ -13,16 +14,25 @@ module Sigma
     attach_function :ergo_lib_context_extension_keys, [:pointer, :pointer], :void
     attr_accessor :pointer
 
+    # Creates an empty ContextExtension
+    # @return [ContextExtension]
     def self.create
       pointer = FFI::MemoryPointer.new(:pointer)
       ergo_lib_context_extension_empty(pointer)
       init(pointer) 
     end
 
+    
+    # Takes ownership of an existing ContextExtension Pointer.
+    # @note A user of sigma_rb generally does not need to call this function
+    # @param pointer [FFI::MemoryPointer]
+    # @return [ContextExtension]
     def self.with_raw_pointer(pointer)
       init(pointer)
     end
 
+    # Get all keys in the map
+    # @return [Array<uint8>]
     def get_keys
       ce_len = ergo_lib_context_extension_len(self.pointer)
       b_ptr = FFI::MemoryPointer.new(:uint8, ce_len)