steem-ruby 0.9.0 → 0.9.5

data/lib/steem/base_error.rb

@@ -1,153 +1,185 @@
 module Steem
   class BaseError < StandardError
-    def initialize(error, cause = nil)
+    def initialize(error = nil, cause = nil)
       @error = error
       @cause = cause
     end
     
     def to_s
-      if !!@cause
-        JSON[error: @error, cause: @cause] rescue {error: @error, cause: @cause}.to_s
-      else
-        JSON[@error] rescue @error.to_s
-      end
+      detail = {}
+      detail[:error] = @error if !!@error
+      detail[:cause] = @cause if !!@cause
+      
+      JSON[detail] rescue detail.to_s
     end
     
     def self.build_error(error, context)
       if error.message == 'Unable to acquire database lock'
-        raise Steem::RemoteDatabaseLockError, error.message, JSON.pretty_generate(error)
+        raise Steem::RemoteDatabaseLockError, error.message, build_backtrace(error)
       end
       
       if error.message.include? 'Internal Error'
-        raise Steem::RemoteNodeError.new, error.message, JSON.pretty_generate(error)
+        raise Steem::RemoteNodeError, error.message, build_backtrace(error)
+      end
+      
+      if error.message.include? 'Server error'
+        raise Steem::RemoteNodeError, error.message, build_backtrace(error)
       end
       
       if error.message.include? 'plugin not enabled'
-        raise Steem::PluginNotEnabledError, error.message, JSON.pretty_generate(error)
+        raise Steem::PluginNotEnabledError, error.message, build_backtrace(error)
       end
       
       if error.message.include? 'argument'
-        raise Steem::ArgumentError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Invalid params'
+        raise Steem::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.start_with? 'Bad Cast:'
-        raise Steem::ArgumentError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'prefix_len'
-        raise Steem::ArgumentError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'Parse Error'
-        raise Steem::ArgumentError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'unknown key'
-        raise Steem::ArgumentError, "#{context}: #{error.message} (or content has been deleted)", JSON.pretty_generate(error)
+        raise Steem::ArgumentError, "#{context}: #{error.message} (or content has been deleted)", build_backtrace(error)
       end
       
       if error.message.include? 'Comment is not in account\'s comments'
-        raise Steem::ArgumentError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'Could not find comment'
-        raise Steem::ArgumentError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'unable to convert ISO-formatted string to fc::time_point_sec'
-        raise Steem::ArgumentError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'Input data have to treated as object.'
-        raise Steem::ArgumentError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'base.amount > share_type(0)'
+        raise Steem::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'blk->transactions.size() > itr->trx_in_block'
-        raise Steem::VirtualOperationsNotAllowedError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::VirtualOperationsNotAllowedError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'A transaction must have at least one operation'
-        raise Steem::EmptyTransactionError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::EmptyTransactionError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'transaction expiration exception'
-        raise Steem::TransactionExpiredError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::TransactionExpiredError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'Duplicate transaction check failed'
-        raise Steem::DuplicateTransactionError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::DuplicateTransactionError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'signature is not canonical'
-        raise Steem::NonCanonicalSignatureError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::NonCanonicalSignatureError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'attempting to push a block that is too old'
-        raise Steem::BlockTooOldError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::BlockTooOldError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'irrelevant signature'
-        raise Steem::IrrelevantSignatureError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::IrrelevantSignatureError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'missing required posting authority'
-        raise Steem::MissingPostingAuthorityError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::MissingPostingAuthorityError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'missing required active authority'
-        raise Steem::MissingActiveAuthorityError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::MissingActiveAuthorityError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'missing required owner authority'
-        raise Steem::MissingOwnerAuthorityError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::MissingOwnerAuthorityError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'missing required other authority'
-        raise Steem::MissingOtherAuthorityError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::MissingOtherAuthorityError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Upstream response error'
+        raise Steem::UpstreamResponseError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Bad or missing upstream response'
+        raise Steem::BadOrMissingUpstreamResponseError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'operator has disabled operation indexing by transaction_id'
-        raise Steem::TransactionIndexDisabledError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::TransactionIndexDisabledError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'is_valid_account_name'
-        raise Steem::InvalidAccountError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::InvalidAccountError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include?('Method') && error.message.include?(' does not exist.')
+        raise Steem::UnknownMethodError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'Invalid operation name'
-        raise Steem::UnknownOperationError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::UnknownOperationError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message =~ /Invalid object name: .+_operation/
+        raise Steem::UnknownOperationError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'Author not found'
-        raise Steem::AuthorNotFoundError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::AuthorNotFoundError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? ' != fc::time_point_sec::maximum()'
-        raise Steem::ReachedMaximumTimeError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::ReachedMaximumTimeError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'Cannot transfer a negative amount (aka: stealing)'
-        raise Steem::TheftError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::TheftError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'Must transfer a nonzero amount'
-        raise Steem::NonZeroRequiredError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::NonZeroRequiredError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       if error.message.include? 'is_asset_type'
-        raise Steem::UnexpectedAssetError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+        raise Steem::UnexpectedAssetError, "#{context}: #{error.message}", build_backtrace(error)
       end
       
       puts JSON.pretty_generate(error) if ENV['DEBUG']
-      raise UnknownError, "#{context}: #{error.message}", JSON.pretty_generate(error)
+      raise UnknownError, "#{context}: #{error.message}", build_backtrace(error)
+    end
+  private
+    def self.build_backtrace(error)
+      backtrace = Thread.current.backtrace.reject{ |line| line =~ /base_error/ }
+      JSON.pretty_generate(error) + "\n" + backtrace.join("\n")
     end
   end
   
+  class DeserializationError < BaseError; end
+  class SerializationMismatchError < BaseError; end
   class UnsupportedChainError < BaseError; end
   class ArgumentError < BaseError; end
-  class RemoteNodeError < BaseError; end
-  class RemoteDatabaseLockError < RemoteNodeError; end
-  class PluginNotEnabledError < RemoteNodeError; end
   class TypeError < BaseError; end
   class EmptyTransactionError < ArgumentError; end
   class InvalidAccountError < ArgumentError; end
@@ -169,11 +201,18 @@ module Steem
   class MissingOtherAuthorityError < MissingAuthorityError; end
   class IncorrectRequestIdError < BaseError; end
   class IncorrectResponseIdError < BaseError; end
+  class RemoteNodeError < BaseError; end
+  class UpstreamResponseError < RemoteNodeError; end
+  class RemoteDatabaseLockError < UpstreamResponseError; end
+  class PluginNotEnabledError < UpstreamResponseError; end
+  class BadOrMissingUpstreamResponseError < UpstreamResponseError; end
   class TransactionIndexDisabledError < BaseError; end
   class NotAppBaseError < BaseError; end
   class UnknownApiError < BaseError; end
+  class UnknownMethodError < BaseError; end
   class UnknownOperationError < BaseError; end
   class JsonRpcBatchMaximumSizeExceededError < BaseError; end
   class TooManyTimeoutsError < BaseError; end
+  class TooManyRetriesError < BaseError; end
   class UnknownError < BaseError; end
 end

data/lib/steem/block_api.rb

@@ -12,11 +12,25 @@ module Steem
       super
     end
     
+    # Uses a batched requst on a range of block headers.
+    #
+    # @param options [Hash] The attributes to get a block range with.
+    # @option options [Range] :block_range starting on one block number and ending on an higher block number.
+    def get_block_headers(options = {block_range: (0..0)}, &block)
+      get_block_objects(options.merge(object: :block_header), block)
+    end
+    
     # Uses a batched requst on a range of blocks.
     #
     # @param options [Hash] The attributes to get a block range with.
     # @option options [Range] :block_range starting on one block number and ending on an higher block number.
     def get_blocks(options = {block_range: (0..0)}, &block)
+      get_block_objects(options.merge(object: :block), block)
+    end
+  private
+    def get_block_objects(options = {block_range: (0..0)}, block = nil)
+      object = options[:object]
+      object_method = "get_#{object}".to_sym
       block_range = options[:block_range] || (0..0)
       
       if (start = block_range.first) < 1
@@ -33,15 +47,21 @@ module Steem
         request_object = []
         
         for i in sub_range do
-          @rpc_client.put(self.class.api_name, :get_block, block_num: i, request_object: request_object)
+          @rpc_client.put(self.class.api_name, object_method, block_num: i, request_object: request_object)
         end
         
         if !!block
           index = 0
           @rpc_client.rpc_batch_execute(request_object: request_object) do |result, error, id|
             block_num = sub_range.to_a[index]
-            index = index += 1
-            yield(result.nil? ? nil : result.block, block_num)
+            index = index + 1
+            
+            case object
+            when :block_header
+              block.call(result.nil? ? nil : result[:header], block_num)
+            else
+              block.call(result.nil? ? nil : result[object], block_num)
+            end
           end
         else
           blocks = []

data/lib/steem/broadcast.rb

@@ -31,8 +31,9 @@ module Steem
   # For details on what to pass to these methods, check out the {https://developers.steem.io/apidefinitions/broadcast-ops Steem Developer Portal Broadcast Operations} page.
   class Broadcast
     extend Retriable
+    extend Utils
     
-    DEFAULT_MAX_ACCEPTED_PAYOUT = Type::Amount.new(["1000000000", 3, "@@000000013"])
+    DEFAULT_MAX_ACCEPTED_PAYOUT = Type::Amount.new(amount: '1000000000', precision: 3, nai: '@@000000013')
     
     # This operation is used to cast a vote on a post/comment.
     # 
@@ -69,6 +70,58 @@ module Steem
       process(options.merge(ops: ops), &block)
     end
     
+    # This operation is used to cast a vote on a post/comment using multiple votable assets.
+    # 
+    #     options = {
+    #       wif: wif,
+    #       params: {
+    #         voter: voter,
+    #         author: author,
+    #         permlink: permlink,
+    #         TODO
+    #       }
+    #     }
+    #     
+    #     Steem::Broadcast.vote2(options) do |result|
+    #       puts result
+    #     end
+    #
+    # @param options [Hash] options
+    # @option options [String] :wif Posting wif
+    # @option options [Hash] :params
+    #   * :voter (String)
+    #   * :author (String)
+    #   * :permlink (String)
+    #   * :rshares (Array)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_vote
+    def self.vote2(options, &block)
+      required_fields = %i(voter author permlink rshares)
+      params = options[:params]
+      check_required_fields(params, *required_fields)
+      
+      ops = [[:vote2, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+    
+    # @param options [Hash] options
+    # @option options [String] :wif Posting wif
+    # @option options [Hash] :params
+    #   * :account (String)
+    #   * :reward_tokens (Array)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_vote
+    def self.claim_reward_balance2(options, &block)
+      required_fields = %i(account reward_tokens)
+      params = options[:params]
+      check_required_fields(params, *required_fields)
+      
+      ops = [[:claim_reward_balance2, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+    
     # Creates a post/comment.  This method simplifies content creation by
     # combining `comment` and `comment_options` into one transaction.
     #
@@ -174,9 +227,9 @@ module Steem
       }]]
       
       max_accepted_payout = if params.keys.include? :max_accepted_payout
-        Type::Amount.to_nia(params[:max_accepted_payout])
+        normalize_amount(options.merge amount: params[:max_accepted_payout])
       else
-        DEFAULT_MAX_ACCEPTED_PAYOUT.to_nia
+        normalize_amount(options.merge amount: DEFAULT_MAX_ACCEPTED_PAYOUT)
       end
       
       allow_votes = if params.keys.include? :allow_votes
@@ -196,13 +249,17 @@ module Steem
         permlink: params[:permlink],
         max_accepted_payout: max_accepted_payout,
         percent_steem_dollars: params[:percent_steem_dollars] || 10000,
+        # allow_replies: allow_replies,
         allow_votes: allow_votes,
         allow_curation_rewards: allow_curation_rewards,
         extensions: []
       }
       
       if !!params[:beneficiaries]
-        comment_options[:extensions] << [0, {beneficiaries: params[:beneficiaries]}]
+        comment_options[:extensions] << [
+          comment_options[:extensions].size,
+          normalize_beneficiaries(options.merge(beneficiaries: params[:beneficiaries]))
+        ]
       end
       
       ops << [:comment_options, comment_options]
@@ -274,7 +331,7 @@ module Steem
       params = options[:params]
       check_required_fields(params, *required_fields)
       
-      params[:amount] = Type::Amount.to_nia(params[:amount])
+      params[:amount] = normalize_amount(options.merge amount: params[:amount])
       
       ops = [[:transfer, params]]
       
@@ -310,7 +367,7 @@ module Steem
       params = options[:params]
       check_required_fields(params, *required_fields)
       
-      params[:amount] = Type::Amount.to_nia(params[:amount])
+      params[:amount] = normalize_amount(options.merge amount: params[:amount])
       
       ops = [[:transfer_to_vesting, params]]
       
@@ -336,7 +393,7 @@ module Steem
       params = options[:params]
       check_required_fields(params, *required_fields)
       
-      params[:vesting_shares] = Type::Amount.to_nia(params[:vesting_shares])
+      params[:vesting_shares] = normalize_amount(options.merge amount: params[:vesting_shares])
       
       ops = [[:withdraw_vesting, params]]
       
@@ -363,8 +420,8 @@ module Steem
       params = options[:params]
       check_required_fields(params, *required_fields)
       
-      params[:amount_to_sell] = Type::Amount.to_nia(params[:amount_to_sell])
-      params[:min_to_receive] = Type::Amount.to_nia(params[:min_to_receive])
+      params[:amount_to_sell] = normalize_amount(options.merge amount: params[:amount_to_sell])
+      params[:min_to_receive] = normalize_amount(options.merge amount: params[:min_to_receive])
       
       if !!params[:expiration]
         params[:expiration] = Time.parse(params[:expiration].to_s)
@@ -376,6 +433,42 @@ module Steem
       process(options.merge(ops: ops), &block)
     end
     
+    # This operation creates a limit order and matches it against existing open
+    # orders.
+    # 
+    # @param options [Hash] options
+    # @option options [String] :wif Active wif
+    # @option options [Hash] :params
+    #   * :owner (String)
+    #   * :orderid (String)
+    #   * :amount_to_sell (String)
+    #   * :exchange_rate (Hash)
+    #   * :fill_or_kill (Boolean)
+    #   * :expiration (String)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_limit_order_create2
+    def self.limit_order_create2(options, &block)
+      required_fields = %i(owner orderid amount_to_sell exchange_rate
+        fill_or_kill)
+      params = options[:params]
+      check_required_fields(params, *required_fields)
+      
+      params[:amount_to_sell] = normalize_amount(options.merge amount: params[:amount_to_sell])
+      params[:exchange_rate] = {
+        base: normalize_amount(options.merge amount: params[:exchange_rate][:base]),
+        quote: normalize_amount(options.merge amount: params[:exchange_rate][:quote])
+      }
+      
+      if !!params[:expiration]
+        params[:expiration] = Time.parse(params[:expiration].to_s)
+        params[:expiration] = params[:expiration].strftime('%Y-%m-%dT%H:%M:%S')
+      end
+      
+      ops = [[:limit_order_create2, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+    
     # Cancels an order and returns the balance to owner.
     # 
     # @param options [Hash] options
@@ -414,8 +507,8 @@ module Steem
       exchange_rate = params[:exchange_rate] rescue nil || {}
       base = exchange_rate[:base]
       quote = exchange_rate[:quote]
-      params[:exchange_rate][:base] = Type::Amount.to_nia(base)
-      params[:exchange_rate][:quote] = Type::Amount.to_nia(quote)
+      params[:exchange_rate][:base] = normalize_amount(options.merge amount: base)
+      params[:exchange_rate][:quote] = normalize_amount(options.merge amount: quote)
       
       ops = [[:feed_publish, params]]
       
@@ -438,7 +531,7 @@ module Steem
       params = options[:params]
       check_required_fields(params, *required_fields)
       
-      params[:amount] = Type::Amount.to_nia(params[:amount])
+      params[:amount] = normalize_amount(options.merge amount: params[:amount])
       
       ops = [[:convert, params]]
       
@@ -502,13 +595,75 @@ module Steem
       
       check_required_fields(params, *required_fields)
       
-      params[:fee] = Type::Amount.to_nia(params[:fee])
+      params[:fee] = normalize_amount(options.merge amount: params[:fee])
       
       ops = [[:account_create, params]]
       
       process(options.merge(ops: ops), &block)
     end
     
+    # Create a claimed account.
+    #     options = {
+    #       wif: wif,
+    #       params: {
+    #         creator: creator_account_name,
+    #         new_account_name: new_account_name,
+    #         owner: {
+    #           weight_threshold: 1,
+    #           account_auths: [],
+    #           key_auths: [[owner_public_key, 1]],
+    #         },
+    #         active: {
+    #           weight_threshold: 1,
+    #           account_auths: [],
+    #           key_auths: [[active_public_key, 1]],
+    #         },
+    #         posting: {
+    #           weight_threshold: 1,
+    #           account_auths: [],
+    #           key_auths: [[posting_public_key, 1]],
+    #         },
+    #         memo_key: memo_public_key,
+    #         json_metadata: '{}'
+    #       }
+    #     }
+    # 
+    #     Steem::Broadcast.create_claimed_account(options)
+    # 
+    # @param options [Hash] options
+    # @option options [String] :wif Active wif
+    # @option options [Hash] :params
+    #   * :creator (String)
+    #   * :new_account_name (String)
+    #   * :owner (Hash)
+    #   * :active (Hash)
+    #   * :posting (Hash)
+    #   * :memo_key (String)
+    #   * :metadata (Hash) Metadata of the account, becomes `json_metadata`.
+    #   * :json_metadata (String) String version of `metadata` (use one or the other).
+    #   * :extensions (Array) (optional)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_create_claimed_account
+    def self.create_claimed_account(options, &block)
+      required_fields = %i(creator new_account_name owner active posting memo_key json_metadata)
+      params = options[:params]
+      
+      if !!params[:metadata] && !!params[:json_metadata]
+        raise Steem::ArgumentError, 'Assign either metadata or json_metadata, not both.'
+      end
+      
+      metadata = params.delete(:metadata) || {}
+      metadata ||= (JSON[params[:json_metadata]] || nil) || {}
+      params[:json_metadata] = metadata.to_json
+      
+      check_required_fields(params, *required_fields)
+      
+      params[:extensions] ||= []
+      ops = [[:create_claimed_account, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+    
     # Update an account.
     #     options = {
     #       wif: wif,
@@ -603,14 +758,81 @@ module Steem
       check_required_fields(params, *required_fields)
       
       account_creation_fee = params[:props][:account_creation_fee] rescue nil
-      params[:props][:account_creation_fee] = Type::Amount.to_nia(account_creation_fee)
-      params[:fee] = Type::Amount.to_nia(params[:fee])
+      params[:props][:account_creation_fee] = normalize_amount(options.merge amount: account_creation_fee)
+      params[:fee] = normalize_amount(options.merge amount: params[:fee])
       
       ops = [[:witness_update, params]]
       
       process(options.merge(ops: ops), &block)
     end
     
+    # Extensible replacement for #witness_update that supports additional
+    # properties added since HF20 and beyond.
+    #
+    #     options = {
+    #       wif: wif,
+    #       params: {
+    #         owner: witness_account_name,
+    #         props: {
+    #           account_creation_fee: '0.000 STEEM',
+    #           maximum_block_size: 131072,
+    #           sbd_interest_rate: 1000,
+    #           account_subsidy_budget: 50000,
+    #           account_subsidy_decay: 330782,
+    #           sbd_exchange_rate: '1.000 STEEM',
+    #           url: "https://steemit.com",
+    #           new_signing_key: 'STM8LoQjQqJHvotqBo7HjnqmUbFW9oJ2theyqonzUd9DdJ7YYHsvD'
+    #         }
+    #       }
+    #     }
+    # 
+    #     Steem::Broadcast.witness_set_properties(options)
+    #
+    # @param options [Hash] options
+    # @option options [String] :wif Active wif
+    # @option options [Hash] :params
+    #   * :owner (String)
+    #   * :props (String)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_witness_set_properties
+    # @see https://github.com/steemit/steem/blob/master/doc/witness_parameters.md
+    def self.witness_set_properties(options, &block)
+      required_fields = %i(owner props)
+      params = options[:params]
+      check_required_fields(params, *required_fields)
+      
+      if !!(account_creation_fee = params[:props][:account_creation_fee] rescue nil)
+        params[:props][:account_creation_fee] = normalize_amount(options.merge amount: account_creation_fee, serialize: true)
+      end
+      
+      if !!(sbd_exchange_rate = params[:props][:sbd_exchange_rate] rescue nil)
+        params[:props][:sbd_exchange_rate][:base] = normalize_amount(options.merge amount: sbd_exchange_rate[:base], serialize: true)
+        params[:props][:sbd_exchange_rate][:quote] = normalize_amount(options.merge amount: sbd_exchange_rate[:quote], serialize: true)
+        params[:props][:sbd_exchange_rate] = params[:props][:sbd_exchange_rate].to_json
+      end
+      
+      %i(key new_signing_key).each do |key|
+        if !!params[key] && params[key].size == 53
+          params[key] = params[key][3..-1]
+        end
+      end
+      
+      %i(account_creation_fee sbd_exchange_rate url new_signing_key).each do |key|
+        next unless !!params[:props][key]
+        
+        val = params[:props][key].to_s
+          
+        params[:props][key] = hexlify val unless val =~ /^[0-9A-F]+$/i
+      end
+      
+      params[:props] = params[:props].to_a
+      
+      params[:extensions] ||= []
+      ops = [[:witness_set_properties, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+    
     # All accounts with a VFS (Vesting Fund Shares) can vote for or against any
     # witness.
     # 
@@ -844,9 +1066,9 @@ module Steem
       
       check_required_fields(params, *required_fields)
       
-      params[:sbd_amount] = Type::Amount.to_nia(params[:sbd_amount])
-      params[:steem_amount] = Type::Amount.to_nia(params[:steem_amount])
-      params[:fee] = Type::Amount.to_nia(params[:fee])
+      params[:sbd_amount] = normalize_amount(options.merge amount: params[:sbd_amount])
+      params[:steem_amount] = normalize_amount(options.merge amount: params[:steem_amount])
+      params[:fee] = normalize_amount(options.merge amount: params[:fee])
       
       params[:ratification_deadline] = Time.parse(params[:ratification_deadline].to_s)
       params[:ratification_deadline] = params[:ratification_deadline].strftime('%Y-%m-%dT%H:%M:%S')
@@ -905,8 +1127,8 @@ module Steem
       params = options[:params]
       check_required_fields(params, *required_fields)
       
-      params[:sbd_amount] = Type::Amount.to_nia(params[:sbd_amount])
-      params[:steem_amount] = Type::Amount.to_nia(params[:steem_amount])
+      params[:sbd_amount] = normalize_amount(options.merge amount: params[:sbd_amount])
+      params[:steem_amount] = normalize_amount(options.merge amount: params[:steem_amount])
 
       ops = [[:escrow_release, params]]
       
@@ -954,7 +1176,7 @@ module Steem
       check_required_fields(params, *required_fields)
       
       params[:memo] ||= ''
-      params[:amount] = Type::Amount.to_nia(params[:amount])
+      params[:amount] = normalize_amount(options.merge amount: params[:amount])
 
       ops = [[:transfer_to_savings, params]]
       
@@ -977,7 +1199,7 @@ module Steem
       check_required_fields(params, *required_fields)
       
       params[:memo] ||= ''
-      params[:amount] = Type::Amount.to_nia(params[:amount])
+      params[:amount] = normalize_amount(options.merge amount: params[:amount])
 
       ops = [[:transfer_from_savings, params]]
       
@@ -1039,7 +1261,7 @@ module Steem
       params = options[:params]
       check_required_fields(params, *required_fields)
       
-      params[:vesting_shares] = Type::Amount.to_nia(params[:vesting_shares])
+      params[:vesting_shares] = normalize_amount(options.merge amount: params[:vesting_shares])
       ops = [[:delegate_vesting_shares, params]]
       
       process(options.merge(ops: ops), &block)
@@ -1075,8 +1297,8 @@ module Steem
       
       check_required_fields(params, *required_fields)
       
-      params[:fee] = Type::Amount.to_nia(params[:fee])
-      params[:delegation] = Type::Amount.to_nia(params[:delegation])
+      params[:fee] = normalize_amount(options.merge amount: params[:fee])
+      params[:delegation] = normalize_amount(options.merge amount: params[:delegation])
       params[:extensions] ||= []
       
       ops = [[:account_create_with_delegation, params]]
@@ -1084,6 +1306,188 @@ module Steem
       process(options.merge(ops: ops), &block)
     end
     
+    # @param options [Hash] options
+    # @option options [String] :wif Active wif
+    # @option options [Hash] :params
+    #   * :creator (String)
+    #   * :fee (String)
+    #   * :extensions (Array)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_claim_account
+    def self.claim_account(options, &block)
+      required_fields = %i(creator fee)
+      params = options[:params]
+      
+      check_required_fields(params, *required_fields)
+      
+      params[:fee] = normalize_amount(options.merge amount: params[:fee])
+      params[:extensions] ||= []
+      
+      ops = [[:claim_account, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+        
+    # @param options [Hash] options
+    # @option options [String] :wif Active wif
+    # @option options [Hash] :params
+    #   * :control_account (String)
+    #   * :symbol (Hash)
+    #   * :smt_creation_fee (Hash)
+    #   * :precision (Integer)
+    #   * :extensions (Array)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_smt_create
+    def self.smt_create(options, &block)
+      required_fields = %i(control_account symbol smt_creation_fee precision)
+      params = options[:params]
+      
+      check_required_fields(params, *required_fields)
+      
+      params[:smt_creation_fee] = normalize_amount(options.merge amount: params[:smt_creation_fee])
+      params[:extensions] ||= []
+      
+      ops = [[:smt_create, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+        
+    # @param options [Hash] options
+    # @option options [String] :wif Active wif
+    # @option options [Hash] :params
+    #   * :control_account (String)
+    #   * :symbol (Hash)
+    #   * :contribution_begin_time (String)
+    #   * :contribution_end_time (String)
+    #   * :launch_time max_supply (String)
+    #   * :steem_units_hard_cap (Integer)
+    #   * :steem_units_soft_cap (Integer)
+    #   * :steem_units_min (Integer)
+    #   * initial_generation_policy (String)
+    #   * :extensions (Array)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_smt_create
+    def self.smt_setup(options, &block)
+      required_fields = %i(control_account symbol contribution_begin_time contribution_end_time launch_time max_supply steem_units_hard_cap steem_units_soft_cap steem_units_min initial_generation_policy)
+      params = options[:params]
+      
+      check_required_fields(params, *required_fields)
+      
+      params[:extensions] ||= []
+      
+      ops = [[:smt_setup, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+    
+    # @param options [Hash] options
+    # @option options [String] :wif Active wif
+    # @option options [Hash] :params
+    #   * :control_account (String)
+    #   * :symbol (Hash)
+    #   * :setup_parameters (Array)
+    #   * :extensions (Array)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_smt_create
+    def self.smt_set_setup_parameters(options, &block)
+      required_fields = %i(control_account symbol setup_parameters)
+      params = options[:params]
+      
+      check_required_fields(params, *required_fields)
+      
+      params[:extensions] ||= []
+      
+      ops = [[:smt_set_setup_parameters, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+    
+    # @param options [Hash] options
+    # @option options [String] :wif Active wif
+    # @option options [Hash] :params
+    #   * :control_account (String)
+    #   * :symbol (Hash)
+    #   * :runtime_parameters (Array)
+    #   * :extensions (Array)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_smt_create
+    def self.smt_set_runtime_parameters(options, &block)
+      required_fields = %i(control_account symbol runtime_parameters)
+      params = options[:params]
+      
+      check_required_fields(params, *required_fields)
+      
+      params[:extensions] ||= []
+      
+      ops = [[:smt_set_runtime_parameters, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+        
+    # @param options [Hash] options
+    # @option options [String] :wif Active wif
+    # @option options [Hash] :params
+    #   * :control_account (String)
+    #   * :symbol (Hash)
+    #   * :extensions (Array)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_smt_create
+    def self.smt_setup_emissions(options, &block)
+      required_fields = %i(control_account symbol schedule_time emissions_unit interval_seconds interval_count lep_time rep_time lep_abs_amount rep_abs_amount lep_rel_amount_numerator rep_rel_amount_numerator rel_amount_denom_bits remove floor_emissions)
+      params = options[:params]
+      
+      check_required_fields(params, *required_fields)
+      
+      params[:extensions] ||= []
+      
+      ops = [[:smt_setup_emissions, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+        
+    # @param options [Hash] options
+    # @option options [String] :wif Active wif
+    # @option options [Hash] :params
+    #   * :control_account (String)
+    #   * :symbol (Hash)
+    #   * :extensions (Array)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_smt_create
+    def self.smt_contribute(options, &block)
+      required_fields = %i(contributor symbol contribution_id contribution)
+      params = options[:params]
+      
+      check_required_fields(params, *required_fields)
+      
+      params[:extensions] ||= []
+      
+      ops = [[:smt_contribute, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+        
+    # @param options [Hash] options
+    # @option options [String] :wif Active wif
+    # @option options [Hash] :params
+    #   * :from_account (String)
+    #   * :to_pool (String)
+    #   * :amount (Hash)
+    #   * :extensions (Array)
+    # @option options [Boolean] :pretend Just validate, do not broadcast.
+    # @see https://developers.steem.io/apidefinitions/broadcast-ops#broadcast_ops_smt_create
+    def self.delegate_to_pool(options, &block)
+      required_fields = %i(from_account to_pool amount)
+      params = options[:params]
+      
+      check_required_fields(params, *required_fields)
+      
+      params[:extensions] ||= []
+      
+      ops = [[:delegate_to_pool, params]]
+      
+      process(options.merge(ops: ops), &block)
+    end
+        
     # @param options [Hash] options
     # @option options [Array<Array<Hash>] :ops Operations to process.
     # @option options [Boolean] :pretend Just validate, do not broadcast.
@@ -1097,9 +1501,17 @@ module Steem
         trx = tx.transaction
         
         response = if !!options[:pretend]
-          database_api(options).verify_authority(trx: trx)
+          if !!options[:app_base]
+            database_api(options).verify_authority(trx: trx)
+          else
+            database_api(options).verify_authority(trx)
+          end
         else
-          network_broadcast_api(options).broadcast_transaction_synchronous(trx: trx)
+          if !!options[:app_base]
+            network_broadcast_api(options).broadcast_transaction(trx: trx)
+          else
+            network_broadcast_api(options).broadcast_transaction_synchronous(trx)
+          end
         end
         
         break
@@ -1119,14 +1531,38 @@ module Steem
       end
     end
   private
+    # @private
+    def self.normalize_amount(options)
+      if !!options[:app_base]
+        Type::Amount.to_h(options[:amount])
+      elsif !!options[:serialize]
+        Type::Amount.to_s(options[:amount])
+      else
+        Type::Amount.to_s(options[:amount])
+      end
+    end
+    
+    def self.normalize_beneficiaries(options)
+      # Type::Beneficiaries.new(options[:beneficiaries])
+      {beneficiaries: options[:beneficiaries]}
+    end
+    
     # @private
     def self.database_api(options)
-      options[:database_api] ||= Steem::DatabaseApi.new(options)
+      options[:database_api] ||= if !!options[:app_base]
+        Steem::DatabaseApi.new(options)
+      else
+        Steem::CondenserApi.new(options)
+      end
     end
     
     # @private
     def self.network_broadcast_api(options)
-      options[:network_broadcast_api] ||= Steem::NetworkBroadcastApi.new(options)
+      options[:network_broadcast_api] ||= if !!options[:app_base]
+        Steem::NetworkBroadcaseApi.new(options)
+      else
+        Steem::CondenserApi.new(options)
+      end
     end
     
     # @private