cosgrove 0.0.3.5 → 0.0.4.1

data/lib/cosgrove/support.rb

@@ -4,9 +4,32 @@ module Cosgrove
     include ActionView::Helpers::TextHelper
     include ActionView::Helpers::DateHelper
     
-    def suggest_account_name(account_name)
-      regex = /.*#{account_name.chars.each.map { |c| c }.join('.*')}.*/
-      guesses = SteemData::Account.where(name: regex).distinct(:name)
+    # Reduce RL bucket depletion
+    def start_typing(event)
+      return if event.nil?
+      return unless event.respond_to? :channel
+      return unless event.channel.respond_to? :start_typing
+      
+      @channels_typing ||= {}
+      
+      if !!@channels_typing[event.channel.id] && (Time.now - @channels_typing[event.channel.id]) < 15
+        return
+      end
+      
+      @channels_typing[event.channel.id] = Time.now
+      
+      event.channel.start_typing
+    end
+    
+    def suggest_account_name(account_name, chain = :hive)
+      chain = chain.to_s.downcase.to_sym
+      pattern = account_name.chars.each.map{ |c| c }.join('%')
+      guesses = case chain
+      # when :steem then SteemApi::Account.where("name LIKE '%#{pattern}%'").pluck(:name)
+      when :hive then HiveSQL::Account.where("name LIKE '%#{pattern}%'").pluck(:name)
+      else
+        []
+      end
       
       if guesses.any?
         guesses.sample
@@ -15,7 +38,7 @@ module Cosgrove
 
     def unknown_account(account_name, event = nil)
       help = ["Unknown account: *#{account_name}*"]
-      event.channel.start_typing if !!event
+      start_typing event
       guess = suggest_account_name(account_name)
 
       help << ", did you mean: #{guess}?" if !!guess
@@ -28,75 +51,77 @@ module Cosgrove
       help.join
     end
     
-    def mongo_behind_warning(event)
-      elapse = -1
-      
-      begin
-        message = []
-        
-        if (blocks = head_block_number(:steem) - steem_data_head_block_number) > 1200
-          elapse = blocks * 3
-          message << "Mongo is behind by #{time_ago_in_words(elapse.seconds.ago)}."
-        else
-          0
-        end
-        
-        if message.size > 0
-          event.respond message.join(' ')
-        end
-      rescue => e
-        event.respond "Mongo might be behind, but the API is also acting up.  Please try again later.\n\n```#{e.inspect}\n```"
-        sleep 15
-        event.respond Cosgrove::SnarkCommands::WITTY.sample
-      end
-      
-      elapse
-    end
-    
     def cannot_find_input(event, message_prefix = "Unable to find that.")
       message = [message_prefix]
       
-      message << if (blocks = head_block_number(:steem) - steem_data_head_block_number) > 86400
-        elapse = blocks * 3
-        "  Mongo is behind by #{time_ago_in_words(elapse.seconds.ago)}.  Try again later."
-      else
-        "  Mongo might be behind or this is not a valid input."
-      end
-        
       event.respond message.join(' ')
     end
     
     def append_link_details(event, slug)
+      return if skipped_channel? event.channel.id
+      
+      chain = :hive
       author_name, permlink = parse_slug slug
       created = nil
       cashout_time = nil
+      message = nil
       
-      if slug =~ /steemit.com/
-        chain = :steem
-      elsif slug =~ /golos.io/
-        chain = :golos
-      elsif slug =~ /golos.blog/
-        chain = :golos
-      else
-        return # silntlly ignore this slug
+      return unless !!author_name && !!permlink
+      
+      if !!event
+        begin
+          message = event.respond "Looking up `#{author_name}/#{permlink}` ..."
+        rescue Discordrb::Errors::NoPermission => _
+          puts "Unable to append link details on #{event.channel.server.name} in #{event.channel.name}"
+          skip_channel event.channel.id
+          return nil
+        end
       end
       
-      post = case chain
-      when :steem then SteemData::Post.where(author: author_name, permlink: permlink).last
-      when :golos then GolosCloud::Comment.where(author: author_name, permlink: permlink).last
+      posts = case chain
+      # when :steem then SteemApi::Comment.where(author: author_name, permlink: permlink)
+      when :hive then HiveSQL::Comment.where(author: author_name, permlink: permlink)
       end
       
+      posts.select(:ID, :created, :cashout_time, :author, :permlink, :active_votes, :children, :category)
+      
+      post = posts.last
+      
       if post.nil?
         # Fall back to RPC
         api(chain).get_content(author_name, permlink) do |content, errors|
           unless content.author.empty?
+            post = content
             created = Time.parse(content.created + 'Z')
             cashout_time = Time.parse(content.cashout_time + 'Z')
           end
         end
       end
       
-      return if post.nil?
+      if post.nil?
+        if !!message
+          message = message.edit 'Looking for content on Hive ...'
+        end
+        
+        # Fall back to Hive RPC
+        api(:hive).get_content(author_name, permlink) do |content, errors|
+          unless content.author.empty?
+            post = content
+            created = Time.parse(content.created + 'Z')
+            cashout_time = Time.parse(content.cashout_time + 'Z')
+          end
+        end
+      end
+      
+      if post.nil?
+        if !!message
+          message = message.edit 'Unable to locate.'
+          sleep 5
+          message.delete
+        end
+        
+        return
+      end
       
       created ||= post.created
       cashout_time ||= post.cashout_time
@@ -105,55 +130,70 @@ module Cosgrove
       age = time_ago_in_words(created)
       age = age.slice(0, 1).capitalize + age.slice(1..-1)
       
-      details << if created < 30.minutes.ago
+      details << if created < 15.minutes.ago
         "#{age} old"
       else
         "**#{age}** old"
       end
+      message = message.edit details.join('; ') if !!message
+      
+      if !!post.category && !!post.category.starts_with?('hive-') && (communities = Cosgrove::FindCommunitiesJob.new.perform(nil, [post.category]), 1).any?
+        details << "in #{communities.first.payload['props']['title']}" rescue nil
+        message = message.edit details.join('; ') if !!message
+      end
+      
+      active_votes = case post.active_votes
+      when String then JSON[post.active_votes] rescue []
+      else; active_votes
+      end
       
-      if post.active_votes.any?
-        upvotes = post.active_votes.map{ |v| v if v['percent'] > 0 }.compact.count
-        downvotes = post.active_votes.map{ |v| v if v['percent'] < 0 }.compact.count
+      if active_votes.respond_to?(:any?) && active_votes.any?
+        upvotes = active_votes.map{ |v| v if v['weight'].to_i > 0 }.compact.count
+        downvotes = active_votes.map{ |v| v if v['weight'].to_i < 0 }.compact.count
         netvotes = upvotes - downvotes
         details << "Net votes: #{netvotes}"
+        message = message.edit details.join('; ') if !!message
         
         # Only append this detail of the post less than an hour old.
         if created > 1.hour.ago
           votes = case chain
-          when :steem then SteemData::AccountOperation.type('vote').starting(post.created)
-          when :golos then GolosCloud::Vote.where('timestamp > ?', post.created)
+          # when :steem then SteemApi::Tx::Vote.where('timestamp > ?', post.created)
+          when :hive then HiveSQL::Tx::Vote.where('timestamp > ?', post.created)
           end
-          total_votes = votes.count
-          total_voters = votes.distinct(:voter).size
+          total_votes = votes.distinct("concat(author, permlink)").count
+          total_voters = votes.distinct(:voter).count
             
           if total_votes > 0 && total_voters > 0
             details << "Out of #{pluralize(total_votes - netvotes, 'vote')} cast by #{pluralize(total_voters, 'voter')}"
+            message = message.edit details.join('; ') if !!message
           end
         end
       end
       
       details << "Comments: #{post.children.to_i}"
+      message = message.edit details.join('; ') if !!message
       
-      page_views = page_views("/#{post.parent_permlink}/@#{post.author}/#{post.permlink}")
-      details << "Views: #{page_views}" if !!page_views
-      
-      begin
-        event.respond details.join('; ')
-      rescue Discordrb::Errors::NoPermission => _
-        puts "Unable to append link details on #{event.channel.server.name} in #{event.channel.name}"
-      end
+      # Page View counter is no longer supported by steemit.com.
+      # page_views = page_views("/#{post.parent_permlink}/@#{post.author}/#{post.permlink}")
+      # details << "Views: #{page_views}" if !!page_views
+      # message = message.edit details.join('; ') if !!message
       
-      return nil
+      details.join('; ') if event.nil?
     end
     
-    def find_account(key, event = nil, chain = :steem)
+    def find_account(key, event = nil, chain = :hive)
       key = key.to_s.downcase
-      chain = chain.to_sym
+      chain ||= :hive
+      chain = chain.to_s.downcase.to_sym
       
-      raise "Required argument: chain" if chain.nil?
       
-      if chain == :steem
-        account = if (accounts = SteemData::Account.where(name: key)).any?
+      case chain
+      # when :steem
+      #   account = if (accounts = SteemApi::Account.where(name: key)).any?
+      #     accounts.first
+      #   end
+      when :hive
+        account = if (accounts = HiveSQL::Account.where(name: key)).any?
           accounts.first
         end
       end
@@ -166,9 +206,9 @@ module Cosgrove
       
       if account.nil?
         account = if !!key
-          if chain == :steem && (accounts = SteemApi::Account.where(name: key)).any?
-            accounts.first
-          elsif chain == :golos && (accounts = GolosCloud::Account.where(name: key)).any?
+          # if chain == :steem && (accounts = SteemApi::Account.where(name: key)).any?
+          #   accounts.first
+          if chain == :hive && (accounts = HiveSQL::Account.where(name: key)).any?
             accounts.first
           else
             # Fall back to RPC
@@ -206,7 +246,7 @@ module Cosgrove
           'Origin' => 'https://steemit.com'
         })
         
-        csrf = page.parser.to_html.split(',"csrf":"').last.split('","new_visit":').first
+        csrf = page.parser.to_html.split(':{"csrf":"').last.split('","new_visit":').first
         # Uncomment in case views stop showing.
         # puts "DEBUG: #{csrf}"
         return unless csrf.size == 36
@@ -223,7 +263,9 @@ module Cosgrove
       end
     end
     
-    def last_irreversible_block(chain = :steem)
+    def last_irreversible_block(chain = :hive)
+      chain ||= :hive
+      chain = chain.to_s.downcase.to_sym
       seconds_ago = (head_block_number(chain) - last_irreversible_block_num(chain)) * 3
       
       "Last Irreversible Block was #{time_ago_in_words(seconds_ago.seconds.ago)} ago."
@@ -242,7 +284,8 @@ module Cosgrove
     def muted(options = {})
       [] if options.empty?
       by = [options[:by]].flatten
-      chain = options[:chain]
+      chain = options[:chain] || :hive
+      chain = chain.to_s.downcase.to_sym
       muted = []
       
       by.each do |a|
@@ -262,5 +305,17 @@ module Cosgrove
       
       muted.uniq
     end
+    
+    def skipped_channels
+      @@skipped_channels ||= []
+    end
+    
+    def skipped_channel?(id)
+      skipped_channels.include? id
+    end
+    
+    def skip_channel(id)
+      skipped_channels << id
+    end
   end
 end

data/lib/cosgrove/upvote_job.rb

@@ -8,28 +8,32 @@ module Cosgrove
       @on_success = options[:on_success]
     end
     
-    def perform(event, slug)
+    def perform(event, slug, chain = :hive)
       if slug.nil? || slug.empty?
         event.respond 'Sorry, I wasn\'t paying attention.'
         return
       end
       
+      chain = chain.to_s.downcase.to_sym
       author_name, permlink = parse_slug slug
       discord_id = event.author.id
       cb_account = Cosgrove::Account.find_by_discord_id(discord_id)
       registered = !!cb_account
       muters = cosgrove_operators
-      muters << steem_account
+      muters << hive_account
       muted = muted by: muters, chain: :steem
       
-      post = find_comment(chain: :steem, author_name: author_name, permlink: permlink)
+      post = find_comment(chain: chain, author_name: author_name, permlink: permlink)
       
       if post.nil?
         cannot_find_input(event)
         return
       end
       
-      votes_today = SteemData::AccountOperation.type('vote').where(voter: steem_account).today
+      votes_today = case chain
+      # when :steem then SteemApi::Tx::Vote.where(voter: steem_account).today
+      when :hive then HiveSQL::Tx::Vote.where(voter: hive_account).today
+      end
       today_count = votes_today.count
       author_count = votes_today.where(author: author_name).count
       vote_ratio = if today_count == 0
@@ -83,7 +87,7 @@ module Cosgrove
         'Unable to vote.  Your account has been resticted.'
       elsif today_count > 10 && vote_ratio > 0.1
         "Maybe later.  It seems like I've been voting for #{author_name} quite a bit lately."
-      elsif active_votes.map{ |v| v['voter'] }.include?(steem_account)
+      elsif active_votes.map{ |v| v['voter'] }.include?(hive_account)
         title = post.title
         title = post.permlink if title.empty?
         "I already voted on #{title} by #{post.author}."
@@ -96,7 +100,7 @@ module Cosgrove
       
       vote = {
         type: :vote,
-        voter: steem_account,
+        voter: hive_account,
         author: post.author,
         permlink: post.permlink,
         weight: upvote_weight(event.channel.id)
@@ -180,13 +184,13 @@ module Cosgrove
       
       case upvote_weight
       when 'dynamic'
-        bot_account = find_account(steem_account)
+        bot_account = find_account(hive_account)
         upvote_weight = bot_account.voting_power.to_i
       when 'upvote_rules'
         upvote_weight = channel_upvote_weight(channel_id)
         
         if upvote_weight == 'dynamic'
-          bot_account = find_account(steem_account)
+          bot_account = find_account(hive_account)
           upvote_weight = bot_account.voting_power.to_i
         else
           upvote_weight = (((upvote_weight || '0.00 %').to_f) * 100).to_i

data/lib/cosgrove/utils.rb

@@ -7,8 +7,8 @@ module Cosgrove
     end
     
     def reset_api
-      @steem_api = @golos_api = @test_api = nil
-      @steem_folow_api = @golos_follow_api = @test_folow_api = nil
+      @steem_api = @hive_api = @test_api = nil
+      @steem_follow_api = @hive_follow_api = @test_follow_api = nil
       @cycle_api_at = nil
     end
     
@@ -28,11 +28,11 @@ module Cosgrove
           url: steem_api_url,
           failover_urls: steem_api_failover_urls.any? ? steem_api_failover_urls : nil
         }
-      when :golos
+      when :hive
         {
-          chain: :golos,
-          url: golos_api_url,
-          failover_urls: golos_api_failover_urls.any? ? golos_api_failover_urls : nil
+          chain: :steem, # TODO switch to :hive when supported by radiator
+          url: hive_api_url,
+          failover_urls: hive_api_failover_urls.any? ? hive_api_failover_urls : nil
         }
       when :test
         {
@@ -50,7 +50,7 @@ module Cosgrove
       
       case chain
       when :steem then @steem_api ||= Radiator::Api.new(chain_options(chain))
-      when :golos then @golos_api ||= Radiator::Api.new(chain_options(chain))
+      when :hive then @hive_api ||= Radiator::Api.new(chain_options(chain))
       when :test then @test_api ||= Radiator::Api.new(chain_options(chain))
       end
     end
@@ -62,18 +62,118 @@ module Cosgrove
       
       case chain
       when :steem then @steem_follow_api ||= Radiator::FollowApi.new(chain_options(chain))
-      when :golos then @golos_follow_api ||= Radiator::FollowApi.new(chain_options(chain))
+      when :hive then @hive_follow_api ||= Radiator::FollowApi.new(chain_options(chain))
       when :test then @test_follow_api ||= Radiator::FollowApi.new(chain_options(chain))
       end
     end
     
+    def steem_engine_shutdown
+      problem = false
+      
+      begin
+        @steem_engine_blockchain.shutdown if !!@steem_engine_blockchain
+      rescue => e
+        puts "Unable to shut down steem engine blockchain rpc: #{e}"
+        problem = true
+      end
+      
+      begin
+        @steem_engine_contracts.shutdown if !!@steem_engine_contracts
+      rescue => e
+        puts "Unable to shut down steem engine contracts rpc: #{e}"
+        problem = true
+      end
+      
+      !problem
+    end
+    
+    def steem_engine(method, params = {}, rpc)
+      begin
+        if params.respond_to?(:empty?) && params.empty?
+          rpc.send(method)
+        else
+          rpc.send(method, params)
+        end
+      rescue => e
+        steem_engine_shutdown
+        
+        raise e
+      end
+    end
+    
+    def steem_engine_blockchain(method, params = {}, &block)
+      @steem_engine_blockchain ||= Radiator::SSC::Blockchain.new(root_url: steem_engine_api_url)
+      result = steem_engine(method, params, @steem_engine_blockchain)
+      
+      yield result if !!block
+      return result
+    end
+    
+    def steem_engine_contracts(method, params = {}, &block)
+      @steem_engine_contracts ||= Radiator::SSC::Contracts.new(root_url: steem_engine_api_url)
+      result = steem_engine(method, params, @steem_engine_contracts)
+      
+      yield result if !!block
+      return result
+    end
+    
+    def hive_engine_shutdown
+      problem = false
+      
+      begin
+        @hive_engine_blockchain.shutdown if !!@hive_engine_blockchain
+      rescue => e
+        puts "Unable to shut down hive engine blockchain rpc: #{e}"
+        problem = true
+      end
+      
+      begin
+        @hive_engine_contracts.shutdown if !!@hive_engine_contracts
+      rescue => e
+        puts "Unable to shut down hive engine contracts rpc: #{e}"
+        problem = true
+      end
+      
+      !problem
+    end
+    
+    def hive_engine(method, params = {}, rpc)
+      begin
+        if params.respond_to?(:empty?) && params.empty?
+          rpc.send(method)
+        else
+          rpc.send(method, params)
+        end
+      rescue => e
+        hive_engine_shutdown
+        
+        raise e
+      end
+    end
+    
+    def hive_engine_blockchain(method, params = {}, &block)
+      @hive_engine_blockchain ||= Radiator::SSC::Blockchain.new(root_url: hive_engine_api_url)
+      result = hive_engine(method, params, @hive_engine_blockchain)
+      
+      yield result if !!block
+      return result
+    end
+    
+    def hive_engine_contracts(method, params = {}, &block)
+      @hive_engine_contracts ||= Radiator::SSC::Contracts.new(root_url: hive_engine_api_url)
+      result = hive_engine(method, params, @hive_engine_contracts)
+      
+      yield result if !!block
+      return result
+    end
+    
     def cycle_stream_at
       @cycle_stream_at if defined? @cycle_stream_at
     end
     
     def reset_stream
-      @steem_stream = @golos_stream = @test_stream = nil
-      @steem_folow_stream = @golos_follow_stream = @test_folow_stream = nil
+      @steem_stream = @hive_stream = @test_stream = nil
+      @steem_follow_stream = @hive_follow_stream = @test_follow_stream = nil
       @cycle_stream_at = nil
     end
     
@@ -84,19 +184,11 @@ module Cosgrove
       
       case chain
       when :steem then @steem_stream ||= Radiator::Stream.new(chain_options(chain))
-      when :golos then @golos_stream ||= Radiator::Stream.new(chain_options(chain))
+      when :hive then @hive_stream ||= Radiator::Stream.new(chain_options(chain))
       when :test then @test_stream ||= Radiator::Stream.new(chain_options(chain))
       end
     end
     
-    def steem_data_head_block_number
-      begin
-        SteemData::AccountOperation.order(timestamp: -1).limit(1).first.block
-      rescue
-        -1
-      end
-    end
-    
     def properties(chain)
       api(chain).get_dynamic_global_properties.result
     end
@@ -105,14 +197,14 @@ module Cosgrove
       properties(chain)['head_block_number']
     end
     
-    def last_irreversible_block_num(chain = :steem)
+    def last_irreversible_block_num(chain = :hive)
       properties(chain)['last_irreversible_block_num']
     end
     
     def new_tx(chain)
       case chain
       when :steem then Radiator::Transaction.new(chain_options(chain).merge(wif: steem_posting_wif))
-      when :golos then Radiator::Transaction.new(chain_options(chain).merge(wif: golos_posting_wif))
+      when :hive then Radiator::Transaction.new(chain_options(chain).merge(wif: hive_posting_wif))
       when :test then Radiator::Transaction.new(chain_options(chain).merge(wif: test_posting_wif))
       end
     end
@@ -136,22 +228,30 @@ module Cosgrove
         slug = slug.split('@').last
         author_name = slug.split('/')[0]
         permlink = slug.split('/')[1..-1].join('/')
+        permlink = permlink.split('#')[0]
         
         [author_name, permlink]
       end
     end
     
-    def find_author_name_permlink(slug)
+    def find_author_name_permlink(slug, chain = :hive)
+      chain = chain.to_s.downcase.to_sym
       op, author_name = slug.split(':')
       author_name, offset = author_name.split(/[\+-]/)
-      author = find_account(author_name)
+      author = find_account(author_name, nil, chain)
       
       offset = offset.to_i
       
       posts = if op == 'latest'
-        SteemData::Post.root_posts.where(author: author.name).order(created: :desc)
+        case chain
+        # when :steem then SteemApi::Comment.where(depth: 0, author: author.name).order(created: :desc)
+        when :hive then HiveSQL::Comment.where(depth: 0, author: author.name).order(created: :desc)
+        end
       elsif op == 'first'
-        SteemData::Post.root_posts.where(author: author.name).order(created: :asc)
+        case chain
+        # when :steem then SteemApi::Comment.where(depth: 0, author: author.name).order(created: :asc)
+        when :hive then HiveSQL::Comment.where(depth: 0, author: author.name).order(created: :asc)
+        end
       else
         []
       end
@@ -163,19 +263,28 @@ module Cosgrove
       []
     end
     
-    def find_comment_by_slug(slug)
+    def find_comment_by_slug(slug, chain = :hive)
+      chain ||= :hive
+      chain = chain.to_s.downcase.to_sym
       author_name, permlink = parse_slug slug
-      find_comment(chain: :steem, author_name: author_name, permlink: permlink)
+      find_comment(chain: chain, author_name: author_name, permlink: permlink)
     end
     
     def find_comment(options)
       chain = options[:chain] || :steem
+      chain = chain.to_s.downcase.to_sym
       author_name = options[:author_name]
       permlink = options[:permlink]
       parent_permlink = options[:parent_permlink]
       
-      post = if chain == :steem
-        posts = SteemData::Post.root_posts.where(author: author_name)
+      post = if chain == :hive
+        # posts = SteemApi::Comment.where(depth: 0, author: author_name)
+        posts = posts.where(permlink: permlink) if !!permlink
+        posts = posts.where(parent_permlink: parent_permlink) if !!parent_permlink
+        
+        posts.first
+      elsif chain == :hive
+        posts = HiveSQL::Comment.where(depth: 0, author: author_name)
         posts = posts.where(permlink: permlink) if !!permlink
         posts = posts.where(parent_permlink: parent_permlink) if !!parent_permlink
         
@@ -185,13 +294,13 @@ module Cosgrove
       if post.nil?
         post = case chain
         when :steem
-          posts = SteemApi::Comment.where(author: author_name)
+          # posts = SteemApi::Comment.where(author: author_name)
           posts = posts.where(permlink: permlink) if !!permlink
           posts = posts.where(parent_permlink: parent_permlink) if !!parent_permlink
           
           posts.first
-        when :golos
-          posts = GolosCloud::Comment.where(author: author_name)
+        when :hive
+          posts = HiveSQL::Comment.where(author: author_name)
           posts = posts.where(permlink: permlink) if !!permlink
           posts = posts.where(parent_permlink: parent_permlink) if !!parent_permlink
           
@@ -212,22 +321,18 @@ module Cosgrove
     end
     
     def find_author(options)
-      chain = options[:chain]
+      chain = options[:chain] || :steem
+      chain = chain.to_s.downcase.to_sym
       author_name = options[:author_name]
       
-      author = SteemData::Account.where(name: author_name).last
-      
-      if author.nil?
-        author = begin
-          SteemApi::Account.where(name: author_name).last
-        rescue => e
-          puts e
-        end
+      author = case chain
+      # when :steem then SteemApi::Account.where(name: author_name).first
+      when :hive then HiveSQL::Account.where(name: author_name).first
       end
       
       if author.nil?
         author = api(chain).get_accounts([author_name]) do |accounts, errors|
-          accounts.last
+          accounts.first
         end
       end
       
@@ -241,30 +346,39 @@ module Cosgrove
       memo_key = options[:memo].to_s.strip
       
       op = case chain
-      when :steem
-        transfers = SteemData::AccountOperation.type('transfer').
-          where(account: steem_account, from: from, to: steem_account, memo: {'$regex' => ".*#{memo_key}.*"})
+      # when :steem
+      #   transfers = SteemApi::Tx::Transfer.
+      #     where(from: from, to: steem_account).
+      #     where("memo LIKE ?", "%#{memo_key}%")
+      # 
+      #   if transfers.any?
+      #     transfers.last
+      #   else
+      #     SteemApi::Tx::Transfer.
+      #       where(from: from).
+      #       where(to: to).
+      #       where("memo LIKE ?", "%#{memo_key}%").last
+      #   end
+      when :hive
+        transfers = HiveSQL::Tx::Transfer.
+          where(from: from, to: hive_account).
+          where("memo LIKE ?", "%#{memo_key}%")
       
         if transfers.any?
           transfers.last
         else
-          SteemApi::Tx::Transfer.
+          HiveSQL::Tx::Transfer.
             where(from: from).
             where(to: to).
             where("memo LIKE ?", "%#{memo_key}%").last
         end
-      when :golos
-        GolosCloud::Tx::Transfer.
-          where(from: from).
-          where(to: to).
-          where("memo LIKE ?", "%#{memo_key}%").last
       end
       
       if op.nil?
-        # Fall back to RPC.  The transaction is so new, SteemData hasn't seen it
-        # yet, SteemData is behind, or there is no such transfer.
+        # Fall back to RPC.  The transaction is so new, SteemApi hasn't seen it
+        # yet, SteemApi is behind, or there is no such transfer.
         
-        api(chain).get_account_history(steem_account, -1, 10000) do |history, error|
+        api(chain).get_account_history(hive_account, -1, 10000) do |history, error|
           if !!error
             ap error
             return "Try again later."
@@ -276,7 +390,7 @@ module Cosgrove
             next unless type == 'transfer'
             o = e.last
             next unless o.from == from
-            next unless o.to == steem_account
+            next unless o.to == hive_account
             next unless o.memo =~ /.*#{memo_key}.*/
             
             o
@@ -287,20 +401,31 @@ module Cosgrove
       op
     end
     
-    def core_asset(chain = :steem)
+    def core_asset(chain = :hive)
+      chain ||= :hive
+      chain = chain.to_s.downcase.to_sym
+      
       case chain
       when :steem then 'STEEM'
-      when :golos then 'GOLOS'
+      when :hive then 'HIVE'
       else; 'TESTS'
       end
     end
     
-    def debt_asset(chain = :steem)
+    def debt_asset(chain = :hive)
+      chain ||= :hive
+      chain = chain.to_s.downcase.to_sym
+      
       case chain
       when :steem then 'SBD'
-      when :golos then 'GBG'
+      when :hive then 'HBD'
       else; 'TBD'
       end
     end
+  private
+    def rpc_id
+      @rpc_id ||= 0
+      @rpc_id += 1
+    end
   end
 end