xrbp 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cdd7b83c144366a77c0a68287e2ae511fa2878ef5b3be0e0f24b0b4d9e6a1be5
-  data.tar.gz: 1db244c92cefaca23244dd7a20cbb89c0d9e2fc25ab10659483aaa8187f0f117
+  metadata.gz: 90ae30e5619f27c7a1f40b891a0e84b12f2de86bec369391d6e6f39f9a02bc89
+  data.tar.gz: 68365c498a34d0e4c7c3c805b59718f867fa46a6ab2784eab012b22726361212
 SHA512:
-  metadata.gz: 42cdd0d6b998b3550a89233b90c86676fe9e56f7a4981cfad96f209fb3272ae2f669f5b16de399318596d13fb9c0fc2b087fa968155a4f30f211fed46cce74c4
-  data.tar.gz: ee8e543e9e04557f8e8355dbd4f56a19f9176ba8e3f24c87db128298f38caa0386bf3763180bee734c94f7e91aaba3341c4689b4f7d4a53b3d4d0fa49d22b6d9
+  metadata.gz: e0660fab2c5f8248577df45b795d5d6794b03dbb33e88e566ec2e08f477147e74dc92d1703155dc152e103956ac586c38d6e1ad4b02fcd52594f9307f4d97c13
+  data.tar.gz: 3d49ec2789f104a194d6f5b6471cf40c3d0fc51695694157f2c79d189e21fe38ec3a94b2d8cbda9594a87f611f7b3440c5c3f0f9987d12a67782cf22f82c7d0e

data/examples/nodestore1.rb

@@ -21,4 +21,6 @@ puts nledger.order_book iou1, iou2
 puts nledger.txs
 
 require 'xrbp/nodestore/sqldb'
-puts XRBP::NodeStore::SQLDB.new("/var/lib/rippled/").ledger_hash_for_seq(49340234)
+sql = XRBP::NodeStore::SQLDB.new("/var/lib/rippled/nudb")
+puts sql.ledgers.hash_for_seq(49340234)
+puts sql.ledgers.count

data/lib/xrbp/common.rb

@@ -13,4 +13,10 @@ module XRBP
     return nil if xrp_time.nil?
     Time.at(xrp_time + 946684800)
   end
+
+  # Convert local time to XRP Time
+  def self.to_xrp_time(local_time)
+    return nil if local_time.nil?
+    local_time.to_i - 946684800
+  end
 end # module XRBP

data/lib/xrbp/core_ext.rb

@@ -59,6 +59,20 @@ class Integer
     end
     b
   end
+
+  def byte_string
+    bytes.reverse.pack("C*")
+  end
+
+  def to_int32
+    self & (2**32-1)
+  end
+
+  alias :to_int :to_int32
+
+  def from_xrp_time
+    XRBP.from_xrp_time(self)
+  end
 end
 
 # @private
@@ -71,3 +85,10 @@ class Array
     fill(x, length...n)
   end
 end
+
+# @private
+class Time
+  def to_xrp_time
+    XRBP.to_xrp_time(self)
+  end
+end

data/lib/xrbp/nodestore/format.rb

@@ -383,32 +383,82 @@ module XRBP
       ###
 
       TX_TYPES = {
-         -1 => :invalid,
-          0 => :payment,
-          1 => :escrow_create,
-          2 => :escrow_finish,
-          3 => :account_set,
-          4 => :escrow_cancel,
-          5 => :regular_key_set,
-          6 => :nickname_set,    #open
-          7 => :offer_create,
-          8 => :offer_cancel,
-
-          9 => :no_longer_used,
-
-         11 => :ticket_create,
-         12 => :ticket_cancel,
-         13 => :signer_list_set,
-         14 => :paychan_create,
-         15 => :paychan_fund,
-         16 => :paychan_claim,
-         17 => :check_create,
-         18 => :check_cash,
-         19 => :check_cancel,
-         20 => :deposit_preauth,
-
-        100 => :amendment,
-        101 => :fee
+         -1 => :Invalid,
+          0 => :Payment,
+          1 => :EscrowCreate,
+          2 => :EscrowFinish,
+          3 => :AccountSet,
+          4 => :EscrowCancel,
+          5 => :SetRegularKey,
+          6 => :NickNameSet,    #open
+          7 => :OfferCreate,
+          8 => :OfferCancel,
+
+          9 => :unused,
+
+         11 => :TicketCreate,
+         12 => :TicketCancel,
+         13 => :SignerListSet,
+         14 => :PaymentChannelCreate,
+         15 => :PaymentChannelFund,
+         16 => :PaymentChannelClaim,
+         17 => :CheckCreate,
+         18 => :CheckCash,
+         19 => :CheckCancel,
+         20 => :DepositPreauth,
+
+        100 => :EnableAmendment,
+        101 => :SetFee
+      }
+
+      # https://xrpl.org/transaction-results.html
+      TX_RESULTS = {
+        # tec
+        # https://xrpl.org/tec-codes.html
+        # "Transaction failed, but it was applied to a ledger to apply the transaction cost.
+        #    They have numerical values in the range 100 to 199"
+        100 => :tecCLAIM,
+        146 => :tecCRYPTOCONDITION_ERROR,
+        121 => :tecDIR_FULL,
+        149 => :tecDUPLICATE,
+        143 => :tecDST_TAG_NEEDED,
+        148 => :tecEXPIRED,
+        105 => :tecFAILED_PROCESSING,
+        137 => :tecFROZEN,
+        122 => :tecINSUF_RESERVE_LINE,
+        123 => :tecINSUF_RESERVE_OFFER,
+        141 => :tecINSUFFICIENT_RESERVE,
+        144 => :tecINTERNAL,
+        147 => :tecINVARIANT_FAILED,
+        142 => :tecNEED_MASTER_KEY,
+        130 => :tecNO_ALTERNATIVE_KEY,
+        134 => :tecNO_AUTH,
+        124 => :tecNO_DST,
+        125 => :tecNO_DST_INSUF_XRP,
+        140 => :tecNO_ENTRY,
+        133 => :tecNO_ISSUER,
+        150 => :tecKILLED,
+        135 => :tecNO_LINE,
+        126 => :tecNO_LINE_INSUF_RESERVE,
+        127 => :tecNO_LINE_REDUNDANT,
+        139 => :tecNO_PERMISSION,
+        131 => :tecNO_REGULAR_KEY,
+        138 => :tecNO_TARGET,
+        145 => :tecOVERSIZE,
+        132 => :tecOWNERS,
+        128 => :tecPATH_DRY,
+        101 => :tecPATH_PARTIAL,
+        129 => :tecUNFUNDED,
+        102 => :tecUNFUNDED_ADD,
+        104 => :tecUNFUNDED_PAYMENT,
+        103 => :tecUNFUNDED_OFFER,
+
+        # tef, tel, tem, ter transactions _not_
+        # applied to ledger
+
+        # tes
+        # https://xrpl.org/tes-success.html
+        0 => :tesSUCCESS
       }
 
       ###

data/lib/xrbp/nodestore/ledger.rb

@@ -43,12 +43,16 @@ module XRBP
         @fees ||= Fees.new
       end
 
+      # Returns boolean indicating if specified account
+      # is flagged as globally frozen
       def global_frozen?(account)
         return false if account == Crypto.xrp_account
         sle = state_map.read(Indexes::account(account))
         return sle && sle.flag?(:global_freeze)
       end
 
+      # Returns boolean indicating if specific account
+      # has frozen trust-line for specified IOU
       def frozen?(account, iou)
         return false if iou[:currency] == 'XRP'
 
@@ -62,16 +66,19 @@ module XRBP
                                                    :low_freeze)
       end
 
+      # Return IOU balance which owner account holds
       def account_holds(owner_id, iou)
         return xrp_liquid(owner_id, 0) if iou[:currency] == 'XRP'
         sle = state_map.read(Indexes::line(owner_id, iou))
         return STAmount.zero if !sle || frozen?(owner_id, iou)
 
         amount = sle.amount(:balance)
-        amount.negate! if owner_id > iou[:account]
+        amount.negate! if Crypto.account_id(owner_id).to_bn >
+                          Crypto.account_id(iou[:account]).to_bn
         balance_hook(amount)
       end
 
+      # Returns available (liquid) XRP account holds
       def xrp_liquid(account, owner_count_adj)
         sle = state_map.read(Indexes::account(account))
         return STAmount.zero unless sle
@@ -122,8 +129,12 @@ module XRBP
         count
       end
 
+      # Return TransferRate configured for IOU
+      #
+      # @see {Rate}
       def transfer_rate(issuer)
         sle = state_map.read(Indexes::account(issuer))
+
         return Rate.new sle.field(:uint32,
                                   :transfer_rate) if sle &&
                                                      sle.field?(:transfer_rate)
@@ -134,6 +145,10 @@ module XRBP
 
       public
 
+      # TODO: helper method to get first funded high quailty
+      #       offer from order book. Also market depth helper
+
+      # Return all offers for the given input/output currency pair
       def order_book(input, output)
         offers = []
 
@@ -145,6 +160,7 @@ module XRBP
         global_freeze = global_frozen?(output[:account]) ||
                         global_frozen?(input[:account])
 
+        # transfer rate multipled to offer output to pay issuer
         rate = transfer_rate(output[:account])
 
            balances = {}
@@ -180,28 +196,32 @@ module XRBP
             # Read offer from db and process
             sle_offer = state_map.read(offer_index)
             if sle_offer
+              # Direct info from nodestore offer
                 owner_id = sle_offer.account_id(:account)
               taker_gets = sle_offer.amount(:taker_gets)
               taker_pays = sle_offer.amount(:taker_pays)
 
-                    owner_funds = nil
-              first_owner_offer = true
+              # Owner / Output Calculation
+                    owner_funds = nil  # how much of offer output the owner has
+              first_owner_offer = true # owner_funds returned w/ first owner offer
 
+              # issuer is offering it's own IOU, fully funded
               if output[:account] == owner_id
-                # issuer is offering it's own IOU, fully funded
                 owner_funds = taker_gets
 
+              # all offers not ours are unfunded
               elsif global_freeze
-                # all offers not ours are unfunded
                 owner_funds.clear(output)
 
               else
+                # if we have owner funds cached
                 if balances[owner_id]
                   owner_funds = balances[owner_id]
                   first_owner_offer = false
 
+                # did not find balance in cache
                 else
-                  # did not find balance in table
+                  # lookup from nodestore
                   owner_funds = account_holds(owner_id, output)
 
                   # treat negative funds as zero
@@ -209,29 +229,33 @@ module XRBP
                 end
               end
 
-              offer = Hash[sle_offer.fields]
-              taker_gets_funded = nil
-              owner_funds_limit = owner_funds
-              offer_rate = Rate.parity
+              offer = Hash[sle_offer.fields]   # copy the offer fields to return
+              taker_gets_funded = nil          # how much offer owner will actually be able to fund
+              owner_funds_limit = owner_funds  # how much the offer owner has limited by the output transfer fee
+              offer_rate = Rate.parity         # offer base output transfer rate
 
+              # Check if transfer fee applies,
               if            rate != Rate.parity      && # transfer fee
                        # TODO: provide support for 'taker_id' rpc param:
                        #taker_id != output[:account] && # not taking offers of own IOUs
                 output[:account] != owner_id            # offer owner not issuing own funds
                   # Need to charge a transfer fee to offer owner.
                   offer_rate = rate
-                  owner_funds_limit = owner_funds / offer_rate.rate
+                  owner_funds_limit = owner_funds / offer_rate.to_amount
               end
 
-
+              # Check if owner has enough funds to pay it all
               if owner_funds_limit >= taker_gets
                 # Sufficient funds no shenanigans.
                 taker_gets_funded = taker_gets
 
               else
-                # Only provide, if not fully funded.
+                # Only set these fields, if not fully funded.
                 taker_gets_funded = owner_funds_limit
                 offer[:taker_gets_funded] = taker_gets_funded
+
+                # the account that takes the offer will need to
+                # pay the 'gets' amount actually funded times the dir_rate (quality)
                 offer[:taker_pays_funded] = [taker_pays,
                                              taker_gets_funded *
                                                       dir_rate].min
@@ -240,13 +264,21 @@ module XRBP
                 offer[:taker_pays_funded].issue = taker_pays.issue
               end
 
+              # Calculate how much owner will pay after this offer,
+              # if no transfer fee, then the amount funded,
+              # else the minimum of what the owner has or the
+              # amount funded w/ transfer fee
               owner_pays = (Rate.parity == offer_rate) ?
                                      taker_gets_funded :
                                            [owner_funds,
-                         taker_gets_funded * offer_rate].min
+                                      taker_gets_funded *
+                                   offer_rate.to_amount].min
 
+              # Update balance cache w/ new owner balance
               balances[owner_id] = owner_funds - owner_pays
 
+              # Set additional params and store the offer
+
               # include all offers funded and unfunded
               offer[:quality] = dir_rate
               offer[:owner_funds] = owner_funds if first_owner_offer

data/lib/xrbp/nodestore/parser.rb

@@ -157,6 +157,9 @@ module XRBP
         elsif e == :transaction_type
           return Format::TX_TYPES[value]
 
+        elsif e == :transaction_result
+          return Format::TX_RESULTS[value]
+
         elsif e == :ledger_entry_type
           return Format::LEDGER_ENTRY_TYPE_CODES[value.chr]
         end
@@ -189,22 +192,39 @@ module XRBP
 
       # Parse 'Amount' data type from binary data.
       #
+      # Stored internally in 64 bits:
+      # - Bit 1 = 0 for XRP, 1 for IOU
+      # - Bit 2 = sign, 0 for negative, 1 for positive
+      #
+      # For XRP:
+      # - Remaining bits = value in drops
+      #
+      # For IOU:
+      # - Next 8 bits = Exponent
+      # - Next 54 bits = Mantissa
+      # Where value = mantissa * (10 ^ exponent)
+      # Note: 97 is added to exponent when serializing and subtracted when parsing so
+      #       that effective nominal exponent is always in range of -96 to 80
+      #
       # @see https://developers.ripple.com/currency-formats.html
+      # @see STAmount(SerialIter& sit, SField const& name);
+      # @see {STAmount#from_wire}
       #
       # @protected
       def parse_amount(data)
         amount = data[0..7].unpack("Q>").first
-           xrp = amount < 0x8000000000000000
-
-        # FIXME : is sign/neg right (?)
 
-        return STAmount.new(:issue    => NodeStore.xrp_issue,
-                            :mantissa => amount & 0x3FFFFFFFFFFFFFFF), data[8..-1] if xrp
+        # native eg, xrp
+        is_xrp = (amount & STAmount::NOT_NATIVE) == 0
+        if is_xrp
+          is_pos = (amount & STAmount::POS_NATIVE) != 0
+          return STAmount.new(:issue    => NodeStore.xrp_issue,
+                              :mantissa => amount & ~STAmount::POS_NATIVE), data[8..-1] if is_pos
 
-        sign = (amount & 0x4000000000000000) >> 62 # 0 = neg / 1 = pos
-         neg = (sign == 0)
-         exp = (amount & 0x3FC0000000000000) >> 54
-        mant = (amount & 0x003FFFFFFFFFFFFF)
+          return STAmount.new(:issue    => NodeStore.xrp_issue,
+                              :mantissa => amount,
+                              :neg      => true), data[8..-1]
+        end
 
         data = data[8..-1]
         currency = Format::CURRENCY_CODE.decode(data)
@@ -213,12 +233,25 @@ module XRBP
         data = data[Format::CURRENCY_CODE.size..-1]
         issuer, data = parse_account(data, 20)
 
-        sle = STAmount.new(:issue    => Issue.new(currency, issuer),
-                           :neg      => neg,
-                           :mantissa => mant,
-                           :exponent => exp)
+        issue = Issue.new(currency, issuer)
+
+         exp = (amount >> (64 - 10)).to_int
+        mant = (amount & ~(1023 << (64 - 10)))
+
+        if mant
+          neg = (exp & 256) == 0
+          exp = (exp & 255) - 97
+
+          sle = STAmount.new(:issue    => issue,
+                             :neg      => neg,
+                             :mantissa => mant,
+                             :exponent => exp)
+
+          return sle, data
+        end
 
-        return sle, data
+        raise unless exp == 512
+        return STAmount.new(:issue => issue)
       end
 
       # Parse 'Account' data type from binary data.

data/lib/xrbp/nodestore/protocol/indexes.rb

@@ -4,15 +4,14 @@ module XRBP
     module Indexes
 
       def self.get_quality(base)
-        # FIXME: reverse to convert big to little endian,
+        # FIXME: assuming native platform is big endian,
         #        need to account for all platforms
-        base[-8..-1].reverse.to_bn
+        base[-8..-1].to_bn
       end
 
       def self.get_quality_next(base)
         nxt = "10000000000000000".to_i(16)
-        (base.to_bn + nxt).bytes
-                          .reverse.pack("C*")
+        (base.to_bn + nxt).byte_string
       end
 
       ###
@@ -45,6 +44,14 @@ module XRBP
         sha512.digest[0..31]
       end
 
+      # TODO: Account Owner Dir from id
+      def self.owner_dir(id)
+      end
+
+      # TODO: Offer Index for account id and seq
+      def self.offer_index(id, seq)
+      end
+
       # Trust line for account/iou
       def self.line(account, iou)
         account = Crypto.account_id(account)
@@ -68,10 +75,6 @@ module XRBP
         sha512.digest[0..31]
       end
 
-      # TODO: order book dir hash for ledger
-      def self.order_book_dir()
-      end
-
       # Order book index for given input/output
       def self.order_book(input, output)
          input = Hash[input]