xrbp 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d140a426f073971891c8e8e81f5313112c661703cebaee32719f6b04d6ca86b0
+  data.tar.gz: 394f8602052b068b2816ddfa4e06621e7537311b26a9d8248c8eaeb44514e510
+SHA512:
+  metadata.gz: b47922beac1ce4613e1bc4b8953bcdf9368d9fdecdef26b6c489f08ad00db2ce2be9780fa9e3fdcdf3f9b31f5912dd4c54c352e8833c002cef6e5c0c30edbafd
+  data.tar.gz: '0833467cf31a91d158f78b9b480faaddb4447fc7bd4eeb693b21e93ac91ad9e7fdd7ede68e432d7b4755da81ac6fd46f08abaf97e27e27536eee22a34b0af503'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2019 Dev Null Productions <devnullproductions@gmail.com>
+
+MIT License
+
+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,7 @@
+XRBP - Ruby XRP Library
+Copyright (C) 2019 Dev Null Productions
+MIT License
+
+---
+
+XRPB is a rubygem which facilitates reading and writing data to/from the XRP ledger.

data/examples/autoconnect_timeout.rb

@@ -0,0 +1,20 @@
+$: << File.expand_path('../../lib', __FILE__)
+require 'xrbp'
+
+ws = XRBP::WebSocket::Connection.new "wss://s1.ripple.com:443"
+
+ws.on :open do
+  puts "Opened"
+end
+
+ws.on :close do
+  puts "Closed"
+end
+
+ws.on :error do |e|
+  puts "Err #{e}"
+end
+
+ws.add_plugin :autoconnect, :connection_timeout
+ws.connection_timeout = 3
+sleep(60)

data/examples/cmd.rb

@@ -0,0 +1,13 @@
+$: << File.expand_path('../../lib', __FILE__)
+require 'xrbp'
+
+ws = XRBP::WebSocket::Connection.new "wss://s1.ripple.com:443"
+
+ws.connect
+ws.add_plugin :command_dispatcher
+ws.cmd(XRBP::WebSocket::Cmds::ServerInfo.new) do |r|
+  puts r
+  ws.close!
+end
+
+ws.wait_for_close

data/examples/ledger.rb

@@ -0,0 +1,15 @@
+$: << File.expand_path('../../lib', __FILE__)
+require 'xrbp'
+
+ws = XRBP::WebSocket::Connection.new "wss://s1.ripple.com:443"
+ws.add_plugin :command_dispatcher
+ws.connect
+
+puts XRBP::Model::Ledger.new.sync(:connection => ws)
+
+XRBP::Model::Ledger.new.sync(:connection => ws) do |l|
+  puts l
+  ws.close!
+end
+
+ws.wait_for_close

data/examples/ledger_multi_subscribe.rb

@@ -0,0 +1,20 @@
+$: << File.expand_path('../../lib', __FILE__)
+require 'xrbp'
+
+ws = XRBP::WebSocket::Parallel.new "wss://s1.ripple.com:443",
+                                   "wss://s2.ripple.com:443"
+ws.add_plugin :command_dispatcher
+ws.connect
+
+l = 0
+ws.on :message do |msg|
+  msg = JSON.parse(msg.data)
+  next unless msg["ledger_index"] && msg["ledger_index"] > l
+          l = msg["ledger_index"]
+  puts msg
+end
+
+XRBP::Model::Ledger.subscribe(:connection => ws)
+
+#ws.wait_for_close
+sleep(1) while true

data/examples/ledger_subscribe.rb

@@ -0,0 +1,18 @@
+$: << File.expand_path('../../lib', __FILE__)
+require 'xrbp'
+
+ws = XRBP::WebSocket::Connection.new "wss://s1.ripple.com:443"
+ws.add_plugin :command_dispatcher
+ws.connect
+
+i = 0
+ws.on :message do |msg|
+  puts msg
+
+  i += 1
+  ws.close! if i > 5
+end
+
+XRBP::Model::Ledger.subscribe(:connection => ws)
+
+ws.wait_for_close

data/examples/multi.rb

@@ -0,0 +1,10 @@
+$: << File.expand_path('../../lib', __FILE__)
+require 'xrbp'
+
+ws = XRBP::WebSocket::MultiConnection.new "wss://s1.ripple.com:443",
+                                          "wss://s2.ripple.com:443"
+
+ws.add_plugin :command_dispatcher
+ws.connect
+
+puts ws.cmd(XRBP::WebSocket::Cmds::ServerInfo.new)

data/examples/paginate.rb

@@ -0,0 +1,13 @@
+$: << File.expand_path('../../lib', __FILE__)
+require 'xrbp'
+
+ws = XRBP::WebSocket::Connection.new "wss://s1.ripple.com:443"
+
+ws.connect
+ws.add_plugin :command_dispatcher, :command_paginator
+ws.cmd(XRBP::WebSocket::Cmds::AccountObjects.new("rhub8VRN55s94qWKDv6jmDy1pUykJzF3wq", :paginate => true)) do |r|
+  puts r
+  ws.close!
+end
+
+ws.wait_for_close

data/examples/prioritized.rb

@@ -0,0 +1,13 @@
+$: << File.expand_path('../../lib', __FILE__)
+require 'xrbp'
+
+ws = XRBP::WebSocket::Prioritized.new "wss://s1.ripple.com:443",
+                                      "wss://s2.ripple.com:443"
+
+ws.add_plugin :command_dispatcher, :result_parser
+ws.parse_results { |res|
+  res["result"]["ledger"]
+}
+ws.connect
+
+puts ws.cmd(XRBP::WebSocket::Cmds::Ledger.new(28327070))

data/examples/round_robin.rb

@@ -0,0 +1,11 @@
+$: << File.expand_path('../../lib', __FILE__)
+require 'xrbp'
+
+ws = XRBP::WebSocket::RoundRobin.new "wss://s1.ripple.com:443",
+                                     "wss://s2.ripple.com:443"
+
+ws.add_plugin :command_dispatcher
+ws.connect
+
+puts ws.cmd(XRBP::WebSocket::Cmds::ServerInfo.new)
+puts ws.cmd(XRBP::WebSocket::Cmds::ServerInfo.new)

data/examples/websocket.rb

@@ -0,0 +1,20 @@
+$: << File.expand_path('../../lib', __FILE__)
+require 'xrbp'
+
+ws = XRBP::WebSocket::Connection.new "wss://s1.ripple.com:443"
+
+ws.on :open do
+  puts "Opened"
+  ws.close!
+end
+
+ws.on :close do
+  puts "Closed"
+end
+
+ws.on :error do |e|
+  puts "Err #{e}"
+end
+
+ws.connect
+ws.wait_for_close

data/lib/xrbp/model/account.rb

@@ -0,0 +1,27 @@
+module XRBP
+  module Model
+    class Account < Base
+      extend Base::ClassMethods
+
+      attr_accessor :id
+
+      def self.create(opts={})
+      end
+
+      def initialize(opts={})
+        @id = opts[:id]
+        super(opts)
+      end
+
+      def info(opts={}, &bl)
+        set_opts(opts)
+        connection.cmd(WebSocket::Cmds::AccountInfo.new(id, full_opts), &bl)
+      end
+
+      def objects(opts={}, &bl)
+        set_opts(opts)
+        connection.cmd(WebSocket::Cmds::AccountObjects.new(id, full_opts), &bl)
+      end
+    end # class Account
+  end # module Model
+end # module XRBP

data/lib/xrbp/model/base.rb

@@ -0,0 +1,31 @@
+module XRBP
+  module Model
+    class Base
+      module ClassMethods
+        attr_accessor :opts, :connection
+
+        def set_opts(opts={})
+          self.opts ||= {}
+          self.opts.merge!(opts)
+          self.connection = opts[:connection] if opts[:connection]
+        end
+      end
+
+      attr_accessor :opts, :connection
+
+      def initialize(opts={})
+        set_opts(opts)
+      end
+
+      def set_opts(opts={})
+        @opts ||= {}
+        @opts.merge!(opts)
+        @connection = opts[:connection] if opts[:connection]
+      end
+
+      def full_opts
+        (self.class.opts || {}).merge(opts || {}).except(:connection)
+      end
+    end # class Base
+  end # module Model
+end # module XRBP

data/lib/xrbp/model/ledger.rb

@@ -0,0 +1,24 @@
+module XRBP
+  module Model
+    class Ledger < Base
+      extend Base::ClassMethods
+
+      attr_accessor :id
+
+      def initialize(opts={})
+        @id = opts[:id]
+        super(opts)
+      end
+
+      def sync(opts={}, &bl)
+        set_opts(opts)
+        connection.cmd(WebSocket::Cmds::Ledger.new(id, full_opts), &bl)
+      end
+
+      def self.subscribe(opts={}, &bl)
+        set_opts(opts)
+        connection.cmd(WebSocket::Cmds::Subscribe.new(:streams => ["ledger"]), &bl)
+      end
+    end # class Ledger
+  end # module Model
+end # module XRBP

data/lib/xrbp/model.rb

@@ -0,0 +1,3 @@
+require_relative './model/base'
+require_relative './model/ledger'
+require_relative './model/account'

data/lib/xrbp/network/nodes.rb

@@ -0,0 +1,8 @@
+module XRBP
+  module Network
+    class Node
+      # TODO retrieve individual node peers &
+      #      iterator-based mechanism to crawl nodes
+    end
+  end # module Network
+end # module XRBP

data/lib/xrbp/network.rb

@@ -0,0 +1,6 @@
+# TODO implement these http based synchronization targets (w/ robust common http logic)
+#require_relative './network/nodes'
+#require_relative './network/validators'
+#require_relative './network/gateways'
+#require_relative './network/valuations'
+#require_relative './network/tips'

data/lib/xrbp/version.rb

@@ -0,0 +1,3 @@
+module XRBP
+  VERSION = '0.0.1'
+end # module XRBP

data/lib/xrbp/websocket/client.rb

@@ -0,0 +1,127 @@
+require 'websocket'
+
+module XRBP
+  module WebSocket
+    class Client
+      include EventEmitter
+
+      attr_reader :url, :options
+
+      def initialize(url, options={})
+        @url = url
+        @options = options
+
+        @handshaked = false
+        @closed = false
+      end
+
+      def connect
+        emit :connecting
+        @closed = false
+        socket.connect
+        handshake!
+        @thread = poll
+        self
+      end
+
+      ###
+
+      def open?
+        handshake.finished? and !closed?
+      end
+
+      def closed?
+        !!@closed
+      end
+
+      def close(err=nil)
+        return if closed?
+
+        # XXX set closed true first incase callbacks need to check this
+        @closed = true
+
+        send_data nil, :type => :close unless socket.pipe_broken
+        emit :close, err
+
+      ensure
+        # Always set closed true
+        @closed = true
+        socket.close if socket
+        @handshake = nil
+        @handshaked = false
+        @socket = nil
+        #Thread.kill @thread if @thread
+        @thread.join if @thread && Thread.current != @thread
+        emit :completed
+      end
+
+      ###
+
+      def socket
+        @socket ||= Socket.new self
+      end
+
+      ###
+
+      def handshake
+        @handshake ||= ::WebSocket::Handshake::Client.new :url => url,
+                                                      :headers => options[:headers]
+      end
+
+      def handshaked?
+        !!@handshaked
+      end
+
+      def handshake!
+        socket.write handshake.to_s
+
+        until handshaked?
+          socket.read_next handshake
+          @handshaked = handshake.finished?
+        end
+      end
+
+      ###
+
+      def send_data(data, opt={:type => :text})
+        return if !handshaked? || closed?
+
+        frame = ::WebSocket::Frame::Outgoing::Client.new(:data => data,
+                                                         :type => opt[:type],
+                                                      :version => handshake.version)
+
+        begin
+          socket.write_nonblock(frame.to_s)
+
+        rescue Errno::EPIPE, OpenSSL::SSL::SSLError => e
+          close(e)
+        end
+      end
+
+      def poll
+        return Thread.new(socket) do |socket|
+          frame = ::WebSocket::Frame::Incoming::Client.new
+          emit :open
+
+          until closed? do
+            begin
+              socket.read_next(frame)
+
+              if msg = frame.next
+                emit :message, msg
+                frame = ::WebSocket::Frame::Incoming::Client.new
+              end
+
+            rescue EOFError => e
+              emit :error, e
+              close(e)
+
+            rescue => e
+              emit :error, e
+            end
+          end
+        end
+      end
+    end # class Client
+  end # module WebSocket
+end # module XRBP

data/lib/xrbp/websocket/cmds/account_info.rb

@@ -0,0 +1,20 @@
+module XRBP
+  module WebSocket
+    module Cmds
+      class AccountInfo < Command
+        attr_accessor :account, :args
+
+        def initialize(account, args={})
+          @account = account
+          @args = args
+          super(to_h)
+        end
+
+        def to_h
+          args.merge(:command => :account_info,
+                     :account => account)
+        end
+      end # class AccountInfo
+    end # module Cmds
+  end # module WebSocket
+end # module Wipple

data/lib/xrbp/websocket/cmds/account_lines.rb

@@ -0,0 +1,33 @@
+module XRBP
+  module WebSocket
+    module Cmds
+      class AccountLines < Command
+        include Paginated
+
+        def page_title
+          "account_lines"
+        end
+
+        attr_accessor :account, :args
+
+        def initialize(account, args={})
+          @account = account
+          @args = args
+          parse_paginate(args)
+          super(to_h)
+        end
+
+        def self.from_h(h)
+          _h = Hash[h]
+           a = _h.delete(:account)
+           new a, _h
+        end
+
+        def to_h
+          args_without_paginate.merge(:command => :account_lines,
+                                      :account => account)
+        end
+      end # class AccountLines
+    end # module Cmds
+  end # module WebSocket
+end # module Wipple

data/lib/xrbp/websocket/cmds/account_objects.rb

@@ -0,0 +1,33 @@
+module XRBP
+  module WebSocket
+    module Cmds
+      class AccountObjects < Command
+        include Paginated
+
+        def page_title
+          "account_objects"
+        end
+
+        attr_accessor :account, :args
+
+        def initialize(account, args={})
+          @account = account
+          @args = args
+          parse_paginate(args)
+          super(to_h)
+        end
+
+        def self.from_h(h)
+          _h = Hash[h]
+           a = _h.delete(:account)
+           new a, _h
+        end
+
+        def to_h
+          args_without_paginate.merge(:command => :account_objects,
+                                      :account => account)
+        end
+      end # class AccountLines
+    end # module Cmds
+  end # module WebSocket
+end # module Wipple

data/lib/xrbp/websocket/cmds/account_offers.rb

@@ -0,0 +1,33 @@
+module XRBP
+  module WebSocket
+    module Cmds
+      class AccountOffers < Command
+        include Paginated
+
+        def page_title
+          "offers"
+        end
+
+        attr_accessor :account, :args
+
+        def initialize(account, args={})
+          @account = account
+          @args = args
+          parse_paginate(args)
+          super(to_h)
+        end
+
+        def self.from_h(h)
+          _h = Hash[h]
+           a = _h.delete(:account)
+           new a, _h
+        end
+
+        def to_h
+          args_without_paginate.merge(:command => :account_offers,
+                                      :account => account)
+        end
+      end # class AccountLines
+    end # module Cmds
+  end # module WebSocket
+end # module Wipple

data/lib/xrbp/websocket/cmds/account_tx.rb

@@ -0,0 +1,20 @@
+module XRBP
+  module WebSocket
+    module Cmds
+      class AccountTx < Command
+        attr_accessor :account, :args
+
+        def initialize(account, args={})
+          @account = account
+          @args = args
+          super(to_h)
+        end
+
+        def to_h
+          args.merge(:command => :account_tx,
+                     :account => account)
+        end
+      end # class AccountLines
+    end # module Cmds
+  end # module WebSocket
+end # module Wipple

data/lib/xrbp/websocket/cmds/book_offers.rb

@@ -0,0 +1,38 @@
+module XRBP
+  module WebSocket
+    module Cmds
+      class BookOffers < Command
+        include Paginated
+
+        def page_title
+          "offers"
+        end
+
+        attr_accessor :args
+
+        def initialize(args={})
+          @args = args
+          parse_paginate(args)
+          super(to_h)
+        end
+
+        def self.from_h(h)
+           new Hash[h]
+        end
+
+        def sanitized_args
+          sa = Hash[args_without_paginate]
+
+          sa[:taker_gets].delete(:issuer) if sa[:taker_gets][:currency] == "XRP"
+          sa[:taker_pays].delete(:issuer) if sa[:taker_pays][:currency] == "XRP"
+
+          sa
+        end
+
+        def to_h
+          sanitized_args.merge(:command => :book_offers)
+        end
+      end # class BookOffers
+    end # module Cmds
+  end # module WebSocket
+end # module Wipple

data/lib/xrbp/websocket/cmds/ledger.rb

@@ -0,0 +1,25 @@
+module XRBP
+  module WebSocket
+    module Cmds
+      class Ledger < Command
+        attr_accessor :id, :args
+
+        def initialize(id=nil, args={})
+          @id = id
+          @args = args
+          super(to_h)
+        end
+
+        def id?
+          !!id
+        end
+
+        def to_h
+          h = args.merge(:command => :ledger)
+          h['ledger_index'] = id if id?
+          return h
+        end
+      end
+    end # module Cmds
+  end # module WebSocket
+end # module Wipple

data/lib/xrbp/websocket/cmds/ledger_entry.rb

@@ -0,0 +1,16 @@
+module XRBP
+  module WebSocket
+    module Cmds
+      class LedgerEntry < Command
+        def initialize(args={})
+          @args = args
+          super(to_h)
+        end
+
+        def to_h
+          @args.merge('command' => 'ledger_entry')
+        end
+      end
+    end # module Cmds
+  end # module WebSocket
+end # module Wipple