sigma_rb 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2da1237215d9dd9b9734403cb13606b66cd3e80ea128a1d301180aec84720739
+  data.tar.gz: 8e7d5e940c16718d66fbfaaa3ac71c751ae107d925783e25ec163781acc2e06e
+SHA512:
+  metadata.gz: 2111272de78b3807f966f984d1986c904e6f34543c06365bfddee20a8a9269d91cad6fd8b8147e9148ffcc500105f35fdf73bd100c69cf43151910622fcb14fb
+  data.tar.gz: 1a0d61d66d6d706b05c9e2c81142bbe28e90f0584d4d555b16e08218286f05d20eee572e0ff158b134918a202bd7556d1aa45875290d71dbae2a1d09e96dd78c

data/LICENSE

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

data/README.md

@@ -0,0 +1,9 @@
+# sigma_rb
+Ruby bindings for https://github.com/ergoplatform/sigma-rust
+
+
+### 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/

data/ext/Rakefile

@@ -0,0 +1,7 @@
+require 'ffi-compiler/compile_task'
+
+FFI::Compiler::CompileTask.new('csigma') do |c|
+  c.have_header?('ergo_lib.h')
+  c.have_library?('ergo')
+  c.ldflags << "-Wl,--whole-archive,-lergo,--no-whole-archive"
+end

data/ext/csigma.c

@@ -0,0 +1,5 @@
+#include "ergo_lib.h"
+
+int main(void) {
+}
+

data/lib/sigma/address.rb

@@ -0,0 +1,73 @@
+require 'ffi'
+require_relative './util.rb'
+require 'ffi-compiler/loader'
+
+module Sigma
+  class Address
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_address_from_testnet, [:pointer,:pointer], :error_pointer
+    attach_function :ergo_lib_address_from_mainnet, [:pointer,:pointer], :error_pointer
+    attach_function :ergo_lib_address_from_base58, [:pointer,:pointer], :error_pointer
+    attach_function :ergo_lib_address_to_base58, [:pointer, Sigma::NETWORK_PREFIX_ENUM, :pointer], :void
+    attach_function :ergo_lib_address_delete, [:pointer], :void
+    attach_function :ergo_lib_address_type_prefix, [:pointer], :uint8
+    attr_accessor :pointer
+
+    def self.with_raw_pointer(unread_pointer)
+      init(unread_pointer)
+    end
+
+    def self.with_testnet_address(address_str)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_address_from_testnet(address_str, pointer)
+      Util.check_error!(error)
+
+      init(pointer)
+    end
+
+    def self.with_mainnet_address(address_str)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_address_from_mainnet(address_str, pointer)
+      Util.check_error!(error)
+
+      init(pointer)
+    end
+
+    def self.with_base58_address(address_str)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_address_from_base58(address_str, pointer)
+      Util.check_error!(error)
+
+      init(pointer)
+    end
+
+    def to_base58(network_prefix)
+      s_ptr = FFI::MemoryPointer.new(:pointer, 1)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_address_to_base58(self.pointer, network_prefix, s_ptr)
+      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 type_prefix
+      ergo_lib_address_type_prefix(self.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_address_delete)
+      )
+      obj 
+    end
+  end
+end

data/lib/sigma/block_header.rb

@@ -0,0 +1,197 @@
+require 'ffi'
+require_relative './util.rb'
+require 'ffi-compiler/loader'
+
+module Sigma
+  class BlockHeader
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_block_header_delete, [:pointer], :void
+    attach_function :ergo_lib_block_header_from_json, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_block_header_eq, [:pointer, :pointer], :bool
+    attr_accessor :pointer
+
+    def self.with_json(json)
+      pointer = FFI::MemoryPointer.new(:pointer) 
+      error = ergo_lib_block_header_from_json(json, pointer)
+      Util.check_error!(error)
+      init(pointer)
+    end
+
+    def self.with_raw_pointer(pointer)
+      init(pointer)
+    end
+
+    def get_block_id
+      pointer = FFI::MemoryPointer.new(:pointer) 
+      ergo_lib_block_header_id(self.pointer, pointer)
+      Sigma::BlockId.with_raw_pointer(:pointer)
+    end
+
+    def ==(bh_two)
+      ergo_lib_block_header_eq(self.pointer, bh_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_block_header_delete)
+      )
+      obj
+    end
+  end
+
+  class BlockHeaders
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_block_headers_new, [:pointer], :void
+    attach_function :ergo_lib_block_headers_delete, [:pointer], :void
+    attach_function :ergo_lib_block_headers_add, [:pointer, :pointer], :void
+    attach_function :ergo_lib_block_headers_len, [:pointer], :uint8
+    attach_function :ergo_lib_block_headers_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_block_headers_new(pointer)
+
+      init(pointer)
+    end
+
+    # Parameter is an ARRAY of JSON Strings
+    def self.from_json(array_of_json_elements)
+      headers = array_of_json_elements.map do |json|
+        Sigma::BlockHeader.with_json(json)
+      end
+      container = create
+      headers.each do |header|
+        container.add(header)
+      end
+      container
+    end
+
+    def len
+      ergo_lib_block_headers_len(self.pointer)
+    end
+
+    def add(block_header)
+      ergo_lib_block_headers_add(block_header.pointer, self.pointer)
+    end
+
+    def get(index)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      res = ergo_lib_block_headers_get(self.pointer, index, pointer)
+      Util.check_error!(res[:error])
+      if res[:is_some]
+        Sigma::BlockHeader.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_block_headers_delete)
+      )
+      obj
+    end
+  end
+
+  class BlockId
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_block_id_delete, [:pointer], :void
+    attr_accessor :pointer
+
+    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_block_id_delete)
+      )
+      obj
+    end
+  end
+
+  class BlockIds
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_block_ids_new, [:pointer], :void
+    attach_function :ergo_lib_block_ids_delete, [:pointer], :void
+    attach_function :ergo_lib_block_ids_add, [:pointer, :pointer], :void
+    attach_function :ergo_lib_block_ids_len, [:pointer], :uint8
+    attach_function :ergo_lib_block_ids_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_block_ids_new(pointer)
+
+      init(pointer)
+    end
+
+    def len
+      ergo_lib_block_ids_len(self.pointer)
+    end
+
+    def add(block_id)
+      ergo_lib_block_ids_add(block_id.pointer, self.pointer)
+    end
+
+    def get(index)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      res = ergo_lib_block_ids_get(self.pointer, index, pointer)
+      Util.check_error!(res[:error])
+      if res[:is_some]
+        Sigma::BlockId.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_block_ids_delete)
+      )
+      obj
+    end
+  end
+end
+

data/lib/sigma/box_selection.rb

@@ -0,0 +1,105 @@
+require 'ffi'
+require_relative './util.rb'
+require 'ffi-compiler/loader'
+
+module Sigma
+  class BoxSelection
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_box_selection_delete, [:pointer], :void
+    attach_function :ergo_lib_box_selection_eq, [:pointer, :pointer], :bool
+    attach_function :ergo_lib_box_selection_new, [:pointer, :pointer, :pointer], :void
+    attach_function :ergo_lib_box_selection_boxes, [:pointer, :pointer], :void
+    attach_function :ergo_lib_box_selection_change, [:pointer, :pointer], :void
+
+    attr_accessor :pointer
+
+    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
+
+    def self.with_raw_pointer(pointer)
+      init(pointer)
+    end
+
+    def get_boxes
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_box_selection_boxes(self.pointer, pointer)
+      Sigma::ErgoBoxes.with_raw_pointer(pointer)
+    end
+
+    def get_change_boxes
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_box_selection_change(self.pointer, pointer)
+      Sigma::ErgoBoxAssetsDataList.with_raw_pointer(pointer)
+    end
+
+    def ==(bs_two)
+      ergo_lib_box_selection_eq(self.pointer, bs_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_box_selection_delete)
+      )
+      obj 
+    end
+  end
+
+  class SimpleBoxSelector
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_simple_box_selector_delete, [:pointer], :void
+    attach_function :ergo_lib_simple_box_selector_new, [:pointer], :void
+    attach_function :ergo_lib_simple_box_selector_select, [:pointer, :pointer, :pointer, :pointer, :pointer], :error_pointer
+
+    attr_accessor :pointer
+
+    def self.create
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_simple_box_selector_new(pointer)
+      init(pointer)
+    end
+
+    def select(inputs:, target_balance:, target_tokens:)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_simple_box_selector_select(
+        self.pointer,
+        inputs.pointer,
+        target_balance.pointer,
+        target_tokens.pointer,
+        pointer
+      )
+      Util.check_error!(error)
+      Sigma::BoxSelection.with_raw_pointer(pointer)
+    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_simple_box_selector_delete)
+      )
+      obj 
+    end
+  end
+end
+

data/lib/sigma/byte_array.rb

@@ -0,0 +1,96 @@
+require 'ffi'
+require_relative './util.rb'
+require 'ffi-compiler/loader'
+
+module Sigma
+  class ByteArray
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_byte_array_delete, [:pointer], :void
+    attach_function :ergo_lib_byte_array_from_raw_parts, [:pointer, :uint, :pointer], :error_pointer
+    attr_accessor :pointer
+
+    def self.from_bytes(bytes)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      b_ptr = FFI::MemoryPointer.new(:uint8, bytes.size)
+      b_ptr.write_array_of_uint8(bytes)
+      error = ergo_lib_byte_array_from_raw_parts(b_ptr, bytes.size, pointer)
+      Util.check_error!(error)
+      init(pointer)
+    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_byte_array_delete)
+      )
+      obj
+    end
+  end
+
+  class ByteArrays
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_byte_arrays_new, [:pointer], :void
+    attach_function :ergo_lib_byte_arrays_delete, [:pointer], :void
+    attach_function :ergo_lib_byte_arrays_add, [:pointer, :pointer], :void
+    attach_function :ergo_lib_byte_arrays_len, [:pointer], :uint8
+    attach_function :ergo_lib_byte_arrays_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_byte_arrays_new(pointer)
+
+      init(pointer)
+    end
+
+    def len
+      ergo_lib_byte_arrays_len(self.pointer)
+    end
+
+    def add(byte_array)
+      ergo_lib_byte_arrays_add(byte_array.pointer, self.pointer)
+    end
+
+    def get(index)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      res = ergo_lib_byte_arrays_get(self.pointer, index, pointer)
+      Util.check_error!(res[:error])
+      if res[:is_some]
+        Sigma::ByteArray.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_byte_arrays_delete)
+      )
+      obj
+    end
+  end
+end
+

data/lib/sigma/constant.rb

@@ -0,0 +1,117 @@
+require 'ffi'
+require_relative './util.rb'
+require 'ffi-compiler/loader'
+
+module Sigma
+  class Constant
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_constant_eq, [:pointer, :pointer], :bool
+    attach_function :ergo_lib_constant_from_base16, [:string, :pointer], :error_pointer
+    attach_function :ergo_lib_constant_from_i32, [:int32, :pointer], :error_pointer
+    attach_function :ergo_lib_constant_to_i32, [:pointer], ReturnNumI32.by_value
+    attach_function :ergo_lib_constant_from_i64, [:int64, :pointer], :error_pointer
+    attach_function :ergo_lib_constant_to_i64, [:pointer], ReturnNumI64.by_value
+    attach_function :ergo_lib_constant_to_base16, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_constant_from_bytes, [:pointer, :uint, :pointer], :error_pointer
+    attach_function :ergo_lib_constant_from_ecpoint_bytes, [:pointer, :uint, :pointer], :error_pointer
+    attach_function :ergo_lib_constant_from_ergo_box, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_constant_delete, [:pointer], :void
+    attr_accessor :pointer
+
+    def self.with_ergo_box(ergo_box)
+      c_ptr = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_constant_from_ergo_box(ergo_box.pointer, c_ptr)
+      
+      init(c_ptr)
+    end
+
+    def self.with_bytes(bytes)
+      c_ptr = FFI::MemoryPointer.new(:pointer)
+      b_ptr = FFI::MemoryPointer.new(:uint8, bytes.size)
+      b_ptr.write_array_of_uint8(bytes)
+      error = ergo_lib_constant_from_bytes(b_ptr, bytes.size, c_ptr)
+      Util.check_error!(error)
+
+      init(c_ptr)
+    end
+
+    def self.with_ecpoint_bytes(bytes)
+      c_ptr = FFI::MemoryPointer.new(:pointer)
+      b_ptr = FFI::MemoryPointer.new(:uint8, bytes.size)
+      b_ptr.write_array_of_uint8(bytes)
+      error = ergo_lib_constant_from_ecpoint_bytes(b_ptr, bytes.size, c_ptr)
+      Util.check_error!(error)
+
+      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
+
+    def self.with_i32(int)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_constant_from_i32(int, pointer)
+      # TODO: This raises error even with valid output
+      #Util.check_error!(error)
+      init(pointer)
+    end
+
+    def self.with_i64(int)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_constant_from_i64(int, pointer)
+      # TODO: This raises error even with valid output
+      #Util.check_error!(error)
+      init(pointer)
+    end
+
+    def self.with_base_16(str)
+      c_ptr = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_constant_from_base16(str, c_ptr)
+      Util.check_error!(error)
+
+      init(c_ptr)
+    end
+
+    def to_i32
+      res = ergo_lib_constant_to_i32(self.pointer)
+      Util.check_error!(res[:error])
+      res[:value]
+    end
+
+    def to_i64
+      res = ergo_lib_constant_to_i64(self.pointer)
+      Util.check_error!(res[:error])
+      res[:value]
+    end
+
+    def ==(constant_two)
+      ergo_lib_constant_eq(self.pointer, constant_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_constant_delete)
+      )
+      obj 
+    end
+  end
+end

data/lib/sigma/context_extension.rb

@@ -0,0 +1,47 @@
+require 'ffi'
+require_relative './util.rb'
+require 'ffi-compiler/loader'
+
+module Sigma
+  class ContextExtension
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_context_extension_delete, [:pointer], :void
+    attach_function :ergo_lib_context_extension_empty, [:pointer], :void
+    attach_function :ergo_lib_context_extension_len, [:pointer], :uint
+    attach_function :ergo_lib_context_extension_keys, [:pointer, :pointer], :void
+    attr_accessor :pointer
+
+    def self.create
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_context_extension_empty(pointer)
+      init(pointer) 
+    end
+
+    def self.with_raw_pointer(pointer)
+      init(pointer)
+    end
+
+    def get_keys
+      ce_len = ergo_lib_context_extension_len(self.pointer)
+      b_ptr = FFI::MemoryPointer.new(:uint8, ce_len)
+      ergo_lib_context_extension_keys(self.pointer, b_ptr)
+      b_ptr.get_array_of_uint8(0, ce_len) 
+    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_context_extension_delete)
+      )
+      obj 
+    end
+  end
+end
+