dpay-ruby 0.1.1

data/lib/dpay/rpc/thread_safe_http_client.rb

@@ -0,0 +1,35 @@
+module DPay
+  module RPC
+    # {ThreadSafeHttpClient} is the default RPC Client used by `dpay-ruby.`
+    # It's perfect for simple requests.  But for higher performance, it's better
+    # to override {HttpClient} and implement something other than {Net::HTTP}.
+    #
+    # It performs http requests in a {Mutex} critical section because {Net::HTTP}
+    # is not thread safe.  This is the very minimum level thread safety
+    # available.
+    class ThreadSafeHttpClient < HttpClient
+      SEMAPHORE = Mutex.new.freeze
+
+      # Same as #{HttpClient#http_post}, but scoped to each thread so it is
+      # thread safe.
+      def http_post
+        thread = Thread.current
+        http_post = thread.thread_variable_get(:http_post)
+        http_post ||= Net::HTTP::Post.new(uri.request_uri, POST_HEADERS)
+        thread.thread_variable_set(:http_post, http_post)
+      end
+
+      def http_request(request); SEMAPHORE.synchronize{super}; end
+
+      # Same as #{BaseClient#rpc_id}, auto-increment, but scoped to each thread
+      # so it is thread safe.
+      def rpc_id
+        thread = Thread.current
+        rpc_id = thread.thread_variable_get(:rpc_id)
+        rpc_id ||= 0
+        rpc_id += 1
+        thread.thread_variable_set(:rpc_id, rpc_id)
+      end
+    end
+  end
+end

data/lib/dpay/stream.rb

@@ -0,0 +1,377 @@
+module DPay
+  # DPay::Stream allows a live view of the dPay blockchain.
+  #
+  # Example streaming blocks:
+  #
+  #     stream = DPay::Stream.new
+  #
+  #     stream.blocks do |block, block_num|
+  #       puts "#{block_num} :: #{block.witness}"
+  #     end
+  #
+  # Example streaming transactions:
+  #
+  #     stream = DPay::Stream.new
+  #
+  #     stream.transactions do |trx, trx_id, block_num|
+  #       puts "#{block_num} :: #{trx_id} :: operations: #{trx.operations.size}"
+  #     end
+  #
+  # Example streaming operations:
+  #
+  #     stream = DPay::Stream.new
+  #
+  #     stream.operations do |op, trx_id, block_num|
+  #       puts "#{block_num} :: #{trx_id} :: #{op.type}: #{op.value.to_json}"
+  #     end
+  #
+  # Allows streaming of block headers, full blocks, transactions, operations and
+  # virtual operations.
+  class Stream
+    attr_reader :database_api, :block_api, :account_history_api, :mode
+
+    BLOCK_INTERVAL = 3
+    MAX_BACKOFF_BLOCK_INTERVAL = 30
+    MAX_RETRY_COUNT = 10
+
+    VOP_TRX_ID = ('0' * 40).freeze
+
+    # @param options [Hash] additional options
+    # @option options [DPay::DatabaseApi] :database_api
+    # @option options [DPay::BlockApi] :block_api
+    # @option options [DPay::AccountHistoryApi || DPay::CondenserApi] :account_history_api
+    # @option options [Symbol] :mode we have the choice between
+    #   * :head the last block
+    #   * :irreversible the block that is confirmed by 2/3 of all block producers and is thus irreversible!
+    # @option options [Boolean] :no_warn do not generate warnings
+    def initialize(options = {mode: :irreversible})
+      @instance_options = options
+      @database_api = options[:database_api] || DPay::DatabaseApi.new(options)
+      @block_api = options[:block_api] || DPay::BlockApi.new(options)
+      @account_history_api = options[:account_history_api]
+      @mode = options[:mode] || :irreversible
+      @no_warn = !!options[:no_warn]
+    end
+
+    # Use this method to stream block numbers.  This is significantly faster
+    # than requesting full blocks and even block headers.  Basically, the only
+    # thing this method does is call {DPay::Database#get_dynamic_global_properties} at 3 second
+    # intervals.
+    #
+    # @param options [Hash] additional options
+    # @option options [Integer] :at_block_num Starts the stream at the given block number.  Default: nil.
+    # @option options [Integer] :until_block_num Ends the stream at the given block number.  Default: nil.
+    def block_numbers(options = {}, &block)
+      block_objects(options.merge(object: :block_numbers), block)
+    end
+
+    # Use this method to stream block headers.  This is quite a bit faster than
+    # requesting full blocks.
+    #
+    # @param options [Hash] additional options
+    # @option options [Integer] :at_block_num Starts the stream at the given block number.  Default: nil.
+    # @option options [Integer] :until_block_num Ends the stream at the given block number.  Default: nil.
+    def block_headers(options = {}, &block)
+      block_objects(options.merge(object: :block_headers), block)
+    end
+
+    # Use this method to stream full blocks.
+    #
+    # @param options [Hash] additional options
+    # @option options [Integer] :at_block_num Starts the stream at the given block number.  Default: nil.
+    # @option options [Integer] :until_block_num Ends the stream at the given block number.  Default: nil.
+    def blocks(options = {}, &block)
+      block_objects(options.merge(object: :blocks), block)
+    end
+
+    # Use this method to stream each transaction.
+    #
+    # @param options [Hash] additional options
+    # @option options [Integer] :at_block_num Starts the stream at the given block number.  Default: nil.
+    # @option options [Integer] :until_block_num Ends the stream at the given block number.  Default: nil.
+    def transactions(options = {}, &block)
+      blocks(options) do |block, block_num|
+        block.transactions.each_with_index do |transaction, index|
+          trx_id = block.transaction_ids[index]
+
+          yield transaction, trx_id, block_num
+        end
+      end
+    end
+
+    # Returns the latest operations from the blockchain.
+    #
+    #   stream = DPay::Stream.new
+    #   stream.operations do |op|
+    #     puts op.to_json
+    #   end
+    #
+    # If symbol are passed to `types` option, then only that operation is
+    # returned.  Expected symbols are:
+    #
+    #   account_create_operation
+    #   account_create_with_delegation_operation
+    #   account_update_operation
+    #   account_witness_proxy_operation
+    #   account_witness_vote_operation
+    #   cancel_transfer_from_savings_operation
+    #   change_recovery_account_operation
+    #   claim_reward_balance_operation
+    #   comment_operation
+    #   comment_options_operation
+    #   convert_operation
+    #   custom_operation
+    #   custom_json_operation
+    #   decline_voting_rights_operation
+    #   delegate_vesting_shares_operation
+    #   delete_comment_operation
+    #   escrow_approve_operation
+    #   escrow_dispute_operation
+    #   escrow_release_operation
+    #   escrow_transfer_operation
+    #   feed_publish_operation
+    #   limit_order_cancel_operation
+    #   limit_order_create_operation
+    #   limit_order_create2_operation
+    #   pow_operation
+    #   pow2_operation
+    #   recover_account_operation
+    #   request_account_recovery_operation
+    #   set_withdraw_vesting_route_operation
+    #   transfer_operation
+    #   transfer_from_savings_operation
+    #   transfer_to_savings_operation
+    #   transfer_to_vesting_operation
+    #   vote_operation
+    #   withdraw_vesting_operation
+    #   witness_update_operation
+    #
+    # For example, to stream only votes:
+    #
+    #   stream = DPay::Stream.new
+    #   stream.operations(types: :vote_operation) do |vote|
+    #     puts vote.to_json
+    #   end
+    #
+    # ... Or ...
+    #
+    #   stream = DPay::Stream.new
+    #   stream.operations(:vote_operation) do |vote|
+    #     puts vote.to_json
+    #   end
+    #
+    # You can also stream virtual operations:
+    #
+    #   stream = DPay::Stream.new
+    #   stream.operations(types: :author_reward_operation, only_virtual: true) do |vop|
+    #     v = vop.value
+    #     puts "#{v.author} got paid for #{v.permlink}: #{[v.bbd_payout, v.dpay_payout, v.vesting_payout]}"
+    #   end
+    #
+    # ... or multiple virtual operation types;
+    #
+    #   stream = DPay::Stream.new
+    #   stream.operations(types: [:producer_reward_operation, :author_reward_operation], only_virtual: true) do |vop|
+    #     puts vop.to_json
+    #   end
+    #
+    # ... or all types, including virtual operation types from the head block number:
+    #
+    #   stream = DPay::Stream.new(mode: :head)
+    #   stream.operations(include_virtual: true) do |op|
+    #     puts op.to_json
+    #   end
+    #
+    # Expected virtual operation types:
+    #
+    #   producer_reward_operation
+    #   author_reward_operation
+    #   curation_reward_operation
+    #   fill_convert_request_operation
+    #   fill_order_operation
+    #   fill_vesting_withdraw_operation
+    #   interest_operation
+    #   shutdown_witness_operation
+    #
+    # @param args [Symbol || Array<Symbol> || Hash] the type(s) of operation or hash of expanded options, optional.
+    # @option args [Integer] :at_block_num Starts the stream at the given block number.  Default: nil.
+    # @option args [Integer] :until_block_num Ends the stream at the given block number.  Default: nil.
+    # @option args [Symbol || Array<Symbol>] :types the type(s) of operation, optional.
+    # @option args [Boolean] :only_virtual Only stream virtual options.  Setting this true will improve performance because the stream only needs block numbers to then retrieve virtual operations.  Default: false.
+    # @option args [Boolean] :include_virtual Also stream virtual options.  Setting this true will impact performance.  Default: false.
+    # @param block the block to execute for each result.  Yields: |op, trx_id, block_num|
+    def operations(*args, &block)
+      options = {}
+      types = []
+      only_virtual = false
+      include_virtual = false
+      last_block_num = nil
+
+      case args.first
+      when Hash
+        options = args.first
+        types = transform_types(options[:types])
+        only_virtual = !!options[:only_virtual] || false
+        include_virtual = !!options[:include_virtual] || only_virtual || false
+      when Symbol, Array then types = transform_types(args)
+      end
+
+      if only_virtual
+        block_numbers(options) do |block_num|
+          get_virtual_ops(types, block_num, block)
+        end
+      else
+        transactions(options) do |transaction, trx_id, block_num|
+          transaction.operations.each do |op|
+            yield op, trx_id, block_num if types.none? || types.include?(op.type)
+
+            next unless last_block_num != block_num
+
+            last_block_num = block_num
+
+            get_virtual_ops(types, block_num, block) if include_virtual
+          end
+        end
+      end
+    end
+
+    def account_history_api
+      @account_history_api ||= begin
+        DPay::AccountHistoryApi.new(@instance_options)
+      rescue DPay::UnknownApiError => e
+        warn "#{e.inspect}, falling back to DPay::CondenserApi." unless @no_warn
+        DPay::CondenserApi.new(@instance_options)
+      end
+    end
+  private
+    # @private
+    def block_objects(options = {}, block)
+      object = options[:object]
+      object_method = "get_#{object}".to_sym
+      block_interval = BLOCK_INTERVAL
+
+      at_block_num, until_block_num = if !!block_range = options[:block_range]
+        [block_range.first, block_range.last]
+      else
+        [options[:at_block_num], options[:until_block_num]]
+      end
+
+      loop do
+        break if !!until_block_num && !!at_block_num && until_block_num < at_block_num
+
+        database_api.get_dynamic_global_properties do |properties|
+          current_block_num = find_block_number(properties)
+          current_block_num = [current_block_num, until_block_num].compact.min
+          at_block_num ||= current_block_num
+
+          if current_block_num >= at_block_num
+            range = at_block_num..current_block_num
+
+            if object == :block_numbers
+              range.each do |n|
+                block.call n
+                block_interval = BLOCK_INTERVAL
+              end
+            else
+              block_api.send(object_method, block_range: range) do |b, n|
+                block.call b, n
+                block_interval = BLOCK_INTERVAL
+              end
+            end
+
+            at_block_num = range.max + 1
+          else
+            # The stream has stalled, so let's back off and let the node sync
+            # up.  We'll catch up with a bigger batch in the next cycle.
+            block_interval = [block_interval * 2, MAX_BACKOFF_BLOCK_INTERVAL].min
+          end
+        end
+
+        sleep block_interval
+      end
+    end
+
+    # @private
+    def find_block_number(properties)
+      block_num = case mode
+      when :head then properties.head_block_number
+      when :irreversible then properties.last_irreversible_block_num
+      else; raise DPay::ArgumentError, "Unknown mode: #{mode}"
+      end
+
+      block_num
+    end
+
+    # @private
+    def transform_types(types)
+      [types].compact.flatten.map do |type|
+        type = type.to_s
+
+        unless type.end_with? '_operation'
+          warn "Op type #{type} is deprecated.  Use #{type}_operation instead." unless @no_warn
+          type += '_operation'
+        end
+
+        type
+      end
+    end
+
+    # @private
+    def get_virtual_ops(types, block_num, block)
+      retries = 0
+
+      loop do
+        get_ops_in_block_options = case account_history_api
+        when DPay::CondenserApi
+          [block_num, true]
+        when DPay::AccountHistoryApi
+          {
+            block_num: block_num,
+            only_virtual: true
+          }
+        end
+
+        response = account_history_api.get_ops_in_block(*get_ops_in_block_options)
+        result = response.result
+
+        if result.nil?
+          if retries < MAX_RETRY_COUNT
+            warn "Retrying get_ops_in_block on block #{block_num}" unless @no_warn
+            retries = retries + 1
+            sleep 9
+            redo
+          else
+            raise TooManyRetriesError, "unable to get valid result while finding virtual operations for block: #{block_num}"
+          end
+        end
+
+        ops = case account_history_api
+        when DPay::CondenserApi
+          result.map do |trx|
+            op = {type: trx.op[0] + '_operation', value: trx.op[1]}
+            op = Hashie::Mash.new(op)
+          end
+        when DPay::AccountHistoryApi then result.ops.map { |trx| trx.op }
+        end
+
+        if ops.empty?
+          if retries < MAX_RETRY_COUNT
+            sleep 3
+            retries = retries + 1
+            redo
+          else
+            raise TooManyRetriesError, "unable to find virtual operations for block: #{block_num}"
+          end
+        end
+
+        ops.each do |op|
+          next if types.any? && !types.include?(op.type)
+
+          block.call op, VOP_TRX_ID, block_num
+        end
+
+        break
+      end
+    end
+  end
+end

data/lib/dpay/transaction_builder.rb

@@ -0,0 +1,386 @@
+module DPay
+  # {TransactionBuilder} can be used to create a transaction that the
+  # {NetworkBroadcastApi} can broadcast to the rest of the platform.  The main
+  # feature of this class is the ability to cryptographically sign the
+  # transaction so that it conforms to the consensus rules that are required by
+  # the blockchain.
+  #
+  #     wif = '5JrvPrQeBBvCRdjv29iDvkwn3EQYZ9jqfAHzrCyUvfbEbRkrYFC'
+  #     builder = DPay::TransactionBuilder.new(wif: wif)
+  #     builder.put(vote: {
+  #       voter: 'alice',
+  #       author: 'bob',
+  #       permlink: 'my-burgers',
+  #       weight: 10000
+  #     })
+  #
+  #     trx = builder.transaction
+  #     network_broadcast_api = DPay::CondenserApi.new
+  #     network_broadcast_api.broadcast_transaction_synchronous(trx: trx)
+  #
+  #
+  # The `wif` value may also be an array, when signing with multiple signatures
+  # (multisig).
+  class TransactionBuilder
+    include Retriable
+    include ChainConfig
+    include Utils
+
+    attr_accessor :app_base, :database_api, :block_api, :expiration, :operations
+    attr_writer :wif
+    attr_reader :signed
+
+    alias app_base? app_base
+
+    def initialize(options = {})
+      @app_base = !!options[:app_base] # default false
+      @database_api = options[:database_api]
+      @block_api = options[:block_api]
+
+      if app_base?
+        @database_api ||= DPay::DatabaseApi.new(options)
+        @block_api ||= DPay::BlockApi.new(options)
+      else
+        @database_api ||= DPay::CondenserApi.new(options)
+        @block_api ||= DPay::CondenserApi.new(options)
+      end
+
+      @wif = [options[:wif]].flatten
+      @signed = false
+
+      if !!(trx = options[:trx])
+        trx = case trx
+        when String then JSON[trx]
+        else; trx
+        end
+
+        trx_options = {
+          ref_block_num: trx['ref_block_num'],
+          ref_block_prefix: trx['ref_block_prefix'],
+          extensions: (trx['extensions']),
+          operations: trx['operations'],
+          signatures: (trx['signatures']),
+        }
+
+        trx_options[:expiration] = case trx['expiration']
+        when String then Time.parse(trx['expiration'] + 'Z')
+        else; trx['expiration']
+        end
+
+        options = options.merge(trx_options)
+      end
+
+      @ref_block_num = options[:ref_block_num]
+      @ref_block_prefix = options[:ref_block_prefix]
+      @operations = options[:operations] || []
+      @expiration = options[:expiration]
+      @extensions = options[:extensions] || []
+      @signatures = options[:signatures] || []
+      @chain = options[:chain] || :dpay
+      @error_pipe = options[:error_pipe] || STDERR
+      @chain_id = case @chain
+      when :dpay then NETWORKS_DPAY_CHAIN_ID
+      when :test then NETWORKS_TEST_CHAIN_ID
+      else; raise UnsupportedChainError, "Unsupported chain: #{@chain}"
+      end
+    end
+
+    def inspect
+      properties = %w(
+        ref_block_num ref_block_prefix expiration operations extensions
+        signatures
+      ).map do |prop|
+        if !!(v = instance_variable_get("@#{prop}"))
+          "@#{prop}=#{v}"
+        end
+      end.compact.join(', ')
+
+      "#<#{self.class.name} [#{properties}]>"
+    end
+
+    def reset
+      @ref_block_num = nil
+      @ref_block_prefix = nil
+      @expiration = nil
+      @operations = []
+      @extensions = []
+      @signatures = []
+      @signed = false
+
+      self
+    end
+
+    def expired?
+      @expiration.nil? || @expiration < Time.now
+    end
+
+    # If the transaction can be prepared, this method will do so and set the
+    # expiration.  Once the expiration is set, it will not re-prepare.  If you
+    # call {#put}, the expiration is set {::Nil} so that it can be re-prepared.
+    #
+    # Usually, this method is called automatically by {#put} and/or {#transaction}.
+    #
+    # @return {TransactionBuilder}
+    def prepare
+      if expired?
+        catch :prepare_header do; begin
+          @database_api.get_dynamic_global_properties do |properties|
+            block_number = properties.last_irreversible_block_num
+            block_header_args = if app_base?
+              {block_num: block_number}
+            else
+              block_number
+            end
+
+            @block_api.get_block_header(block_header_args) do |result|
+              header = if app_base?
+                result.header
+              else
+                result
+              end
+
+              @ref_block_num = (block_number - 1) & 0xFFFF
+              @ref_block_prefix = unhexlify(header.previous[8..-1]).unpack('V*')[0]
+              @expiration ||= (Time.parse(properties.time + 'Z') + EXPIRE_IN_SECS).utc
+            end
+          end
+        rescue => e
+          if can_retry? e
+            @error_pipe.puts "#{e} ... retrying."
+            throw :prepare_header
+          else
+            raise e
+          end
+        end; end
+      end
+
+      self
+    end
+
+    # Sets operations all at once, then prepares.
+    def operations=(operations)
+      @operations = operations.map{ |op| normalize_operation(op) }
+      prepare
+      @operations
+    end
+
+    # A quick and flexible way to append a new operation to the transaction.
+    # This method uses ducktyping to figure out how to form the operation.
+    #
+    # There are three main ways you can call this method.  These assume that
+    # `op_type` is a {::Symbol} (or {::String}) representing the type of operation and `op` is the
+    # operation {::Hash}.
+    #
+    #     put(op_type, op)
+    #
+    # ... or ...
+    #
+    #     put(op_type => op)
+    #
+    # ... or ...
+    #
+    #     put([op_type, op])
+    #
+    # You can also chain multiple operations:
+    #
+    #     builder = DPay::TransactionBuilder.new
+    #     builder.put(vote: vote1).put(vote: vote2)
+    # @return {TransactionBuilder}
+    def put(type, op = nil)
+      @expiration = nil
+      @operations << normalize_operation(type, op)
+      prepare
+      self
+    end
+
+    # If all of the required values are set, this returns a fully formed
+    # transaction that is ready to broadcast.
+    #
+    # @return
+    #     {
+    #            :ref_block_num => 18912,
+    #         :ref_block_prefix => 575781536,
+    #               :expiration => "2018-04-26T15:26:12",
+    #               :extensions => [],
+    #               :operations => [[:vote, {
+    #                    :voter => "alice",
+    #                   :author => "bob",
+    #                 :permlink => "my-burgers",
+    #                   :weight => 10000
+    #                 }
+    #             ]],
+    #               :signatures => ["1c45b65740b4b2c17c4bcf6bcc3f8d90ddab827d50532729fc3b8f163f2c465a532b0112ae4bf388ccc97b7c2e0bc570caadda78af48cf3c261037e65eefcd941e"]
+    #     }
+    def transaction
+      prepare
+      sign
+    end
+
+    # Appends to the `signatures` array of the transaction, built from a
+    # serialized digest.
+    #
+    # @return {Hash | TransactionBuilder} The fully signed transaction if a `wif` is provided or the instance of the {TransactionBuilder} if a `wif` has not yet been provided.
+    def sign
+      return self if @wif.empty?
+      return self if expired?
+
+      trx = {
+        ref_block_num: @ref_block_num,
+        ref_block_prefix: @ref_block_prefix,
+        expiration: @expiration.strftime('%Y-%m-%dT%H:%M:%S'),
+        operations: @operations,
+        extensions: @extensions,
+        signatures: @signatures
+      }
+
+      unless @signed
+        catch :serialize do; begin
+          transaction_hex_args = if app_base?
+            {trx: trx}
+          else
+            trx
+          end
+
+          @database_api.get_transaction_hex(transaction_hex_args) do |result|
+            hex = if app_base?
+              result.hex
+            else
+              result
+            end
+
+            hex = @chain_id + hex[0..-4] # Why do we have to chop the last two bytes?
+            digest = unhexlify(hex)
+            digest_hex = Digest::SHA256.digest(digest)
+            private_keys = @wif.map{ |wif| Bitcoin::Key.from_base58 wif }
+            ec = Bitcoin::OpenSSL_EC
+            count = 0
+            sigs = []
+
+            private_keys.each do |private_key|
+              sig = nil
+
+              loop do
+                count += 1
+                @error_pipe.puts "#{count} attempts to find canonical signature" if count % 40 == 0
+                public_key_hex = private_key.pub
+                sig = ec.sign_compact(digest_hex, private_key.priv, public_key_hex, false)
+
+                next if public_key_hex != ec.recover_compact(digest_hex, sig)
+                break if canonical? sig
+              end
+
+              @signatures << hexlify(sig)
+            end
+
+            @signed = true
+            trx[:signatures] = @signatures
+          end
+        rescue => e
+          if can_retry? e
+            @error_pipe.puts "#{e} ... retrying."
+            throw :serialize
+          else
+            raise e
+          end
+        end; end
+      end
+
+      Hashie::Mash.new trx
+    end
+
+    # @return [Array] All public keys that could possibly sign for a given transaction.
+    def potential_signatures
+      potential_signatures_args = if app_base?
+        {trx: transaction}
+      else
+        transaction
+      end
+
+      @database_api.get_potential_signatures(potential_signatures_args) do |result|
+        if app_base?
+          result[:keys]
+        else
+          result
+        end
+      end
+    end
+
+    # This API will take a partially signed transaction and a set of public keys
+    # that the owner has the ability to sign for and return the minimal subset
+    # of public keys that should add signatures to the transaction.
+    #
+    # @return [Array] The minimal subset of public keys that should add signatures to the transaction.
+    def required_signatures
+      required_signatures_args = if app_base?
+        {trx: transaction}
+      else
+        [transaction, []]
+      end
+
+      @database_api.get_required_signatures(*required_signatures_args) do |result|
+        if app_base?
+          result[:keys]
+        else
+          result
+        end
+      end
+    end
+
+    # @return [Boolean] True if the transaction has all of the required signatures.
+    def valid?
+      verify_authority_args = if app_base?
+        {trx: transaction}
+      else
+        transaction
+      end
+
+      @database_api.verify_authority(verify_authority_args) do |result|
+        if app_base?
+          result.valid
+        else
+          result
+        end
+      end
+    end
+  private
+    # See: https://github.com/dpays/dpay/pull/2500
+    # @private
+    def canonical?(sig)
+      sig = sig.unpack('C*')
+
+      !(
+        ((sig[0] & 0x80 ) != 0) || ( sig[0] == 0 ) ||
+        ((sig[1] & 0x80 ) != 0) ||
+        ((sig[32] & 0x80 ) != 0) || ( sig[32] == 0 ) ||
+        ((sig[33] & 0x80 ) != 0)
+      )
+    end
+
+    def normalize_operation(type, op = nil)
+      if app_base?
+        case type
+        when Symbol, String
+          type_value = "#{type}_operation"
+          {type: type_value, value: op}
+        when Hash
+          type_value = "#{type.keys.first}_operation"
+          {type: type_value, value: type.values.first}
+        when Array
+          type_value = "#{type[0]}_operation"
+          {type: type_value, value: type[1]}
+        else
+          raise DPay::ArgumentError, "Don't know what to do with operation type #{type.class}: #{type} (#{op})"
+        end
+      else
+        case type
+        when Symbol then [type, op]
+        when String then [type.to_sym, op]
+        when Hash then [type.keys.first.to_sym, type.values.first]
+        when Array then type
+        else
+          raise DPay::ArgumentError, "Don't know what to do with operation type #{type.class}: #{type} (#{op})"
+        end
+      end
+    end
+  end
+end