sigma_rb 0.1.3

data/lib/sigma/ergo_tree.rb

@@ -0,0 +1,111 @@
+require 'ffi'
+require_relative './util.rb'
+require 'ffi-compiler/loader'
+
+module Sigma
+  class ErgoTree
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_ergo_tree_delete, [:pointer], :void
+    attach_function :ergo_lib_ergo_tree_eq, [:pointer, :pointer], :bool
+    attach_function :ergo_lib_ergo_tree_from_base16_bytes, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_ergo_tree_to_base16_bytes, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_ergo_tree_to_bytes, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_ergo_tree_template_bytes, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_ergo_tree_bytes_len, [:pointer], ReturnNumUsize.by_value
+    attach_function :ergo_lib_ergo_tree_template_bytes_len, [:pointer], ReturnNumUsize.by_value
+    attach_function :ergo_lib_ergo_tree_with_constant, [:pointer, :uint8, :pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_ergo_tree_constants_len, [:pointer], ReturnNumUsize.by_value
+    attach_function :ergo_lib_ergo_tree_get_constant, [:pointer, :uint8, :pointer], ReturnOption.by_value
+    attr_accessor :pointer
+
+    def self.with_raw_pointer(unread_pointer)
+      init(unread_pointer)
+    end
+
+    def self.from_base16_encoded_string(encoded_str)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_ergo_tree_from_base16_bytes(encoded_str, pointer)
+      Util.check_error!(error)
+
+      init(pointer)
+    end
+
+    def to_base16_encoded_string
+      s_ptr = FFI::MemoryPointer.new(:pointer, 1)
+      error = ergo_lib_ergo_tree_to_base16_bytes(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
+
+    def to_bytes
+      res = ergo_lib_ergo_tree_bytes_len(self.pointer)
+      Util.check_error!(res[:error])
+      bytes_length = res[:value]
+      bytes_ptr = FFI::MemoryPointer.new(:uint8, bytes_length)
+      error = ergo_lib_ergo_tree_to_bytes(self.pointer, bytes_ptr)
+      Util.check_error!(error)
+      bytes_ptr.read_array_of_uint8(bytes_length)
+    end
+
+    def to_template_bytes
+      res = ergo_lib_ergo_tree_template_bytes_len(self.pointer)
+      Util.check_error!(res[:error])
+      bytes_length = res[:value]
+      bytes_ptr = FFI::MemoryPointer.new(:uint8, bytes_length)
+      error = ergo_lib_ergo_tree_template_bytes(self.pointer, bytes_ptr)
+      Util.check_error!(error)
+      bytes_ptr.read_array_of_uint8(bytes_length)
+    end
+
+    def constants_length
+      res = ergo_lib_ergo_tree_constants_len(self.pointer)
+      Util.check_error!(res[:error])
+      res[:value]
+    end
+
+    def get_constant(index)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      res = ergo_lib_ergo_tree_get_constant(self.pointer, index, pointer)
+      Util.check_error!(res[:error])
+      if res[:is_some]
+        Sigma::Constant.with_raw_pointer(pointer)
+      else
+        nil
+      end
+    end
+
+    def replace_constant(index:, constant:)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_ergo_tree_with_constant(self.pointer, index, constant.pointer, pointer)
+      Util.check_error!(error)
+
+      # Replace self.pointer with new ergo_tree pointer
+      # Old pointer will be deleted when out of scope by GC
+      self.class.init(pointer, obj: self)
+    end
+
+    def ==(ergo_tree_two)
+      ergo_lib_ergo_tree_eq(self.pointer, ergo_tree_two.pointer)
+    end
+
+    private
+
+    def self.init(unread_pointer, obj: nil)
+      obj ||= self.new
+      obj_ptr = unread_pointer.get_pointer(0)
+
+      obj.pointer = FFI::AutoPointer.new(
+        obj_ptr,
+        method(:ergo_lib_ergo_tree_delete)
+      )
+      obj
+    end
+
+
+  end
+end

data/lib/sigma/input.rb

@@ -0,0 +1,249 @@
+require 'ffi'
+require_relative './util.rb'
+require 'ffi-compiler/loader'
+
+module Sigma
+  class Input
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attr_accessor :pointer
+    attach_function :ergo_lib_input_delete, [:pointer], :void
+    attach_function :ergo_lib_input_box_id, [:pointer, :pointer], :void
+    attach_function :ergo_lib_input_spending_proof, [:pointer, :pointer], :void
+
+    def self.with_raw_pointer(pointer)
+      init(pointer)
+    end
+
+    def get_box_id
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_input_box_id(self.pointer, pointer)
+      Sigma::BoxId.with_raw_pointer(pointer)
+    end
+
+    def get_spending_proof
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_input_spending_proof(self.pointer, pointer)
+      Sigma::ProverResult.with_raw_pointer(pointer)
+    end
+
+    private
+
+    def self.init(unread_pointer)
+      obj = self.new
+      obj_ptr = unread_pointer.get_pointer(0)
+
+      obj.pointer = FFI::AutoPointer.new(
+        obj_ptr,
+        method(:ergo_lib_input_delete)
+      )
+      obj
+    end
+  end
+
+  class Inputs
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_inputs_new, [:pointer], :void
+    attach_function :ergo_lib_inputs_delete, [:pointer], :void
+    attach_function :ergo_lib_inputs_add, [:pointer, :pointer], :void
+    attach_function :ergo_lib_inputs_len, [:pointer], :uint8
+    attach_function :ergo_lib_inputs_get, [:pointer, :uint8, :pointer], ReturnOption.by_value
+
+    attr_accessor :pointer
+
+    def self.with_raw_pointer(unread_pointer)
+      init(unread_pointer)
+    end
+
+    def self.create
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_inputs_new(pointer)
+
+      init(pointer)
+    end
+
+    def len
+      ergo_lib_inputs_len(self.pointer)
+    end
+
+    def add(input)
+      ergo_lib_inputs_add(input.pointer, self.pointer)
+    end
+
+    def get(index)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      res = ergo_lib_inputs_get(self.pointer, index, pointer)
+      Util.check_error!(res[:error])
+      if res[:is_some]
+        Sigma::Input.with_raw_pointer(pointer)
+      else
+        nil
+      end
+    end
+
+    private
+
+    def self.init(unread_pointer)
+      obj = self.new
+      obj_ptr = unread_pointer.get_pointer(0)
+
+      obj.pointer = FFI::AutoPointer.new(
+        obj_ptr,
+        method(:ergo_lib_inputs_delete)
+      )
+      obj
+    end
+  end
+
+  class ProverResult
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_prover_result_delete, [:pointer], :void
+    attach_function :ergo_lib_prover_result_to_json, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_prover_result_context_extension, [:pointer, :pointer], :void
+    attach_function :ergo_lib_prover_result_proof, [:pointer, :pointer], :void
+    attach_function :ergo_lib_prover_result_proof_len, [:pointer], :uint
+    attr_accessor :pointer
+
+    def to_bytes
+      proof_len = ergo_lib_prover_result_proof_len(self.pointer)
+      b_ptr = FFI::MemoryPointer.new(:uint8, proof_len)
+      ergo_lib_prover_result_proof(self.pointer, b_ptr)
+      b_ptr.get_array_of_uint8(0, proof_len) 
+    end
+
+    def get_context_extension
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_prover_result_context_extension(self.pointer, pointer)
+      Sigma::ContextExtension.with_raw_pointer(pointer)
+    end
+
+    def to_json
+      s_ptr = FFI::MemoryPointer.new(:pointer, 1)
+      error = ergo_lib_prover_result_to_json(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
+
+    def self.with_raw_pointer(pointer)
+      init(pointer)
+    end
+
+    private
+
+    def self.init(unread_pointer)
+      obj = self.new
+      obj_ptr = unread_pointer.get_pointer(0)
+
+      obj.pointer = FFI::AutoPointer.new(
+        obj_ptr,
+        method(:ergo_lib_prover_result_delete)
+      )
+      obj
+    end
+
+  end
+
+  class UnsignedInput
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_unsigned_input_delete, [:pointer], :void
+    attach_function :ergo_lib_unsigned_input_box_id, [:pointer, :pointer], :void
+    attach_function :ergo_lib_unsigned_input_context_extension, [:pointer, :pointer], :void
+
+    attr_accessor :pointer
+    
+    def self.with_raw_pointer(pointer)
+      init(pointer)
+    end
+
+    def get_box_id
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_unsigned_input_box_id(self.pointer, pointer)
+      Sigma::BoxId.with_raw_pointer(pointer)
+    end
+
+    def get_context_extension
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_unsigned_input_context_extension(self.pointer, pointer)
+      Sigma::ContextExtension.with_raw_pointer(pointer)
+    end
+
+    private
+
+    def self.init(unread_pointer)
+      obj = self.new
+      obj_ptr = unread_pointer.get_pointer(0)
+
+      obj.pointer = FFI::AutoPointer.new(
+        obj_ptr,
+        method(:ergo_lib_unsigned_input_delete)
+      )
+      obj
+    end
+  end
+
+  class UnsignedInputs
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_unsigned_inputs_new, [:pointer], :void
+    attach_function :ergo_lib_unsigned_inputs_delete, [:pointer], :void
+    attach_function :ergo_lib_unsigned_inputs_add, [:pointer, :pointer], :void
+    attach_function :ergo_lib_unsigned_inputs_len, [:pointer], :uint8
+    attach_function :ergo_lib_unsigned_inputs_get, [:pointer, :uint8, :pointer], ReturnOption.by_value
+
+    attr_accessor :pointer
+
+    def self.with_raw_pointer(unread_pointer)
+      init(unread_pointer)
+    end
+
+    def self.create
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_unsigned_inputs_new(pointer)
+
+      init(pointer)
+    end
+
+    def len
+      ergo_lib_unsigned_inputs_len(self.pointer)
+    end
+
+    def add(unsigned_input)
+      ergo_lib_unsigned_inputs_add(unsigned_input.pointer, self.pointer)
+    end
+
+    def get(index)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      res = ergo_lib_unsigned_inputs_get(self.pointer, index, pointer)
+      Util.check_error!(res[:error])
+      if res[:is_some]
+        Sigma::UnsignedInput.with_raw_pointer(pointer)
+      else
+        nil
+      end
+    end
+
+    private
+
+    def self.init(unread_pointer)
+      obj = self.new
+      obj_ptr = unread_pointer.get_pointer(0)
+
+      obj.pointer = FFI::AutoPointer.new(
+        obj_ptr,
+        method(:ergo_lib_unsigned_inputs_delete)
+      )
+      obj
+    end
+  end
+end

data/lib/sigma/merkle_proof.rb

@@ -0,0 +1,79 @@
+require 'ffi'
+require_relative './util.rb'
+require 'ffi-compiler/loader'
+
+module Sigma
+  class MerkleProof
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_merkle_proof_delete, [:pointer], :void
+    attach_function :ergo_merkle_proof_new, [:pointer, :uint, :pointer], :error_pointer
+    attach_function :ergo_merkle_proof_from_json, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_merkle_proof_add_node, [:pointer, :pointer, :uint, NODE_SIDE_ENUM], :error_pointer
+    attach_function :ergo_merkle_proof_valid, [:pointer, :pointer, :uint], :bool
+    attach_function :ergo_merkle_proof_valid_base16, [:pointer, :pointer, :pointer], :error_pointer
+    attr_accessor :pointer
+
+    # leaf_data is an Array(Uint8)
+    def self.create(leaf_data)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      b_ptr = FFI::MemoryPointer.new(:uint8, leaf_data.size)
+      b_ptr.write_array_of_uint8(leaf_data)
+      error = ergo_merkle_proof_new(b_ptr, leaf_data.size, pointer)
+      Util.check_error!(error)
+      init(pointer)
+    end
+
+    def self.with_json(json)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_merkle_proof_from_json(json, pointer)
+      init(pointer)
+    end
+
+    def add_node(hash:, side:)
+      b_ptr = FFI::MemoryPointer.new(:uint8, hash.size)
+      b_ptr.write_array_of_uint8(hash)
+      error = ergo_merkle_proof_add_node(self.pointer, b_ptr, hash.size, side)
+      Util.check_error!(error)
+    end
+
+    # Hash can be an Array(Uint8) or String
+    def valid(hash)
+      if hash.is_a?(Array)
+        valid_with_array(hash)
+      elsif hash.is_a?(String)
+        valid_with_string(hash)
+      else
+        raise 'Invalid type for hash: #{hash.class}. It must be an Array(Uint8) or String'
+      end
+    end
+
+    private def valid_with_array(hash)
+      b_ptr = FFI::MemoryPointer.new(:uint8, hash.size)
+      b_ptr.write_array_of_uint8(hash)
+      ergo_merkle_proof_valid(self.pointer, b_ptr, b_ptr.size)
+    end
+
+    private def valid_with_string(hash)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_merkle_proof_valid_base16(self.pointer, hash, pointer)
+      Util.check_error!(error)
+      pointer.get_pointer(0)
+    end
+
+
+    private
+
+    def self.init(unread_pointer)
+      obj = self.new
+      obj_ptr = unread_pointer.get_pointer(0)
+
+      obj.pointer = FFI::AutoPointer.new(
+        obj_ptr,
+        method(:ergo_merkle_proof_delete)
+      )
+      obj 
+    end
+  end
+end

data/lib/sigma/nipopow.rb

@@ -0,0 +1,155 @@
+require 'ffi'
+require_relative './util.rb'
+require 'ffi-compiler/loader'
+
+module Sigma
+  class NipopowProof
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_nipopow_proof_delete, [:pointer], :void
+    attach_function :ergo_lib_nipopow_proof_from_json, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_nipopow_proof_to_json, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_nipopow_proof_is_better_than, [:pointer, :pointer], ReturnBool.by_value
+
+    attr_accessor :pointer
+
+    def self.with_json(json)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_nipopow_proof_from_json(json, pointer)
+      Util.check_error!(error)
+      init(pointer)
+    end
+
+    def is_better_than(other_proof)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      res = ergo_lib_nipopow_proof_is_better_than(self.pointer, other_proof.pointer)
+      Util.check_error!(res[:error])
+      res[:value]
+    end
+
+    def to_json
+      s_ptr = FFI::MemoryPointer.new(:pointer, 1)
+      error = ergo_lib_nipopow_proof_to_json(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
+
+    private
+
+    def self.init(unread_pointer)
+      obj = self.new
+      obj_ptr = unread_pointer.get_pointer(0)
+
+      obj.pointer = FFI::AutoPointer.new(
+        obj_ptr,
+        method(:ergo_lib_nipopow_proof_delete)
+      )
+      obj 
+    end
+  end
+  
+  class NipopowVerifier
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_nipopow_verifier_delete, [:pointer], :void
+    attach_function :ergo_lib_nipopow_verifier_new, [:pointer,:pointer], :void
+    attach_function :ergo_lib_nipopow_verifier_best_chain, [:pointer,:pointer], :void
+    attach_function :ergo_lib_nipopow_verifier_process, [:pointer,:pointer], :error_pointer
+    attr_accessor :pointer
+
+    def self.create(genesis_block_id)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_nipopow_verifier_new(genesis_block_id.pointer, pointer)
+      init(pointer)
+    end
+
+    def best_chain
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_nipopow_verifier_best_chain(self.pointer, pointer)
+      BlockHeaders.with_raw_pointer(pointer)
+    end
+
+    def process(proof)
+      error = ergo_lib_nipopow_verifier_process(self.pointer, proof.pointer)
+      Util.check_error!(error)
+    end
+
+    private
+
+    def self.init(unread_pointer)
+      obj = self.new
+      obj_ptr = unread_pointer.get_pointer(0)
+
+      obj.pointer = FFI::AutoPointer.new(
+        obj_ptr,
+        method(:ergo_lib_nipopow_verifier_delete)
+      )
+      obj 
+    end
+  end
+
+  class PoPowHeader
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_popow_header_delete, [:pointer], :void
+    attach_function :ergo_lib_popow_header_from_json, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_popow_header_get_header, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_popow_header_get_interlinks, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_po_pow_header_eq, [:pointer, :pointer], :bool
+    attr_accessor :pointer
+
+    def self.with_json(json)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_popow_header_from_json(json, pointer)
+      Util.check_error!(error)
+      init(pointer)
+    end
+
+    def to_json
+      s_ptr = FFI::MemoryPointer.new(:pointer, 1)
+      error = ergo_lib_popow_header_to_json(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
+
+    def get_header
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_popow_header_get_header(self.pointer, pointer)
+      Util.check_error!(error)
+      BlockHeader.with_raw_pointer(pointer)
+    end
+
+    def get_interlinks
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_popow_header_get_interlinks(self.pointer, pointer)
+      Util.check_error!(error)
+      BlockIds.with_raw_pointer(pointer)
+    end
+
+    def ==(other_header)
+      ergo_lib_po_pow_header_eq(self.pointer, other_header.pointer)
+    end
+
+    private
+
+    def self.init(unread_pointer)
+      obj = self.new
+      obj_ptr = unread_pointer.get_pointer(0)
+
+      obj.pointer = FFI::AutoPointer.new(
+        obj_ptr,
+        method(:ergo_lib_popow_header_delete)
+      )
+      obj 
+    end
+  end
+end

data/lib/sigma/pre_header.rb

@@ -0,0 +1,38 @@
+require 'ffi'
+require_relative './util.rb'
+require 'ffi-compiler/loader'
+
+module Sigma
+  class PreHeader
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_preheader_delete, [:pointer], :void
+    attach_function :ergo_lib_preheader_from_block_header, [:pointer, :pointer], :void
+    attach_function :ergo_lib_pre_header_eq, [:pointer, :pointer], :bool
+    attr_accessor :pointer
+
+    def self.with_block_header(block_header)
+      pointer = FFI::MemoryPointer.new(:pointer) 
+      ergo_lib_preheader_from_block_header(block_header.pointer, pointer)
+      init(pointer) 
+    end
+
+    def ==(ph_two)
+      ergo_lib_pre_header_eq(self.pointer, ph_two.pointer)
+    end
+
+    private
+
+    def self.init(unread_pointer)
+      obj = self.new
+      obj_ptr = unread_pointer.get_pointer(0)
+
+      obj.pointer = FFI::AutoPointer.new(
+        obj_ptr,
+        method(:ergo_lib_preheader_delete)
+      )
+      obj
+    end
+  end
+end