stellar_spectrum 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0973e01fef131fdb5026e04c8ca49939c230a54d2086bd3838b84fe7bdb2e693'
-  data.tar.gz: c5f9da4f3eb02163675fb64745b4b1dfa52a7500d4f9c0e0352cccf7bbfd60a1
+  metadata.gz: 82171102575548c02b4566a049a7959544daea5bb1e4509df7a5ce1e78dd1a2e
+  data.tar.gz: 88a64d56566dacc96206c78be2fb0f4aa37ba36a0565009c9db048f55feaa3f8
 SHA512:
-  metadata.gz: f896ac727003556d6116c8bcc7609dac568ab3d99d163dad267f67119184bff303b53c01da8556ca4eb5cd3622b48b5b24460922572d2067cd15de917ebcb45d
-  data.tar.gz: d93ee85a47ec55cf62ea627a67af50ee25a7ca4592939046c6996e7e8e1e2cd5a895b80e1a0c87142944a4ce9714f992a098570188d01433384c06950ec3c46e
+  metadata.gz: 548ca98342523d4b589461d1a8f5ea210778a0d97acc6e0844b83c38d9ca36c9d250ef04e73b9dd5fa906ee063f5f103ac409f4f7dbfaeb1fa496e4e80260e38
+  data.tar.gz: 398063e01bf565768e527af8eba2dce1dae26d0c5f914363a76de8a7a3bde7398d1581315e032647ea33f991610cbee71892ffe3104d3e261776b26fed4ced46

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.5.3

data/CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.0] - 2018-12-12
+### Added
+- Retry when timeout is encountered [#6](https://github.com/bloom-solutions/stellar_spectrum-ruby/pull/6)
+
 ## [1.0.0] - 2018-11-30
 ### Changed
 - Use stellar-sdk => 0.6.0

data/Gemfile.lock

@@ -1,18 +1,19 @@
 PATH
   remote: .
   specs:
-    stellar_spectrum (1.0.0)
+    stellar_spectrum (1.1.0)
       activesupport
       gem_config
+      light-service
       redis
       stellar-sdk (>= 0.6.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (5.2.1.1)
-      activesupport (= 5.2.1.1)
-    activesupport (5.2.1.1)
+    activemodel (5.2.2)
+      activesupport (= 5.2.2)
+    activesupport (5.2.2)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
@@ -49,13 +50,15 @@ GEM
       faraday_middleware
       net-http-digest_auth
       uri_template
-    i18n (1.1.1)
+    i18n (1.2.0)
       concurrent-ruby (~> 1.0)
-    method_source (0.9.0)
+    light-service (0.11.0)
+      activesupport (>= 3.0)
+    method_source (0.9.2)
     minitest (5.11.3)
     multipart-post (2.0.0)
     net-http-digest_auth (1.4.1)
-    pry (0.11.3)
+    pry (0.12.2)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
     pry-byebug (3.6.0)

data/README.md

@@ -61,6 +61,14 @@ When another transaction is created, an available (unlocked) payment channel wil
 
 If all payment channels are unavailable (locked), then the call will block the Ruby process/thread until a channel is available. Therefore, unless you have way more channels than you will ever consume, we strongly recommend you send transactions in a background worker like Sidekiq.
 
+#### Retries
+
+When the call to Horizon [times out](https://www.stellar.org/developers/horizon/reference/errors/timeout.html), we do not know whether or not the asset was sent.
+
+Because there are many payment channels to choose from, and each channel has their own sequence number, it would be complicated to control it from outside the gem. Therefore, this gem will retry for you. When a timeout is encountered the same channel and the same sequence number will be used to retry, as suggested in the Stellar docs.
+
+If the response is successful, the gem will mark the request as successful, and return the response.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/stellar_spectrum/client.rb

@@ -21,143 +21,33 @@ module StellarSpectrum
       self.logger = logger
     end
 
-    def send_payment(from:, to:, amount:, memo: nil, tries: 0)
-      tries += 1
-      available_channels = GetAvailableChannels.execute(
-        redis: redis,
-        locked_accounts: locked_accounts,
-        channel_accounts: channel_accounts,
-      )
-
-      if available_channels.empty?
-        log "No available channels, retry for the #{tries.ordinalize} time..."
-        attempt_release_lock!
-
-        return send_payment(
-          from: from,
-          to: to,
-          amount: amount,
-          memo: memo,
-          tries: tries,
-        )
-      end
-
-      log "Sending payment. #{available_channels.count} available channels: " \
-        "#{available_channels.map(&:address).inspect}"
-
-      channel_account = available_channels.first
-
-      next_sequence_number = next_sequence_number_for(channel_account)
-
-      successfully_locked = lock!(channel_account.address, {
-        sequence_number: next_sequence_number,
-      })
-
-      if !successfully_locked
-        log "Unable to lock #{channel_account.address}, " \
-          "retry for the #{tries.ordinalize} time..."
-
-        attempt_release_lock!
-
-        return send_payment(
-          from: from,
-          to: to,
-          amount: amount,
-          memo: memo,
-          tries: tries,
-        )
-      end
-
-      stellar_client.send_payment(
+    def send_payment(
+      from:,
+      to:,
+      amount:,
+      memo: nil,
+      tries: 0,
+      transaction_source: nil,
+      sequence: nil
+    )
+      result = SendPayment.(
         from: from,
         to: to,
         amount: amount,
         memo: memo,
-        transaction_source: channel_account,
-        sequence: next_sequence_number,
+        seeds: seeds,
+        redis_url: redis_url,
+        horizon_url: horizon_url,
+        force_transaction_source: transaction_source,
+        force_sequence_number: sequence,
+        force_lock: false,
       )
-    end
-
-    def attempt_release_lock!(except_address: nil)
-      if logger
-        log_message =  "Attempting to release a lock"
-        if except_address.present?
-          log_message << "(except for address #{except_address})"
-        end
-        log log_message
-      end
-
-      address, address_info = locked_accounts.except(except_address).
-        sort_by {|address, info| info[:pttl]}.last
-
-      return false if address.nil?
-
-      current_sequence_number = current_sequence_number_for(address)
-      address_info = locked_accounts[address]
-
-      # Someone else may have unlocked it while we were taking our sweet
-      # time fetching the sequence number
-      return false if address_info.nil?
-
-      address_sequence_number = address_info[:sequence_number].to_i
-      if current_sequence_number < address_sequence_number
-        log "Not releasing #{address}: sequence number locked at " \
-          "#{address_sequence_number} is > current sequence number " \
-          "#{current_sequence_number}"
-        return false
-      end
 
-      log "Releasing #{address}: sequence number locked at " \
-        "#{address_sequence_number} is <= current sequence number " \
-        "#{current_sequence_number}"
-      unlock!(address)
-    end
-
-    def channel_accounts
-      @channel_accounts ||= seeds.map { |s| Stellar::Account.from_seed(s) }
-    end
-
-    def locked_accounts
-      GetLockedAccounts.execute(redis: redis, channel_accounts: channel_accounts)
-    end
+      # if result.failure?
+        # return false
+      # end
 
-    def stellar_client
-      @stellar_client ||= Stellar::Client.new(horizon: self.horizon_url)
+      result.send_asset_response
     end
-
-    def redis
-      @redis ||= InitRedis.execute(redis_url: self.redis_url)
-    end
-
-    def lock!(address, sequence_number:)
-      redis.set(GetKeyForAddress.execute(address), sequence_number, {
-        nx: true,
-        ex: MAX_LOCK_TIME_IN_SECONDS,
-      })
-    end
-
-    def unlock!(address)
-      log "Unlocking address #{address}"
-      redis.del(GetKeyForAddress.execute(address))
-    end
-
-    def next_sequence_number_for(address_or_account)
-      current_sequence_number_for(address_or_account) + 1
-    end
-
-    def current_sequence_number_for(address_or_account)
-      account = address_or_account
-      if address_or_account.is_a?(String)
-        account = Stellar::Account.from_address(address_or_account)
-      end
-
-      stellar_client.account_info(account).sequence.to_i
-    end
-
-    def log(message)
-      return if logger.nil?
-      logger.info [LOG_TAG, message].join(" ")
-    end
-
   end
 end

data/lib/stellar_spectrum/services/get_available_channels.rb

@@ -1,11 +1,16 @@
 module StellarSpectrum
   class GetAvailableChannels
 
-    def self.execute(redis:, locked_accounts:, channel_accounts:)
-      locked_addresses = locked_accounts.keys
-      channel_accounts.each_with_object([]) do |account, available_channels|
+    extend LightService::Action
+    expects :redis, :locked_accounts, :channel_accounts
+    promises :available_channels
+
+    executed do |c|
+      locked_addresses = c.locked_accounts.keys
+
+      c.available_channels = c.channel_accounts.each_with_object([]) do |account, channels|
         next if locked_addresses.include?(account.address)
-        available_channels << account
+        channels << account
       end
     end
 

data/lib/stellar_spectrum/services/get_channel_account_info.rb

@@ -0,0 +1,23 @@
+module StellarSpectrum
+  class GetChannelAccountInfo
+
+    extend LightService::Action
+    expects :locked_accounts, :channel_account
+    promises :channel_account_info, :unlock_response
+
+    executed do |c|
+      c.channel_account_info = c.locked_accounts[c.channel_account.address]
+
+      c.unlock_response = nil
+      next c if c.channel_account_info.present?
+
+      c.unlock_response = true
+
+      message = "#{c.channel_account.address} has been unlocked by some " \
+        "other mechanism like ttl expiration or by something else, " \
+        "so this is a success"
+      c.skip_remaining!(message)
+    end
+
+  end
+end

data/lib/stellar_spectrum/services/get_channel_accounts.rb

@@ -0,0 +1,15 @@
+module StellarSpectrum
+  class GetChannelAccounts
+
+    extend LightService::Action
+    expects :seeds
+    promises :channel_accounts
+
+    executed do |c|
+      c.channel_accounts = c.seeds.map do |seed|
+        Stellar::Account.from_seed(seed)
+      end
+    end
+
+  end
+end

data/lib/stellar_spectrum/services/get_locked_accounts.rb

@@ -1,9 +1,16 @@
 module StellarSpectrum
   class GetLockedAccounts
 
+    extend LightService::Action
+    expects :redis, :channel_accounts
+    promises :locked_accounts
+
     REDIS_PTTL_KEY_NON_PRESENT = -2
 
-    def self.execute(redis:, channel_accounts:)
+    executed do |c|
+      redis = c.redis
+      channel_accounts = c.channel_accounts
+
       addresses = channel_accounts.map(&:address)
       address_keys = addresses.map {|a| GetKeyForAddress.execute(a) }
       redis_response = redis.multi do
@@ -15,7 +22,7 @@ module StellarSpectrum
       address_sequence_numbers = redis_response[0]
       address_pttls = redis_response[1..-1]
 
-      addresses.each_with_object({}).with_index do |(address, hash), i|
+      c.locked_accounts = addresses.each_with_object({}).with_index do |(address, hash), i|
         pttl = address_pttls[i]
 
         next if pttl == REDIS_PTTL_KEY_NON_PRESENT

data/lib/stellar_spectrum/services/get_sequence_number.rb

@@ -0,0 +1,17 @@
+module StellarSpectrum
+  class GetSequenceNumber
+
+    extend LightService::Action
+    expects :stellar_client, :channel_account
+    promises :current_sequence_number, :next_sequence_number
+
+    executed do |c|
+      account_info = c.stellar_client.account_info(c.channel_account)
+      c.current_sequence_number = account_info.sequence.to_i
+
+      c.next_sequence_number = c[:force_sequence_number] ||
+        c.current_sequence_number + 1
+    end
+
+  end
+end

data/lib/stellar_spectrum/services/increment_tries.rb

@@ -0,0 +1,13 @@
+module StellarSpectrum
+  class IncrementTries
+
+    extend LightService::Action
+    expects :tries
+    promises :tries
+
+    executed do |c|
+      c.tries += 1
+    end
+
+  end
+end

data/lib/stellar_spectrum/services/init_redis.rb

@@ -1,8 +1,12 @@
 module StellarSpectrum
   class InitRedis
 
-    def self.execute(redis_url:)
-      Redis.new(redis_url: redis_url)
+    extend LightService::Action
+    expects :redis_url
+    promises :redis
+
+    executed do |c|
+      c.redis = Redis.new(redis_url: c.redis_url)
     end
 
   end

data/lib/stellar_spectrum/services/init_stellar_client.rb

@@ -0,0 +1,13 @@
+module StellarSpectrum
+  class InitStellarClient
+
+    extend LightService::Action
+    expects :horizon_url
+    promises :stellar_client
+
+    executed do |c|
+      c.stellar_client = Stellar::Client.new(horizon: c.horizon_url)
+    end
+
+  end
+end

data/lib/stellar_spectrum/services/lock_channel.rb

@@ -0,0 +1,25 @@
+module StellarSpectrum
+  class LockChannel
+
+    extend LightService::Action
+    expects :channel_account, :next_sequence_number, :redis, :force_lock
+    promises :successfully_locked
+
+    SUCCESS_NON_NX_RESULT = "OK".freeze
+
+    executed do |c|
+      address = c.channel_account.address
+      address_key = GetKeyForAddress.execute(address)
+
+      c.successfully_locked = c.redis.set(address_key, c.next_sequence_number, {
+        nx: !c.force_lock,
+        ex: Client::MAX_LOCK_TIME_IN_SECONDS,
+      })
+
+      if c.successfully_locked == SUCCESS_NON_NX_RESULT
+        c.successfully_locked = true
+      end
+    end
+
+  end
+end

data/lib/stellar_spectrum/services/pick_channel.rb

@@ -0,0 +1,13 @@
+module StellarSpectrum
+  class PickChannel
+
+    extend LightService::Action
+    expects :available_channels
+    promises :channel_account
+
+    executed do |c|
+      c.channel_account = c.available_channels.first
+    end
+
+  end
+end

data/lib/stellar_spectrum/services/send_payment.rb

@@ -0,0 +1,64 @@
+module StellarSpectrum
+  class SendPayment
+
+    extend LightService::Organizer
+
+    def self.call(
+      from:,
+      to:,
+      amount:,
+      memo: nil,
+      tries: 0,
+      seeds:,
+      redis_url:,
+      horizon_url:,
+      force_transaction_source: nil,
+      force_sequence_number: nil,
+      force_lock: false
+    )
+      with(
+        from: from,
+        to: to,
+        amount: amount,
+        memo: memo,
+        tries: tries,
+        seeds: seeds,
+        redis_url: redis_url,
+        horizon_url: horizon_url,
+        force_transaction_source: force_transaction_source,
+        force_sequence_number: force_sequence_number,
+        force_lock: force_lock,
+      ).reduce(actions)
+    end
+
+    def self.actions
+      [
+        IncrementTries,
+        InitStellarClient,
+        InitRedis,
+        GetChannelAccounts,
+        reduce_if(->(c) {c[:force_transaction_source].nil?}, [
+          GetLockedAccounts,
+          GetAvailableChannels,
+          reduce_if(->(c) { c.available_channels.empty? }, retry_actions),
+          PickChannel,
+        ]),
+        reduce_if(->(c) {c[:force_transaction_source].present?}, [
+          execute(->(c) {c[:channel_account] = c[:force_transaction_source]}),
+        ]),
+        GetSequenceNumber,
+        LockChannel,
+        reduce_if(->(c) {!c.successfully_locked}, retry_actions),
+        SendingPayment::SendAsset,
+      ]
+    end
+
+    def self.retry_actions
+      [
+        SendingPayment::AttemptReleaseLock,
+        SendingPayment::Retry,
+      ]
+    end
+
+  end
+end

data/lib/stellar_spectrum/services/sending_payment/attempt_release_lock.rb

@@ -0,0 +1,18 @@
+module StellarSpectrum
+  module SendingPayment
+    class AttemptReleaseLock
+
+      extend LightService::Action
+      expects :stellar_client, :redis, :channel_accounts
+
+      executed do |c|
+        Unlocking::AttemptRelease.(
+          stellar_client: c.stellar_client,
+          redis: c.redis,
+          channel_accounts: c.channel_accounts,
+        )
+      end
+
+    end
+  end
+end

data/lib/stellar_spectrum/services/sending_payment/retry.rb

@@ -0,0 +1,45 @@
+module StellarSpectrum
+  module SendingPayment
+    class Retry
+
+      extend LightService::Action
+      EXPECTS = %i[
+        from
+        to
+        amount
+        memo
+        tries
+        seeds
+        horizon_url
+        redis_url
+        force_transaction_source
+        force_sequence_number
+        force_lock
+      ]
+      expects *EXPECTS
+      promises :send_asset_response
+      WAIT_TIME_IN_SECONDS = 5
+
+      executed do |c|
+        sleep WAIT_TIME_IN_SECONDS
+
+        args = EXPECTS.each_with_object({}) do |attr, hash|
+          hash[attr] = c.send(attr)
+        end
+
+        c.send_asset_response = SendPayment.(args).send_asset_response
+
+        # THIS IS IMPORTANT or else it will continue with the rest of the
+        # actions and possibly send out the asset just as many times as `tries`
+        # https://github.com/adomokos/light-service/pull/164
+        # fail_and_return for now until we figure out a way to stop all actions
+        # from reduce_if
+        # See https://github.com/adomokos/light-service/pull/164
+        message = "Closing try #{c.tries}"
+        c.fail_and_return! message
+      end
+
+    end
+
+  end
+end

data/lib/stellar_spectrum/services/sending_payment/send_asset.rb

@@ -0,0 +1,57 @@
+module StellarSpectrum
+  module SendingPayment
+    class SendAsset
+
+      extend LightService::Action
+      TIMEOUT_CODE = 504.freeze
+
+      expects *%i[
+        from
+        to
+        amount
+        memo
+        channel_account
+        next_sequence_number
+        stellar_client
+        tries
+        seeds
+        horizon_url
+        redis_url
+      ]
+
+      promises :send_asset_response
+
+      executed do |c|
+        c.send_asset_response = c.stellar_client.send_payment(
+          from: c.from,
+          to: c.to,
+          amount: c.amount,
+          memo: c.memo,
+          transaction_source: c.channel_account,
+          sequence: c.next_sequence_number,
+        )
+      rescue Faraday::ClientError => e
+        if e.response[:status] == TIMEOUT_CODE
+          retry_result = Retry.execute(
+            stellar_client: c.stellar_client,
+            from: c.from,
+            to: c.to,
+            amount: c.amount,
+            memo: c.memo,
+            tries: c.tries,
+            seeds: c.seeds,
+            horizon_url: c.horizon_url,
+            redis_url: c.redis_url,
+            force_transaction_source: c.channel_account,
+            force_sequence_number: c.next_sequence_number,
+            force_lock: true,
+          )
+          c.send_asset_response = retry_result[:send_asset_response]
+        else
+          fail
+        end
+      end
+
+    end
+  end
+end

data/lib/stellar_spectrum/services/unlocking/attempt_release.rb

@@ -0,0 +1,37 @@
+module StellarSpectrum
+  module Unlocking
+    class AttemptRelease
+
+      extend LightService::Organizer
+      def self.call(redis:, channel_accounts:, stellar_client:)
+        result = with(
+          stellar_client: stellar_client,
+          redis: redis,
+          channel_accounts: channel_accounts,
+        ).reduce(actions)
+
+        if result.failure?
+          result[:unlock_response] = false
+        end
+
+        result
+      end
+
+      def self.actions
+        [
+          GetLockedAccounts,
+          GetAccountToUnlock,
+          GetSequenceNumber,
+          # Someone else may have unlocked it while we were taking
+          # our sweet time fetching the sequence number, so fetch
+          # the locked accounts again:
+          GetLockedAccounts,
+          GetChannelAccountInfo,
+          CheckSequenceNumber,
+          Unlock,
+        ]
+      end
+
+    end
+  end
+end

data/lib/stellar_spectrum/services/unlocking/check_sequence_number.rb

@@ -0,0 +1,25 @@
+module StellarSpectrum
+  module Unlocking
+    class CheckSequenceNumber
+
+      extend LightService::Action
+      expects :current_sequence_number, :channel_account, :channel_account_info
+
+      executed do |c|
+        address_sequence_number = c.channel_account_info[:sequence_number].to_i
+        current_sequence_number = c.current_sequence_number
+
+        next c if current_sequence_number >= address_sequence_number
+
+        address = c.channel_account.address
+
+        message = "Not releasing #{address}: sequence number locked at " \
+          "#{address_sequence_number} is > current sequence number " \
+          "#{current_sequence_number}"
+
+        c.fail_and_return! message
+      end
+
+    end
+  end
+end

data/lib/stellar_spectrum/services/unlocking/get_account_to_unlock.rb

@@ -0,0 +1,23 @@
+module StellarSpectrum
+  module Unlocking
+    class GetAccountToUnlock
+
+      extend LightService::Action
+      expects :locked_accounts
+      promises :channel_account
+
+      executed do |c|
+        address, info = c.locked_accounts.except(c[:except_address])
+          .sort_by {|address, info| info[:pttl]}.last
+
+        if address.present?
+          c.channel_account = Stellar::Account.from_address(address)
+        else
+          c.channel_account = nil
+          c.fail_and_return! "No addresses to unlock"
+        end
+      end
+
+    end
+  end
+end

data/lib/stellar_spectrum/services/unlocking/unlock.rb

@@ -0,0 +1,16 @@
+module StellarSpectrum
+  module Unlocking
+    class Unlock
+
+      extend LightService::Action
+      expects :redis, :channel_account
+      promises :unlock_response
+
+      executed do |c|
+        address_key = GetKeyForAddress.execute(c.channel_account.address)
+        c.unlock_response = c.redis.del(address_key)
+      end
+
+    end
+  end
+end

data/lib/stellar_spectrum/version.rb

@@ -1,3 +1,3 @@
 module StellarSpectrum
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/stellar_spectrum.rb

@@ -1,4 +1,5 @@
 require "gem_config"
+require "light-service"
 require "stellar_spectrum/version"
 require "stellar_spectrum/client"
 require "stellar-sdk"
@@ -6,10 +7,25 @@ require "redis"
 require "active_support/core_ext/hash/except"
 require "active_support/core_ext/object/blank"
 require 'active_support/core_ext/integer/inflections'
+require "stellar_spectrum/services/get_channel_account_info"
 require "stellar_spectrum/services/get_available_channels"
+require "stellar_spectrum/services/get_channel_accounts"
 require "stellar_spectrum/services/get_key_for_address"
 require "stellar_spectrum/services/get_locked_accounts"
+require "stellar_spectrum/services/get_sequence_number"
+require "stellar_spectrum/services/increment_tries"
 require "stellar_spectrum/services/init_redis"
+require "stellar_spectrum/services/init_stellar_client"
+require "stellar_spectrum/services/lock_channel"
+require "stellar_spectrum/services/pick_channel"
+require "stellar_spectrum/services/send_payment"
+require "stellar_spectrum/services/sending_payment/attempt_release_lock"
+require "stellar_spectrum/services/sending_payment/retry"
+require "stellar_spectrum/services/sending_payment/send_asset"
+require "stellar_spectrum/services/unlocking/attempt_release"
+require "stellar_spectrum/services/unlocking/check_sequence_number"
+require "stellar_spectrum/services/unlocking/get_account_to_unlock"
+require "stellar_spectrum/services/unlocking/unlock"
 
 module StellarSpectrum
 

data/stellar_spectrum.gemspec

@@ -39,6 +39,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "gem_config"
   spec.add_dependency "redis"
   spec.add_dependency "stellar-sdk", ">= 0.6.0"
+  spec.add_dependency "light-service"
 
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stellar_spectrum
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Ramon Tayag
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-30 00:00:00.000000000 Z
+date: 2018-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -67,6 +67,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: light-service
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -147,6 +161,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".ruby-version"
 - ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
@@ -161,9 +176,24 @@ files:
 - lib/stellar_spectrum.rb
 - lib/stellar_spectrum/client.rb
 - lib/stellar_spectrum/services/get_available_channels.rb
+- lib/stellar_spectrum/services/get_channel_account_info.rb
+- lib/stellar_spectrum/services/get_channel_accounts.rb
 - lib/stellar_spectrum/services/get_key_for_address.rb
 - lib/stellar_spectrum/services/get_locked_accounts.rb
+- lib/stellar_spectrum/services/get_sequence_number.rb
+- lib/stellar_spectrum/services/increment_tries.rb
 - lib/stellar_spectrum/services/init_redis.rb
+- lib/stellar_spectrum/services/init_stellar_client.rb
+- lib/stellar_spectrum/services/lock_channel.rb
+- lib/stellar_spectrum/services/pick_channel.rb
+- lib/stellar_spectrum/services/send_payment.rb
+- lib/stellar_spectrum/services/sending_payment/attempt_release_lock.rb
+- lib/stellar_spectrum/services/sending_payment/retry.rb
+- lib/stellar_spectrum/services/sending_payment/send_asset.rb
+- lib/stellar_spectrum/services/unlocking/attempt_release.rb
+- lib/stellar_spectrum/services/unlocking/check_sequence_number.rb
+- lib/stellar_spectrum/services/unlocking/get_account_to_unlock.rb
+- lib/stellar_spectrum/services/unlocking/unlock.rb
 - lib/stellar_spectrum/version.rb
 - stellar_spectrum.gemspec
 homepage: https://github.com/bloom-solutions/stellar_spectrum-ruby
@@ -190,7 +220,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.7.8
 signing_key: 
 specification_version: 4
 summary: Use Stellar payment channels in Ruby with ease