sigma_rb 0.1.3

data/lib/sigma/reduced_transaction.rb

@@ -0,0 +1,88 @@
+require 'ffi'
+require_relative './util.rb'
+require 'ffi-compiler/loader'
+
+module Sigma
+  class ReducedTransaction
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_reduced_tx_delete, [:pointer], :void
+    attach_function :ergo_lib_reduced_tx_from_unsigned_tx, [:pointer, :pointer, :pointer, :pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_reduced_tx_unsigned_tx, [:pointer, :pointer], :void
+    attr_accessor :pointer
+
+    def self.from_unsigned_tx(unsigned_tx:, boxes_to_spend:, data_boxes:, state_context:)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_reduced_tx_from_unsigned_tx(
+          unsigned_tx.pointer,
+          boxes_to_spend.pointer,
+          data_boxes.pointer,
+          state_context.pointer,
+          pointer
+        )
+      Util.check_error!(error)
+      init(pointer)
+    end
+
+    def self.with_raw_pointer(pointer)
+      init(pointer)
+    end
+
+    def get_unsigned_transaction
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_reduced_tx_unsigned_tx(self.pointer, pointer)
+      UnsignedTransaction.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_reduced_tx_delete)
+      )
+      obj 
+    end
+  end
+
+  class Propositions
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_propositions_delete, [:pointer], :void
+    attach_function :ergo_lib_propositions_new, [:pointer], :void
+    attach_function :ergo_lib_propositions_add_proposition_from_bytes, [:pointer, :pointer, :uint], :error_pointer
+    attr_accessor :pointer
+
+    def self.create
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_propositions_new(pointer)
+      init(pointer)
+    end
+
+    def add_proposition(bytes)
+      b_ptr = FFI::MemoryPointer.new(:uint8, bytes.size)
+      b_ptr.write_array_of_uint8(bytes)
+      error = ergo_lib_propositions_add_proposition_from_bytes(self.pointer, b_ptr, bytes.size)
+      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_propositions_delete)
+      )
+      obj 
+    end
+  end
+end
+

data/lib/sigma/secret_key.rb

@@ -0,0 +1,119 @@
+require 'ffi'
+require_relative './util.rb'
+require 'ffi-compiler/loader'
+
+module Sigma
+  class SecretKey
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_secret_key_delete, [:pointer], :void
+    attach_function :ergo_lib_secret_key_generate_random, [:pointer], :void
+    attach_function :ergo_lib_secret_key_from_bytes, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_secret_key_get_address, [:pointer, :pointer], :void
+    attach_function :ergo_lib_secret_key_to_bytes, [:pointer, :pointer], :void
+
+    attr_accessor :pointer
+
+    def self.create
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_secret_key_generate_random(pointer)
+      init(pointer)
+    end
+
+    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_secret_key_from_bytes(b_ptr, pointer)
+      Util.check_error!(error)
+      init(pointer)
+    end
+
+    def self.with_raw_pointer(pointer)
+      init(pointer)
+    end
+
+    def get_address
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_secret_key_get_address(self.pointer, pointer)
+      Sigma::Address.with_raw_pointer(pointer)
+    end
+
+    def to_bytes
+      bytes_len = 32
+      b_ptr = FFI::MemoryPointer.new(:uint8, bytes_len) 
+      ergo_lib_secret_key_to_bytes(self.pointer, b_ptr)
+      b_ptr.get_array_of_uint8(0, bytes_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_secret_key_delete)
+      )
+      obj
+    end
+  end
+
+  class SecretKeys
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_secret_keys_new, [:pointer], :void
+    attach_function :ergo_lib_secret_keys_delete, [:pointer], :void
+    attach_function :ergo_lib_secret_keys_add, [:pointer, :pointer], :void
+    attach_function :ergo_lib_secret_keys_len, [:pointer], :uint8
+    attach_function :ergo_lib_secret_keys_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_secret_keys_new(pointer)
+
+      init(pointer)
+    end
+
+    def len
+      ergo_lib_secret_keys_len(self.pointer)
+    end
+
+    def add(secret_key)
+      ergo_lib_secret_keys_add(secret_key.pointer, self.pointer)
+    end
+
+    def get(index)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      res = ergo_lib_secret_keys_get(self.pointer, index, pointer)
+      Util.check_error!(res[:error])
+      if res[:is_some]
+        Sigma::SecretKey.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_secret_keys_delete)
+      )
+      obj
+    end
+  end
+end

data/lib/sigma/structs.rb

@@ -0,0 +1,31 @@
+require 'ffi'
+
+module Sigma
+  extend FFI::Library
+  typedef :pointer, :error_pointer
+
+  class ReturnOption < FFI::Struct
+    layout :is_some, :bool,
+           :error, :error_pointer
+  end
+
+  class ReturnNumUsize < FFI::Struct
+    layout :value, :uint,
+           :error, :error_pointer
+  end
+
+  class ReturnNumI32 < FFI::Struct
+    layout :value, :int32,
+           :error, :error_pointer
+  end
+
+  class ReturnNumI64 < FFI::Struct
+    layout :value, :int64,
+           :error, :error_pointer
+  end
+
+  class ReturnBool < FFI::Struct
+    layout :value, :bool,
+           :error, :error_pointer
+  end
+end

data/lib/sigma/token.rb

@@ -0,0 +1,225 @@
+require 'ffi'
+require_relative './util.rb'
+require 'ffi-compiler/loader'
+
+module Sigma
+  class TokenAmount
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_token_amount_delete, [:pointer], :void
+    attach_function :ergo_lib_token_amount_from_i64, [:int64, :pointer], :error_pointer
+    attach_function :ergo_lib_token_amount_as_i64, [:pointer], :int64
+    attach_function :ergo_lib_token_amount_eq, [:pointer, :pointer], :bool
+    attr_accessor :pointer
+
+    def self.with_raw_pointer(unread_pointer)
+      init(unread_pointer)
+    end
+
+    def self.with_i64(int)
+      ptr = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_token_amount_from_i64(int, ptr)
+      Util.check_error!(error)
+
+      init(ptr)
+    end
+
+    def to_i
+      ergo_lib_token_amount_as_i64(self.pointer)
+    end
+
+    def ==(token_amount_two)
+      ergo_lib_token_amount_eq(self.pointer, token_amount_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_token_amount_delete)
+      )
+      obj 
+    end
+  end
+
+  class TokenId
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_token_id_from_box_id, [:pointer, :pointer], :void
+    attach_function :ergo_lib_token_id_from_str, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_token_id_delete, [:pointer], :void
+    attach_function :ergo_lib_token_id_eq, [:pointer, :pointer], :bool
+    attach_function :ergo_lib_token_id_to_str, [:pointer, :pointer], :void
+    attr_accessor :pointer
+
+    def self.with_raw_pointer(tid_pointer)
+      init(tid_pointer)
+    end
+
+    def self.with_box_id(box_id)
+      tid_ptr = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_token_id_from_box_id(box_id.pointer, tid_ptr)
+
+      init(tid_ptr)
+    end
+
+    def self.from_base16_encoded_string(str)
+      tid_ptr = FFI::MemoryPointer.new(:pointer)
+      error = ergo_lib_token_id_from_str(str, tid_ptr)
+      Util.check_error!(error)
+
+      init(tid_ptr)
+    end
+
+    def to_base16_encoded_string
+      s_ptr = FFI::MemoryPointer.new(:pointer, 1)
+      ergo_lib_token_id_to_str(self.pointer, 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 ==(token_id_two)
+      ergo_lib_token_id_eq(self.pointer, token_id_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_token_id_delete)
+      )
+      obj 
+    end
+  end
+
+  class Token
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_token_new, [:pointer, :pointer, :pointer], :void
+    attach_function :ergo_lib_token_get_id, [:pointer, :pointer], :void
+    attach_function :ergo_lib_token_get_amount, [:pointer, :pointer], :void
+    attach_function :ergo_lib_token_delete, [:pointer], :void
+    attach_function :ergo_lib_token_to_json_eip12, [:pointer, :pointer], :error_pointer
+    attach_function :ergo_lib_token_eq, [:pointer, :pointer], :bool
+    attr_accessor :pointer
+
+    def self.create(token_id:, token_amount:)
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_token_new(token_id.pointer, token_amount.pointer, pointer)
+
+      init(pointer)
+    end
+
+    def self.with_raw_pointer(pointer)
+      init(pointer)
+    end
+
+    def get_id
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_token_get_id(self.pointer, pointer)
+      Sigma::TokenId.with_raw_pointer(pointer)
+    end
+
+    def get_amount
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_token_get_amount(self.pointer, pointer)
+      Sigma::TokenAmount.with_raw_pointer(pointer)
+    end
+
+    def to_json_eip12
+      s_ptr = FFI::MemoryPointer.new(:pointer, 1)
+      error = ergo_lib_token_to_json_eip12(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 ==(token_two)
+      ergo_lib_token_eq(self.pointer, token_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_token_delete)
+      )
+      obj
+    end
+  end
+
+  class Tokens
+    extend FFI::Library
+    ffi_lib FFI::Compiler::Loader.find('csigma')
+    typedef :pointer, :error_pointer
+    attach_function :ergo_lib_tokens_delete, [:pointer], :void
+    attach_function :ergo_lib_tokens_new, [:pointer], :void
+    attach_function :ergo_lib_tokens_len, [:pointer], :uint8
+    attach_function :ergo_lib_tokens_get, [:pointer, :uint8, :pointer], ReturnOption.by_value
+    attach_function :ergo_lib_tokens_add, [:pointer, :pointer], :error_pointer
+    attr_accessor :pointer
+
+    def self.create
+      pointer = FFI::MemoryPointer.new(:pointer)
+      ergo_lib_tokens_new(pointer)
+      init(pointer)
+    end
+
+    def self.with_raw_pointer(tokens_ptr)
+      init(tokens_ptr)
+    end
+
+    def len
+      ergo_lib_tokens_len(self.pointer)
+    end
+
+    def get(index)
+      token_pointer = FFI::MemoryPointer.new(:pointer)
+      res = ergo_lib_tokens_get(self.pointer, index, token_pointer)
+      Util.check_error!(res[:error])
+      if res[:is_some]
+        Sigma::Token.with_raw_pointer(token_pointer)
+      else
+        nil
+      end
+    end
+
+    def add(token)
+      error = ergo_lib_tokens_add(token.pointer, self.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_tokens_delete)
+      )
+      obj
+    end
+  end
+end
+