bsv-sdk 0.20.0 → 0.22.0

data/lib/bsv/wallet/serializer/sign_action_args.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Serializer
+      # BRC-103 serialiser for sign_action args (call byte 2).
+      #
+      # Wire layout (port of go-sdk/wallet/serializer/sign_action_args.go):
+      #   [varint]     spends count
+      #   For each spend (sorted by input_index):
+      #     [varint]   input_index
+      #     [int_bytes] unlocking_script
+      #     [optional_uint32] sequence_number
+      #   [int_bytes]  reference
+      #   [1 byte]     options present flag (0=absent, 1=present)
+      #   If options present:
+      #     [optional_bool] accept_delayed_broadcast
+      #     [optional_bool] return_txid_only
+      #     [optional_bool] no_send
+      #     [txid_slice]       send_with
+      module SignActionArgs
+        module_function
+
+        # @param args [Hash]
+        # @return [String] binary
+        def serialize(args)
+          w = Wire::Writer.new
+
+          spends = args[:spends] || {}
+          w.write_varint(spends.length)
+          spends.keys.sort.each do |idx|
+            spend = spends[idx]
+            w.write_varint(idx)
+            w.write_int_bytes(spend[:unlocking_script])
+            w.write_optional_uint32(spend[:sequence_number])
+          end
+
+          w.write_int_bytes(args[:reference])
+
+          opts = args[:options]
+          if opts
+            w.write_byte(1)
+            w.write_optional_bool(opts[:accept_delayed_broadcast])
+            w.write_optional_bool(opts[:return_txid_only])
+            w.write_optional_bool(opts[:no_send])
+            w.write_txid_slice(opts[:send_with])
+          else
+            w.write_byte(0)
+          end
+
+          w.buf
+        end
+
+        # @param bytes [String] binary
+        # @return [Hash]
+        def deserialize(bytes)
+          r = Wire::Reader.new(bytes)
+
+          spend_count = r.read_varint
+          spends = {}
+          spend_count.times do
+            idx    = r.read_varint
+            script = r.read_int_bytes
+            seq    = r.read_optional_uint32
+            spend  = { unlocking_script: script }
+            spend[:sequence_number] = seq unless seq.nil?
+            spends[idx] = spend
+          end
+
+          reference = r.read_int_bytes
+
+          options_present = r.read_byte
+          options = if options_present == 1
+                      opts = {}
+                      v = r.read_optional_bool
+                      opts[:accept_delayed_broadcast] = v unless v.nil?
+                      v = r.read_optional_bool
+                      opts[:return_txid_only] = v unless v.nil?
+                      v = r.read_optional_bool
+                      opts[:no_send] = v unless v.nil?
+                      sw = r.read_txid_slice
+                      opts[:send_with] = sw unless sw.nil?
+                      opts
+                    end
+
+          result = { spends: spends }
+          result[:reference] = reference unless reference.nil? || reference.empty?
+          result[:options]   = options   unless options.nil?
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/serializer/sign_action_result.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Serializer
+      # BRC-103 serialiser for sign_action result (call byte 2).
+      #
+      # Wire layout (port of go-sdk/wallet/serializer/sign_action_result.go):
+      #   [flag + 32 bytes] txid with flag byte: 0=absent, 1=present (wire-order)
+      #   [flag + int_bytes] tx (BEEF bytes) with flag byte: 0=absent, 1=present + varint_len
+      #   [send_with_results] varint count + txid (32 bytes) + status_byte each
+      module SignActionResult
+        module_function
+
+        # @param result [Hash]
+        # @return [String] binary
+        def serialize(result)
+          w = Wire::Writer.new
+
+          txid_bytes = result[:txid] ? [result[:txid]].pack('H*').reverse : nil
+          w.write_optional_bytes_with_flag(txid_bytes, fixed_size: 32)
+          w.write_optional_bytes_with_flag(result[:tx])
+
+          Common.write_send_with_results(w, result[:send_with_results])
+
+          w.buf
+        end
+
+        # @param bytes [String] binary
+        # @return [Hash]
+        def deserialize(bytes)
+          r = Wire::Reader.new(bytes)
+
+          txid_raw = r.read_optional_bytes_with_flag(fixed_size: 32)
+          txid_hex = txid_raw&.reverse&.unpack1('H*')
+          tx       = r.read_optional_bytes_with_flag
+
+          send_with_results = Common.read_send_with_results(r)
+
+          result = {}
+          result[:txid]              = txid_hex          unless txid_hex.nil?
+          result[:tx]                = tx                unless tx.nil?
+          result[:send_with_results] = send_with_results unless send_with_results.nil?
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/serializer/status.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Serializer
+      # BRC-103 serialisers for is_authenticated (call byte 23) and
+      # wait_for_authentication (call byte 24).
+      #
+      # Both calls take no args payload (originator is in the frame header).
+      #
+      # Result wire format:
+      #   is_authenticated:        [1 byte] 0x01 = true, 0x00 = false
+      #   wait_for_authentication: empty payload → always returns authenticated: true
+      #
+      # Port of go-sdk/wallet/serializer/authenticated.go.
+      module IsAuthenticated
+        module Args
+          module_function
+
+          def serialize(_args = {})
+            ''.b
+          end
+
+          def deserialize(_bytes)
+            {}
+          end
+        end
+
+        module Result
+          module_function
+
+          # @param result [Hash] { authenticated: Boolean }
+          # @return [String] 1-byte binary
+          def serialize(result)
+            [result[:authenticated] ? 1 : 0].pack('C')
+          end
+
+          # @param bytes [String] binary — must be exactly 1 byte
+          # @return [Hash] { authenticated: Boolean }
+          def deserialize(bytes)
+            data = bytes.b
+            unless data.bytesize == 1
+              raise BSV::Wallet::InvalidParameterError.new(
+                'is_authenticated result',
+                'exactly 1 byte'
+              )
+            end
+
+            { authenticated: data.getbyte(0) == 1 }
+          end
+        end
+      end
+
+      module WaitForAuthentication
+        module Args
+          module_function
+
+          def serialize(_args = {})
+            ''.b
+          end
+
+          def deserialize(_bytes)
+            {}
+          end
+        end
+
+        module Result
+          module_function
+
+          # @param _result [Hash] ignored — always serialises as empty payload
+          # @return [String] empty binary
+          def serialize(_result = {})
+            ''.b
+          end
+
+          # @param _bytes [String] ignored — always returns authenticated: true
+          # @return [Hash] { authenticated: true }
+          def deserialize(_bytes = nil)
+            { authenticated: true }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/serializer/verify_hmac.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Serializer
+      # BRC-103 wire codec for the +verify_hmac+ call (call byte 14).
+      #
+      # Port of go-sdk/wallet/serializer/verify_hmac.go.
+      module VerifyHmac
+        HMAC_SIZE = 32
+
+        # Args wire layout:
+        #   [key-related params]
+        #   [32 bytes: HMAC]
+        #   [VarInt data_len][data bytes]
+        #   [optional_bool seek_permission]
+        module Args
+          module_function
+
+          def serialize(args)
+            hmac = Common.to_binary(args[:hmac])
+            raise BSV::Wallet::InvalidParameterError.new('hmac', "exactly #{HMAC_SIZE} bytes") unless hmac.bytesize == HMAC_SIZE
+
+            w = BSV::Wallet::Wire::Writer.new
+            Common.write_key_related_params(
+              w,
+              protocol_id: args[:protocol_id],
+              key_id: args[:key_id],
+              counterparty: args[:counterparty],
+              privileged: args[:privileged],
+              privileged_reason: args[:privileged_reason]
+            )
+            w.write_bytes(hmac)
+            data = Common.to_binary(args[:data])
+            w.write_varint(data.bytesize)
+            w.write_bytes(data)
+            w.write_optional_bool(args[:seek_permission])
+            w.buf
+          end
+
+          def deserialize(bytes)
+            r = BSV::Wallet::Wire::Reader.new(bytes)
+            params = Common.read_key_related_params(r)
+            hmac = r.read_bytes(HMAC_SIZE)
+            data_len = r.read_varint
+            data = r.read_bytes(data_len)
+            seek_permission = r.read_optional_bool
+            params.merge(hmac: hmac, data: data, seek_permission: seek_permission)
+          end
+        end
+
+        # Result wire layout: empty — success implies valid.
+        module Result
+          module_function
+
+          def serialize(_result)
+            ''.b
+          end
+
+          def deserialize(_bytes)
+            { valid: true }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/serializer/verify_signature.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Serializer
+      # BRC-103 wire codec for the +verify_signature+ call (call byte 16).
+      #
+      # Port of go-sdk/wallet/serializer/verify_signature.go.
+      module VerifySignature
+        HASH_SIZE = 32
+
+        # Args wire layout:
+        #   [key-related params]
+        #   [optional_bool for_self]
+        #   [VarInt sig_len][DER signature bytes]
+        #   [1 byte: data-type flag — 1=data, 2=hash_to_directly_verify]
+        #   If flag=1: [VarInt data_len][data bytes]
+        #   If flag=2: [32 bytes: hash]
+        #   [optional_bool seek_permission]
+        module Args
+          module_function
+
+          def serialize(args)
+            data = args[:data] && Common.to_binary(args[:data])
+            hash = args[:hash_to_directly_verify] && Common.to_binary(args[:hash_to_directly_verify])
+            sig  = args[:signature] && Common.to_binary(args[:signature])
+
+            if data && hash
+              raise BSV::Wallet::InvalidParameterError.new(
+                'data and hash_to_directly_verify',
+                'not both provided — supply one or the other'
+              )
+            end
+            raise BSV::Wallet::InvalidParameterError.new('data or hash_to_directly_verify', 'present') unless data || hash
+            raise BSV::Wallet::InvalidParameterError.new('signature', 'present') unless sig
+
+            w = BSV::Wallet::Wire::Writer.new
+            Common.write_key_related_params(
+              w,
+              protocol_id: args[:protocol_id],
+              key_id: args[:key_id],
+              counterparty: args[:counterparty],
+              privileged: args[:privileged],
+              privileged_reason: args[:privileged_reason]
+            )
+
+            w.write_optional_bool(args[:for_self])
+
+            w.write_varint(sig.bytesize)
+            w.write_bytes(sig)
+
+            if data
+              w.write_byte(1)
+              w.write_varint(data.bytesize)
+              w.write_bytes(data)
+            else
+              w.write_byte(2)
+              w.write_bytes(hash)
+            end
+
+            w.write_optional_bool(args[:seek_permission])
+            w.buf
+          end
+
+          def deserialize(bytes)
+            r = BSV::Wallet::Wire::Reader.new(bytes)
+            params = Common.read_key_related_params(r)
+            for_self = r.read_optional_bool
+            sig_len = r.read_varint
+            signature = r.read_bytes(sig_len)
+            flag = r.read_byte
+            payload = case flag
+                      when 1
+                        len = r.read_varint
+                        { data: r.read_bytes(len) }
+                      when 2
+                        { hash_to_directly_verify: r.read_bytes(HASH_SIZE) }
+                      else
+                        raise ArgumentError, "invalid data-type flag: #{flag}"
+                      end
+            seek_permission = r.read_optional_bool
+            params.merge(for_self: for_self, signature: signature).merge(payload).merge(seek_permission: seek_permission)
+          end
+        end
+
+        # Result wire layout: empty — success implies valid.
+        module Result
+          module_function
+
+          def serialize(_result)
+            ''.b
+          end
+
+          def deserialize(_bytes)
+            { valid: true }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/serializer.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    # Registry of per-call BRC-103 binary serialisers.
+    #
+    # Each table maps a Wire::Calls constant to the module_function on the
+    # matching Serializer sub-module. Other developer agents populate their
+    # tiers in parallel — add one entry per call, one line each.
+    module Serializer
+      autoload :Common,                       'bsv/wallet/serializer/common'
+
+      # Crypto tier (call bytes 8-16)
+      autoload :GetPublicKey,                 'bsv/wallet/serializer/get_public_key'
+      autoload :RevealCounterpartyKeyLinkage, 'bsv/wallet/serializer/reveal_counterparty_key_linkage'
+      autoload :RevealSpecificKeyLinkage,     'bsv/wallet/serializer/reveal_specific_key_linkage'
+      autoload :Encrypt,                      'bsv/wallet/serializer/encrypt'
+      autoload :Decrypt,                      'bsv/wallet/serializer/decrypt'
+      autoload :CreateHmac,                   'bsv/wallet/serializer/create_hmac'
+      autoload :VerifyHmac,                   'bsv/wallet/serializer/verify_hmac'
+      autoload :CreateSignature,              'bsv/wallet/serializer/create_signature'
+      autoload :VerifySignature,              'bsv/wallet/serializer/verify_signature'
+
+      # Trivial tier (call bytes 23-28)
+      autoload :GetNetwork,               'bsv/wallet/serializer/get_network'
+      autoload :GetVersion,               'bsv/wallet/serializer/get_version'
+      autoload :GetHeight,                'bsv/wallet/serializer/get_height'
+      autoload :GetHeaderForHeight,       'bsv/wallet/serializer/get_header_for_height'
+      autoload :IsAuthenticated,          'bsv/wallet/serializer/status'
+      autoload :WaitForAuthentication,    'bsv/wallet/serializer/status'
+      autoload :CreateActionArgs,           'bsv/wallet/serializer/create_action_args'
+      autoload :CreateActionResult,         'bsv/wallet/serializer/create_action_result'
+      autoload :SignActionArgs,             'bsv/wallet/serializer/sign_action_args'
+      autoload :SignActionResult,           'bsv/wallet/serializer/sign_action_result'
+      autoload :AbortAction,               'bsv/wallet/serializer/abort_action'
+      autoload :InternalizeActionArgs,     'bsv/wallet/serializer/internalize_action'
+      autoload :InternalizeActionResult,   'bsv/wallet/serializer/internalize_action'
+      autoload :ListActionsArgs,           'bsv/wallet/serializer/list_actions'
+      autoload :ListActionsResult,         'bsv/wallet/serializer/list_actions'
+      autoload :Certificate,               'bsv/wallet/serializer/certificate'
+      autoload :DiscoverCertificatesResult, 'bsv/wallet/serializer/discover_certificates_result'
+      autoload :ListOutputs,               'bsv/wallet/serializer/list_outputs'
+      autoload :RelinquishOutput,          'bsv/wallet/serializer/relinquish_output'
+      autoload :AcquireCertificate,        'bsv/wallet/serializer/acquire_certificate'
+      autoload :ListCertificates,          'bsv/wallet/serializer/list_certificates'
+      autoload :ProveCertificate,          'bsv/wallet/serializer/prove_certificate'
+      autoload :RelinquishCertificate,     'bsv/wallet/serializer/relinquish_certificate'
+      autoload :DiscoverByIdentityKey,     'bsv/wallet/serializer/discover_by_identity_key'
+      autoload :DiscoverByAttributes,      'bsv/wallet/serializer/discover_by_attributes'
+
+      # Client-side: serialise outgoing args for each call.
+      SERIALIZE_ARGS = {
+        Wire::Calls::GET_PUBLIC_KEY => GetPublicKey::Args.method(:serialize),
+        Wire::Calls::REVEAL_COUNTERPARTY_KEY_LINKAGE => RevealCounterpartyKeyLinkage::Args.method(:serialize),
+        Wire::Calls::REVEAL_SPECIFIC_KEY_LINKAGE => RevealSpecificKeyLinkage::Args.method(:serialize),
+        Wire::Calls::ENCRYPT => Encrypt::Args.method(:serialize),
+        Wire::Calls::DECRYPT => Decrypt::Args.method(:serialize),
+        Wire::Calls::CREATE_HMAC => CreateHmac::Args.method(:serialize),
+        Wire::Calls::VERIFY_HMAC => VerifyHmac::Args.method(:serialize),
+        Wire::Calls::CREATE_SIGNATURE => CreateSignature::Args.method(:serialize),
+        Wire::Calls::VERIFY_SIGNATURE => VerifySignature::Args.method(:serialize),
+        Wire::Calls::GET_NETWORK => GetNetwork::Args.method(:serialize),
+        Wire::Calls::GET_VERSION => GetVersion::Args.method(:serialize),
+        Wire::Calls::GET_HEIGHT => GetHeight::Args.method(:serialize),
+        Wire::Calls::GET_HEADER_FOR_HEIGHT => GetHeaderForHeight::Args.method(:serialize),
+        Wire::Calls::IS_AUTHENTICATED => IsAuthenticated::Args.method(:serialize),
+        Wire::Calls::WAIT_FOR_AUTHENTICATION => WaitForAuthentication::Args.method(:serialize),
+        Wire::Calls::CREATE_ACTION => CreateActionArgs.method(:serialize),
+        Wire::Calls::SIGN_ACTION => SignActionArgs.method(:serialize),
+        Wire::Calls::ABORT_ACTION => AbortAction.method(:serialize_args),
+        Wire::Calls::INTERNALIZE_ACTION => InternalizeActionArgs.method(:serialize),
+        Wire::Calls::LIST_ACTIONS => ListActionsArgs.method(:serialize),
+        Wire::Calls::LIST_OUTPUTS => ListOutputs.method(:serialize_args),
+        Wire::Calls::RELINQUISH_OUTPUT => RelinquishOutput.method(:serialize_args),
+        Wire::Calls::ACQUIRE_CERTIFICATE => AcquireCertificate.method(:serialize_args),
+        Wire::Calls::LIST_CERTIFICATES => ListCertificates.method(:serialize_args),
+        Wire::Calls::PROVE_CERTIFICATE => ProveCertificate.method(:serialize_args),
+        Wire::Calls::RELINQUISH_CERTIFICATE => RelinquishCertificate.method(:serialize_args),
+        Wire::Calls::DISCOVER_BY_IDENTITY_KEY => DiscoverByIdentityKey.method(:serialize_args),
+        Wire::Calls::DISCOVER_BY_ATTRIBUTES => DiscoverByAttributes.method(:serialize_args)
+      }.freeze
+
+      # Client-side: deserialise incoming result payload for each call.
+      DESERIALIZE_RESULT = {
+        Wire::Calls::GET_PUBLIC_KEY => GetPublicKey::Result.method(:deserialize),
+        Wire::Calls::REVEAL_COUNTERPARTY_KEY_LINKAGE => RevealCounterpartyKeyLinkage::Result.method(:deserialize),
+        Wire::Calls::REVEAL_SPECIFIC_KEY_LINKAGE => RevealSpecificKeyLinkage::Result.method(:deserialize),
+        Wire::Calls::ENCRYPT => Encrypt::Result.method(:deserialize),
+        Wire::Calls::DECRYPT => Decrypt::Result.method(:deserialize),
+        Wire::Calls::CREATE_HMAC => CreateHmac::Result.method(:deserialize),
+        Wire::Calls::VERIFY_HMAC => VerifyHmac::Result.method(:deserialize),
+        Wire::Calls::CREATE_SIGNATURE => CreateSignature::Result.method(:deserialize),
+        Wire::Calls::VERIFY_SIGNATURE => VerifySignature::Result.method(:deserialize),
+        Wire::Calls::GET_NETWORK => GetNetwork::Result.method(:deserialize),
+        Wire::Calls::GET_VERSION => GetVersion::Result.method(:deserialize),
+        Wire::Calls::GET_HEIGHT => GetHeight::Result.method(:deserialize),
+        Wire::Calls::GET_HEADER_FOR_HEIGHT => GetHeaderForHeight::Result.method(:deserialize),
+        Wire::Calls::IS_AUTHENTICATED => IsAuthenticated::Result.method(:deserialize),
+        Wire::Calls::WAIT_FOR_AUTHENTICATION => WaitForAuthentication::Result.method(:deserialize),
+        Wire::Calls::CREATE_ACTION => CreateActionResult.method(:deserialize),
+        Wire::Calls::SIGN_ACTION => SignActionResult.method(:deserialize),
+        Wire::Calls::ABORT_ACTION => AbortAction.method(:deserialize_result),
+        Wire::Calls::INTERNALIZE_ACTION => InternalizeActionResult.method(:deserialize),
+        Wire::Calls::LIST_ACTIONS => ListActionsResult.method(:deserialize),
+        Wire::Calls::LIST_OUTPUTS => ListOutputs.method(:deserialize_result),
+        Wire::Calls::RELINQUISH_OUTPUT => RelinquishOutput.method(:deserialize_result),
+        Wire::Calls::ACQUIRE_CERTIFICATE => AcquireCertificate.method(:deserialize_result),
+        Wire::Calls::LIST_CERTIFICATES => ListCertificates.method(:deserialize_result),
+        Wire::Calls::PROVE_CERTIFICATE => ProveCertificate.method(:deserialize_result),
+        Wire::Calls::RELINQUISH_CERTIFICATE => RelinquishCertificate.method(:deserialize_result),
+        Wire::Calls::DISCOVER_BY_IDENTITY_KEY => DiscoverByIdentityKey.method(:deserialize_result),
+        Wire::Calls::DISCOVER_BY_ATTRIBUTES => DiscoverByAttributes.method(:deserialize_result)
+      }.freeze
+
+      # Server-side: deserialise incoming args payload for each call.
+      DESERIALIZE_ARGS = {
+        Wire::Calls::GET_PUBLIC_KEY => GetPublicKey::Args.method(:deserialize),
+        Wire::Calls::REVEAL_COUNTERPARTY_KEY_LINKAGE => RevealCounterpartyKeyLinkage::Args.method(:deserialize),
+        Wire::Calls::REVEAL_SPECIFIC_KEY_LINKAGE => RevealSpecificKeyLinkage::Args.method(:deserialize),
+        Wire::Calls::ENCRYPT => Encrypt::Args.method(:deserialize),
+        Wire::Calls::DECRYPT => Decrypt::Args.method(:deserialize),
+        Wire::Calls::CREATE_HMAC => CreateHmac::Args.method(:deserialize),
+        Wire::Calls::VERIFY_HMAC => VerifyHmac::Args.method(:deserialize),
+        Wire::Calls::CREATE_SIGNATURE => CreateSignature::Args.method(:deserialize),
+        Wire::Calls::VERIFY_SIGNATURE => VerifySignature::Args.method(:deserialize),
+        Wire::Calls::GET_NETWORK => GetNetwork::Args.method(:deserialize),
+        Wire::Calls::GET_VERSION => GetVersion::Args.method(:deserialize),
+        Wire::Calls::GET_HEIGHT => GetHeight::Args.method(:deserialize),
+        Wire::Calls::GET_HEADER_FOR_HEIGHT => GetHeaderForHeight::Args.method(:deserialize),
+        Wire::Calls::IS_AUTHENTICATED => IsAuthenticated::Args.method(:deserialize),
+        Wire::Calls::WAIT_FOR_AUTHENTICATION => WaitForAuthentication::Args.method(:deserialize),
+        Wire::Calls::CREATE_ACTION => CreateActionArgs.method(:deserialize),
+        Wire::Calls::SIGN_ACTION => SignActionArgs.method(:deserialize),
+        Wire::Calls::ABORT_ACTION => AbortAction.method(:deserialize_args),
+        Wire::Calls::INTERNALIZE_ACTION => InternalizeActionArgs.method(:deserialize),
+        Wire::Calls::LIST_ACTIONS => ListActionsArgs.method(:deserialize),
+        Wire::Calls::LIST_OUTPUTS => ListOutputs.method(:deserialize_args),
+        Wire::Calls::RELINQUISH_OUTPUT => RelinquishOutput.method(:deserialize_args),
+        Wire::Calls::ACQUIRE_CERTIFICATE => AcquireCertificate.method(:deserialize_args),
+        Wire::Calls::LIST_CERTIFICATES => ListCertificates.method(:deserialize_args),
+        Wire::Calls::PROVE_CERTIFICATE => ProveCertificate.method(:deserialize_args),
+        Wire::Calls::RELINQUISH_CERTIFICATE => RelinquishCertificate.method(:deserialize_args),
+        Wire::Calls::DISCOVER_BY_IDENTITY_KEY => DiscoverByIdentityKey.method(:deserialize_args),
+        Wire::Calls::DISCOVER_BY_ATTRIBUTES => DiscoverByAttributes.method(:deserialize_args)
+      }.freeze
+
+      # Server-side: serialise outgoing result for each call.
+      SERIALIZE_RESULT = {
+        Wire::Calls::GET_PUBLIC_KEY => GetPublicKey::Result.method(:serialize),
+        Wire::Calls::REVEAL_COUNTERPARTY_KEY_LINKAGE => RevealCounterpartyKeyLinkage::Result.method(:serialize),
+        Wire::Calls::REVEAL_SPECIFIC_KEY_LINKAGE => RevealSpecificKeyLinkage::Result.method(:serialize),
+        Wire::Calls::ENCRYPT => Encrypt::Result.method(:serialize),
+        Wire::Calls::DECRYPT => Decrypt::Result.method(:serialize),
+        Wire::Calls::CREATE_HMAC => CreateHmac::Result.method(:serialize),
+        Wire::Calls::VERIFY_HMAC => VerifyHmac::Result.method(:serialize),
+        Wire::Calls::CREATE_SIGNATURE => CreateSignature::Result.method(:serialize),
+        Wire::Calls::VERIFY_SIGNATURE => VerifySignature::Result.method(:serialize),
+        Wire::Calls::GET_NETWORK => GetNetwork::Result.method(:serialize),
+        Wire::Calls::GET_VERSION => GetVersion::Result.method(:serialize),
+        Wire::Calls::GET_HEIGHT => GetHeight::Result.method(:serialize),
+        Wire::Calls::GET_HEADER_FOR_HEIGHT => GetHeaderForHeight::Result.method(:serialize),
+        Wire::Calls::IS_AUTHENTICATED => IsAuthenticated::Result.method(:serialize),
+        Wire::Calls::WAIT_FOR_AUTHENTICATION => WaitForAuthentication::Result.method(:serialize),
+        Wire::Calls::CREATE_ACTION => CreateActionResult.method(:serialize),
+        Wire::Calls::SIGN_ACTION => SignActionResult.method(:serialize),
+        Wire::Calls::ABORT_ACTION => AbortAction.method(:serialize_result),
+        Wire::Calls::INTERNALIZE_ACTION => InternalizeActionResult.method(:serialize),
+        Wire::Calls::LIST_ACTIONS => ListActionsResult.method(:serialize),
+        Wire::Calls::LIST_OUTPUTS => ListOutputs.method(:serialize_result),
+        Wire::Calls::RELINQUISH_OUTPUT => RelinquishOutput.method(:serialize_result),
+        Wire::Calls::ACQUIRE_CERTIFICATE => AcquireCertificate.method(:serialize_result),
+        Wire::Calls::LIST_CERTIFICATES => ListCertificates.method(:serialize_result),
+        Wire::Calls::PROVE_CERTIFICATE => ProveCertificate.method(:serialize_result),
+        Wire::Calls::RELINQUISH_CERTIFICATE => RelinquishCertificate.method(:serialize_result),
+        Wire::Calls::DISCOVER_BY_IDENTITY_KEY => DiscoverByIdentityKey.method(:serialize_result),
+        Wire::Calls::DISCOVER_BY_ATTRIBUTES => DiscoverByAttributes.method(:serialize_result)
+      }.freeze
+    end
+  end
+end