crea-ruby 0.0.1

data/lib/crea/chain_config.rb

@@ -0,0 +1,36 @@
+module Crea
+  module ChainConfig
+    EXPIRE_IN_SECS = 600
+    EXPIRE_IN_SECS_PROPOSAL = 24 * 60 * 60
+    
+    NETWORKS_CREA_CHAIN_ID = '0000000000000000000000000000000000000000000000000000000000000000'
+    NETWORKS_CREA_ADDRESS_PREFIX = 'CREA'
+    NETWORKS_CREA_CORE_ASSET = ["0", 3, "@@000000021"] # CREA
+    NETWORKS_CREA_DEBT_ASSET = ["0", 3, "@@000000013"] # CBD
+    NETWORKS_CREA_VEST_ASSET = ["0", 6, "@@000000037"] # VESTS
+    NETWORKS_CREA_DEFAULT_NODE = 'https://node1.creary.net' # √
+    # NETWORKS_CREA_DEFAULT_NODE = 'https://api.crearystage.com' # √
+    # NETWORKS_CREA_DEFAULT_NODE = 'https://api.crearydev.com' # √
+    # NETWORKS_CREA_DEFAULT_NODE = 'https://appbasetest.timcliff.com'
+    # NETWORKS_CREA_DEFAULT_NODE = 'https://gtg.crea.house:8090'
+    # NETWORKS_CREA_DEFAULT_NODE = 'https://api.crea.house' # √?
+    # NETWORKS_CREA_DEFAULT_NODE = 'https://seed.bitcoiner.me'
+    # NETWORKS_CREA_DEFAULT_NODE = 'https://cread.minnowsupportproject.org'
+    # NETWORKS_CREA_DEFAULT_NODE = 'https://cread.privex.io'
+    # NETWORKS_CREA_DEFAULT_NODE = 'https://rpc.crealiberator.com'
+    # NETWORKS_CREA_DEFAULT_NODE = 'https://rpc.curiecrea.com'
+    # NETWORKS_CREA_DEFAULT_NODE = 'https://rpc.buildteam.io'
+    # NETWORKS_CREA_DEFAULT_NODE = 'https://cread.pevo.science'
+    # NETWORKS_CREA_DEFAULT_NODE = 'https://rpc.creaviz.com'
+    # NETWORKS_CREA_DEFAULT_NODE = 'https://cread.creagigs.org'
+    
+    NETWORKS_TEST_CHAIN_ID = '46d82ab7d8db682eb1959aed0ada039a6d49afa1602491f93dde9cac3e8e6c32'
+    NETWORKS_TEST_ADDRESS_PREFIX = 'TST'
+    NETWORKS_TEST_CORE_ASSET = ["0", 3, "@@000000021"] # TESTS
+    NETWORKS_TEST_DEBT_ASSET = ["0", 3, "@@000000013"] # TBD
+    NETWORKS_TEST_VEST_ASSET = ["0", 6, "@@000000037"] # VESTS
+    NETWORKS_TEST_DEFAULT_NODE = 'https://testnet.crearydev.com'
+    
+    NETWORK_CHAIN_IDS = [NETWORKS_CREA_CHAIN_ID, NETWORKS_TEST_CHAIN_ID]
+  end
+end

data/lib/crea/formatter.rb

@@ -0,0 +1,14 @@
+module Crea
+  class Formatter
+    def self.reputation(raw)
+      raw = raw.to_i
+      neg = raw < 0
+      level = Math.log10(raw.abs)
+      level = [level - 9, 0].max
+      level = (neg ? -1 : 1) * level
+      level = (level * 9) + 25
+      
+      level.round(1)
+    end
+  end
+end

data/lib/crea/jsonrpc.rb

@@ -0,0 +1,108 @@
+module Crea
+  # {Jsonrpc} allows you to inspect the available methods offered by a node.
+  # If a node runs a plugin you want, then all of the API methods it can exposes
+  # will automatically be available.  This API is used internally to determine
+  # which APIs and methods are available on the node you specify.
+  #
+  # In theory, if a new plugin is created and enabled by the node, it will be
+  # available by this library without needing an update to its code.
+  class Jsonrpc < Api
+    API_METHODS = %i(get_signature get_methods)
+    
+    def self.api_methods
+      @api_methods ||= {}
+    end
+    
+    # Might help diagnose a cluster that has asymmetric plugin definitions.
+    def self.reset_api_methods
+      @api_methods = nil
+    end
+    
+    def initialize(options = {})
+      @api_name = self.class.api_name = :jsonrpc
+      @methods = API_METHODS
+      super
+    end
+    
+    def get_api_methods(&block)
+      api_methods = self.class.api_methods[@rpc_client.uri.to_s]
+      
+      if api_methods.nil?
+        get_methods do |result, error, rpc_id|
+          raise NotAppBaseError, "#{@rpc_client.uri} does not appear to run AppBase" unless defined? result.map
+          
+          methods = result.map do |method|
+            method.split('.').map(&:to_sym)
+          end
+          
+          api_methods = Hashie::Mash.new
+          
+          methods.each do |api, method|
+            api_methods[api] ||= []
+            api_methods[api] << method
+          end
+          
+          self.class.api_methods[@rpc_client.uri.to_s] = api_methods
+        end
+      end
+      
+      if !!block
+        api_methods.each do |api, methods|
+          yield api, methods
+        end
+      else
+        return api_methods
+      end
+    end
+    
+    def get_all_signatures(&block)
+      request_object = []
+      method_names = []
+      method_map = {}
+      signatures = {}
+      offset = 0
+      
+      get_api_methods do |api, methods|
+        request_object += methods.map do |method|
+          method_name = "#{api}.#{method}"
+          method_names << method_name
+          current_rpc_id = @rpc_client.rpc_id
+          offset += 1
+          method_map[current_rpc_id] = [api, method]
+          
+          {
+            jsonrpc: '2.0',
+            id: current_rpc_id,
+            method: 'jsonrpc.get_signature',
+            params: {method: method_name}
+          }
+        end
+      end
+      
+      chunks = if request_object.size > Crea::RPC::HttpClient::JSON_RPC_BATCH_SIZE_MAXIMUM
+        request_object.each_slice(Crea::RPC::HttpClient::JSON_RPC_BATCH_SIZE_MAXIMUM)
+      else
+        request_object
+      end
+      
+      for request_object in chunks do
+        @rpc_client.rpc_batch_execute(request_object: request_object) do |result, error, id|
+          api, method = method_map[id]
+          api = api.to_sym
+          method = method.to_sym
+          
+          signatures[api] ||= {}
+          signatures[api][method] = result
+        end
+        
+        if !!block
+          signatures.each do |api, methods|
+            yield api, methods
+          end
+        end
+      end
+      
+      return signatures unless !!block
+    end
+  end
+end

data/lib/crea/marshal.rb

@@ -0,0 +1,231 @@
+require 'bindata'
+require 'base58'
+
+module Crea
+  class Marshal
+    include Utils
+    include ChainConfig
+    
+    PUBLIC_KEY_DISABLED = '1111111111111111111111111111111114T1Anm'
+    
+    attr_reader :bytes, :cursor
+
+    def initialize(options = {})
+      @bytes = if !!(hex = options[:hex])
+        unhexlify hex
+      else
+        options[:bytes]
+      end
+      
+      @chain = options[:chain] || :crea
+      @prefix ||= case @chain
+      when :crea then NETWORKS_CREA_ADDRESS_PREFIX
+      when :test then NETWORKS_TEST_ADDRESS_PREFIX
+      else; raise UnsupportedChainError, "Unsupported chain: #{@chain}"
+      end
+      @cursor = 0
+    end
+    
+    def hex
+      hexlify bytes
+    end
+    
+    def rewind!
+      @cursor = 0
+    end
+    
+    def step(n = 0)
+      @cursor += n
+    end
+    
+    def scan(len)
+      bytes.slice(@cursor..(@cursor - 1) + len).tap { |_| @cursor += len }
+    end
+    
+    def operation_type
+      Operation::IDS[unsigned_char]
+    end
+    
+    def unsigned_char; BinData::Uint8le.read(scan(1)); end # 8-bit unsigned 
+    def uint16; BinData::Uint16le.read(scan(2)); end # 16-bit unsigned, VAX (little-endian) byte order
+    def uint32; BinData::Uint32le.read(scan(4)); end # 32-bit unsigned, VAX (little-endian) byte order
+    def uint64; BinData::Uint64le.read(scan(8)); end # 64-bit unsigned, little-endian
+
+    def signed_char; BinData::Int8le.read(scan(1)); end # 8-bit signed 
+    def int16; BinData::Int16le.read(scan(2)); end # 16-bit signed, little-endian
+    def int32; BinData::Int32le.read(scan(4)); end # 32-bit signed, little-endian
+    def int64; BinData::Int64le.read(scan(8)); end # 64-bit signed, little-endian
+
+    def boolean; scan(1) == "\x01"; end
+    
+    def varint
+      shift = 0
+      result = 0
+      bytes = []
+      
+      while (n = unsigned_char) >> 7 == 1
+        bytes << n
+      end
+      
+      bytes << n
+      
+      bytes.each do |b|
+        result += ((b & 0x7f) << shift)
+        break unless (b & 0x80)
+        shift += 7
+      end
+      
+      result
+    end
+    
+    def string(len = nil); scan(len || varint); end
+    
+    def raw_bytes(len = nil); scan(len || varint).force_encoding('BINARY'); end
+  
+    def point_in_time
+      if (time = uint32) == 2**32-1
+        Time.at -1
+      else
+        Time.at time
+      end.utc
+    end
+    
+    def public_key(prefix = @prefix)
+      raw_public_key = raw_bytes(33)
+      checksum = OpenSSL::Digest::RIPEMD160.digest(raw_public_key)
+      key = Base58.binary_to_base58(raw_public_key + checksum.slice(0, 4), :bitcoin)
+      
+      prefix + key unless key == PUBLIC_KEY_DISABLED
+    end
+    
+    def amount
+      amount = uint64.to_f
+      precision = signed_char
+      asset = scan(7).strip
+      
+      amount = "%.#{precision}f #{asset}" % (amount / 10 ** precision)
+
+      Crea::Type::Amount.new(amount)
+    end
+    
+    def price
+      {base: amount, quote: amount}
+    end
+    
+    def authority(options = {optional: false})
+      return if !!options[:optional] && unsigned_char == 0
+      
+      {
+        weight_threshold: uint32,
+        account_auths: varint.times.map { [string, uint16] },
+        key_auths: varint.times.map { [public_key, uint16] }
+      }
+    end
+    
+    def optional_authority
+      authority(optional: true)
+    end
+    
+    def comment_options_extensions
+      if scan(1) == "\x01"
+        beneficiaries
+      else
+        []
+      end
+    end
+    
+    def beneficiaries
+      if scan(1) == "\x00"
+        varint.times.map {{account: string, weight: uint16}}
+      end
+    end
+    
+    def chain_properties
+      {
+        account_creation_fee: amount,
+        maximum_block_size: uint32,
+        cbd_interest_rate: uint16
+      }
+    end
+    
+    def required_auths
+      varint.times.map { string }
+    end
+    
+    def witness_properties
+      properties = {}
+      
+      varint.times do
+        key = string.to_sym
+        properties[key] = case key
+        when :account_creation_fee then Crea::Type::Amount.new(string)
+        when :account_subsidy_budget then scan(3)
+        when :account_subsidy_decay, :maximum_block_size then uint32
+        when :url then string
+        when :cbd_exchange_rate
+          JSON[string].tap do |rate|
+            rate["base"] = Crea::Type::Amount.new(rate["base"])
+            rate["quote"] = Crea::Type::Amount.new(rate["quote"])
+          end
+        when :cbd_interest_rate then uint16
+        when :key, :new_signing_key then @prefix + scan(50)
+        else; raise "Unknown witness property: #{key}"
+        end
+      end
+      
+      properties
+    end
+    
+    def empty_array
+      unsigned_char == 0 and [] or raise "Found non-empty array."
+    end
+    
+    def transaction(options = {})
+      trx = options[:trx] || Transaction.new
+      
+      trx.ref_block_num = uint16
+      trx.ref_block_prefix = uint32
+      trx.expiration = point_in_time
+      
+      trx.operations = operations
+      
+      trx
+    rescue => e
+      raise DeserializationError.new("Transaction failed\nOriginal serialized bytes:\n[#{hex[0..(@cursor * 2) - 1]}]#{hex[((@cursor) * 2)..-1]}", e)
+    end
+
+    def operations
+      operations_len = signed_char
+      operations = []
+      
+      while operations.size < operations_len do
+        begin
+          type = operation_type
+          break if type.nil?
+          
+          op_class_name = type.to_s.sub!(/_operation$/, '')
+          op_class_name = "Crea::Operation::" + op_class_name.split('_').map(&:capitalize).join
+          op_class = Object::const_get(op_class_name)
+          op = op_class.new
+          
+          op_class::serializable_types.each do |k, v|
+            begin
+              # binding.pry if v == :comment_options_extensions
+              op.send("#{k}=", send(v))
+            rescue => e
+              raise DeserializationError.new("#{type}.#{k} (#{v}) failed", e)
+            end
+          end
+          
+          operations << {type: type, value: op}
+        rescue => e
+          raise DeserializationError.new("#{type} failed", e)
+        end
+      end
+      
+      operations
+    rescue => e
+      raise DeserializationError.new("Operations failed", e)
+    end
+  end
+end

data/lib/crea/mixins/jsonable.rb

@@ -0,0 +1,37 @@
+module Crea
+  module JSONable
+    module ClassMethods
+      attr_accessor :attributes
+
+      def attr_accessor *attrs
+        self.attributes = Array attrs
+        
+        super
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def as_json options = {}
+      serialized = Hash.new
+      
+      self.class.attributes.each do |attribute|
+        unless (value = self.public_send attribute).nil?
+          serialized[attribute] = if value.respond_to? :strftime
+            value.strftime('%Y-%m-%dT%H:%M:%S')
+          else
+            value
+          end
+        end
+      end
+      
+      serialized
+    end
+
+    def to_json *a
+      as_json.to_json *a
+    end
+  end
+end

data/lib/crea/mixins/retriable.rb

@@ -0,0 +1,58 @@
+module Crea
+  module Retriable
+    # @private
+    MAX_RETRY_COUNT = 30
+    
+    MAX_RETRY_ELAPSE = 60
+    
+    # @private
+    MAX_BACKOFF = MAX_RETRY_ELAPSE / 4
+    
+    RETRYABLE_EXCEPTIONS = [
+      NonCanonicalSignatureError, IncorrectRequestIdError,
+      IncorrectResponseIdError, RemoteDatabaseLockError
+    ]
+    
+    def can_retry?(e = nil)
+      @retry_count ||= 0
+      
+      return false if @retry_count >= MAX_RETRY_COUNT
+      
+      @retry_count = if retry_reset?
+        @first_retry_at = nil
+      else
+        @retry_count + 1
+      end
+      
+      can_retry = case e
+      when *RETRYABLE_EXCEPTIONS then true
+      else; false
+      end
+      
+      backoff if can_retry
+      
+      can_retry
+    end
+  private
+    # @private
+    def first_retry_at
+      @first_retry_at ||= Time.now.utc
+    end
+    
+    # @private
+    def retry_reset?
+      Time.now.utc - first_retry_at > MAX_RETRY_ELAPSE
+    end
+    
+    # Expontential backoff.
+    #
+    # @private
+    def backoff
+      @backoff ||= 0.1
+      @backoff *= 2
+      @backoff = 0.1 if @backoff > MAX_BACKOFF
+      
+      sleep @backoff
+    end
+  end
+end