mms-client 1.6.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

mms_client/security/certs.py

@@ -1,14 +1,24 @@
 """Contains functionality associated with certificates."""
 
 from pathlib import Path
+from ssl import PROTOCOL_TLSv1_2
 from typing import Union
 
+from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey
+from cryptography.hazmat.primitives.serialization import Encoding
+from cryptography.hazmat.primitives.serialization import NoEncryption
+from cryptography.hazmat.primitives.serialization import PrivateFormat
+from cryptography.hazmat.primitives.serialization import PublicFormat
+from cryptography.hazmat.primitives.serialization.pkcs12 import load_key_and_certificates
 from requests_pkcs12 import Pkcs12Adapter
 
 
 class Certificate:
     """Describes a certificate composed of a cert file and a key file."""
 
+    # The encoding to use for MMS certificates
+    encoding = Encoding.PEM
+
     def __init__(self, cert: Union[str, Path, bytes], passphrase: str):
         """Create a new Certificate.
 
@@ -29,6 +39,13 @@ class Certificate:
         # Save the passphrase
         self._passphrase = passphrase
 
+        # Load the private key using the cryptography library
+        private_key, _, _ = load_key_and_certificates(self._cert, self._passphrase.encode("UTF-8"))
+        if isinstance(private_key, RSAPrivateKey):
+            self._private = private_key
+        else:
+            raise TypeError(f"Private key of type ({type(private_key).__name__}) was not expected.")
+
     @property
     def certificate(self) -> bytes:
         """Return the certificate data."""
@@ -39,6 +56,22 @@ class Certificate:
         """Return the full path to the passphrase."""
         return self._passphrase
 
+    def public_key(self) -> bytes:
+        """Extract the public key from the certificate.
+
+        Returns: The public key in PEM format.
+        """
+        return self._private.public_key().public_bytes(Certificate.encoding, PublicFormat.PKCS1)
+
+    def private_key(self) -> bytes:
+        """Extract the private key from the certificate.
+
+        THIS SHOULD NOT, UNDER ANY CIRCUMSTANCES, BE PRINTED OR LOGGED!!!
+
+        Returns: The private key in PEM format.
+        """
+        return self._private.private_bytes(Certificate.encoding, PrivateFormat.PKCS8, NoEncryption())
+
     def to_adapter(self) -> Pkcs12Adapter:
         """Convert the certificate to a Pkcs12Adapter."""
-        return Pkcs12Adapter(pkcs12_data=self._cert, pkcs12_password=self._passphrase)
+        return Pkcs12Adapter(pkcs12_data=self._cert, pkcs12_password=self._passphrase, ssl_protocol=PROTOCOL_TLSv1_2)

mms_client/security/crypto.py

@@ -1,13 +1,11 @@
 """Contains objects for cryptographic operations."""
 
+from base64 import b64decode
 from base64 import b64encode
-from hashlib import sha256
 
-from cryptography.hazmat.backends import default_backend
-from cryptography.hazmat.primitives import hashes
-from cryptography.hazmat.primitives.asymmetric import padding
-from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey
-from cryptography.hazmat.primitives.serialization.pkcs12 import load_key_and_certificates
+from Cryptodome.Hash import SHA256
+from Cryptodome.PublicKey import RSA
+from Cryptodome.Signature import pkcs1_15
 
 from mms_client.security.certs import Certificate
 
@@ -21,23 +19,33 @@ class CryptoWrapper:
         Arguments:
         cert (Certificate): The certificate to use for cryptographic operations.
         """
-        # First, save our certificate for later use
-        self._cert = cert
+        # Extract the public key and private key data from the certificate
+        private_key = RSA.import_key(cert.private_key())
+        public_key = RSA.import_key(cert.public_key())
 
-        # Next, import the private key from the certificate
-        private_key, _, _ = load_key_and_certificates(
-            self._cert.certificate, self._cert.passphrase.encode(), default_backend()
-        )
+        # Create a new signer from the private key and a new verifier from the public key
+        self._signer = pkcs1_15.new(private_key)
+        self._verifier = pkcs1_15.new(public_key)
 
-        # Now, we need to assert typing on this private key to make mypy happy
-        if isinstance(private_key, RSAPrivateKey):
-            self._private_key = private_key
-        else:
-            raise TypeError(f"Private key of type ({type(private_key).__name__}) was not expected.")
+    def verify(self, content: bytes, signature: bytes) -> bool:
+        """Verify a signature against the given content using the certificate.
 
-        # Finally, save our padding and algorithm for later use
-        self._padding = padding.PKCS1v15()
-        self._algorithm = hashes.SHA256()
+        Arguments:
+        content (bytes):    The content to verify.
+        signature (bytes):  The signature to verify against the content.
+
+        Returns:    True if the signature is valid, False otherwise.
+        """
+        # Hash the content using SHA256
+        hashed = SHA256.new(content)
+
+        # Verify the signature using the public key. This will raise a ValueError if the signature is invalid.
+        # We catch this exception and return False to indicate that the signature is invalid.
+        try:
+            self._verifier.verify(hashed, b64decode(signature))
+            return True
+        except ValueError:
+            return False
 
     def sign(self, data: bytes) -> bytes:
         """Create a signature from the given data using the certificate.
@@ -48,10 +56,10 @@ class CryptoWrapper:
         Returns:    A base64-encoded string containing the signature.
         """
         # First, hash the data using SHA256
-        hashed = sha256(data)
+        hashed = SHA256.new(data)
 
         # Next, sign the hash using the private key
-        signature = self._private_key.sign(hashed.digest(), self._padding, self._algorithm)
+        signature = self._signer.sign(hashed)
 
         # Finally, return the base64-encoded signature
         return b64encode(signature)

mms_client/services/base.py

@@ -1,5 +1,6 @@
 """Contains the client layer for communicating with the MMS server."""
 
+from base64 import b64decode
 from dataclasses import dataclass
 from logging import getLogger
 from typing import Dict
@@ -52,26 +53,33 @@ class ServiceConfiguration:
 
 
 @dataclass
-class EndpointConfiguration(Generic[E, P]):
+class EndpointConfiguration(Generic[E, P]):  # pylint: disable=too-many-instance-attributes
     """Configuration for an endpoint on the MMS server."""
 
     # The name of the endpoint
     name: str
 
-    # The allowed client types for the endpoint
-    allowed_clients: Optional[List[ClientType]]
-
     # The service for the endpoint
     service: ServiceConfiguration
 
     # The type of request to submit to the MMS server
     request_type: RequestType
 
+    # The allowed client types for the endpoint
+    allowed_clients: Optional[List[ClientType]] = None
+
     # The type of payload to expect in the response
-    response_envelope_type: Optional[Type[E]]
+    response_envelope_type: Optional[Type[E]] = None
 
     # The type of data to expect in the response
-    response_data_type: Optional[Type[P]]
+    response_data_type: Optional[Type[P]] = None
+
+    # Whether the endpoint is for a report request
+    for_report: bool = False
+
+    # An optional serializer used to deserialize the response data for the service. This is only used for report
+    # requests because they have a separate XSD file for responses.
+    serializer: Optional[Serializer] = None
 
 
 class ClientProto(Protocol):
@@ -85,6 +93,10 @@ class ClientProto(Protocol):
     def user(self) -> str:
         """Return the user name of the person making the request."""
 
+    @property
+    def client_type(self) -> ClientType:
+        """Return the type of client to use for making requests to the MMS server."""
+
     def verify_audience(self, config: EndpointConfiguration) -> None:
         """Verify that the client type is allowed.
 
@@ -131,14 +143,7 @@ class ClientProto(Protocol):
         """
 
 
-def mms_endpoint(
-    name: str,
-    service: ServiceConfiguration,
-    request_type: RequestType,
-    allowed_clients: Optional[List[ClientType]] = None,
-    resp_envelope_type: Optional[Type[E]] = None,
-    resp_data_type: Optional[Type[P]] = None,
-):
+def mms_endpoint(**kwargs):
     """Create a decorator for an MMS endpoint.
 
     This decorator is used to mark a method as an MMS endpoint. It will add the endpoint configuration to the function
@@ -151,13 +156,16 @@ def mms_endpoint(
     request_type (RequestType):         The type of request to submit to the MMS server.
     allowed_clients (List[ClientType]): The types of clients that are allowed to access the endpoint. If this is not
                                         provided, then any client will be allowed.
-    resp_envelope_type (Type[E]):       The type of payload to expect in the response. If this is not provided, then the
+    response_envelope_type (Type[E]):   The type of payload to expect in the response. If this is not provided, then the
                                         response envelope will be assumed to have the same type as the request envelope.
-    resp_data_type (Type[P]):           The type of data to expect in the response. If this is not provided, then the
+    response_data_type (Type[P]):       The type of data to expect in the response. If this is not provided, then the
                                         response data will be assumed to have the same type as the request data.
+    for_report (bool):                  If True, the endpoint is for a report request.
+    serializer (Serializer):            The serializer to use for responses from the endpoint. Overrides the default
+                                        serializer for the service.
     """
     # First, create the endpoint configuration from the given parameters
-    config = EndpointConfiguration(name, allowed_clients, service, request_type, resp_envelope_type, resp_data_type)
+    config = EndpointConfiguration(**kwargs)
 
     # Next, create a decorator that will add the endpoint configuration to the function
     def decorator(func):
@@ -168,10 +176,18 @@ def mms_endpoint(
             self.verify_audience(config)
 
             # Next, call the wrapped function to get the envelope
-            envelope = func(self, *args, **kwargs)
+            result = func(self, *args, **kwargs)
+            if isinstance(result, tuple):
+                envelope, callback = result
+            else:
+                envelope, callback = result, None
 
             # Now, submit the request to the MMS server and get the response
-            resp, _ = self.request_one(envelope, args[0], config)
+            resp, attachments = self.request_one(envelope, args[0], config)
+
+            # Call the callback function if it was provided
+            if callback:
+                callback(resp, attachments)
 
             # Finally, extract the data from the response and return it
             logger.info(f"{config.name}: Returning {type(resp.data).__name__} data.")
@@ -183,14 +199,7 @@ def mms_endpoint(
     return decorator
 
 
-def mms_multi_endpoint(
-    name: str,
-    service: ServiceConfiguration,
-    request_type: RequestType,
-    allowed_clients: Optional[List[ClientType]] = None,
-    resp_envelope_type: Optional[Type[E]] = None,
-    resp_data_type: Optional[Type[P]] = None,
-):
+def mms_multi_endpoint(**kwargs):
     """Create a decorator for an MMS multi-response endpoint.
 
     This decorator is used to mark a method as an MMS multi-response endpoint. It will add the endpoint configuration to
@@ -204,17 +213,20 @@ def mms_multi_endpoint(
     request_type (RequestType):         The type of request to submit to the MMS server.
     allowed_clients (List[ClientType]): The types of clients that are allowed to access the endpoint. If this is not
                                         provided, then any client will be allowed.
-    resp_envelope_type (Type[E]):       The type of payload to expect in the response. If this is not provided, then
+    response_envelope_type (Type[E]):   The type of payload to expect in the response. If this is not provided, then
                                         the response envelope will be assumed to have the same type as the request
                                         envelope.
-    resp_data_type (Type[P]):           The type of data to expect in the response. If this is not provided, then the
+    response_data_type (Type[P]):       The type of data to expect in the response. If this is not provided, then the
                                         response data will be assumed to have the same type as the request data. Note,
                                         that this is not intended to account for the expected sequence type of the
                                         response data. That is already handled in the wrapped function, so this should
                                         only be set if the inner data type being returned differs from what was sent.
+    for_report (bool):                  If True, the endpoint is for a report request.
+    serializer (Serializer):            The serializer to use for responses from the endpoint. Overrides the default
+                                        serializer for the service.
     """
     # First, create the endpoint configuration from the given parameters
-    config = EndpointConfiguration(name, allowed_clients, service, request_type, resp_envelope_type, resp_data_type)
+    config = EndpointConfiguration(**kwargs)
 
     # Next, create a decorator that will add the endpoint configuration to the function
     def decorator(func):
@@ -225,10 +237,18 @@ def mms_multi_endpoint(
             self.verify_audience(config)
 
             # Next, call the wrapped function to get the envelope
-            envelope = func(self, *args, **kwargs)
+            result = func(self, *args, **kwargs)
+            if isinstance(result, tuple):
+                envelope, callback = result  # pragma: no cover
+            else:
+                envelope, callback = result, None
 
             # Now, submit the request to the MMS server and get the response
-            resp, _ = self.request_many(envelope, args[0], config)
+            resp, attachments = self.request_many(envelope, args[0], config)
+
+            # Call the callback function if it was provided
+            if callback:
+                callback(resp, attachments)  # pragma: no cover
 
             # Finally, extract the data from the response and return it
             logger.info(f"{config.name}: Returning {len(resp.data)} item(s).")
@@ -248,6 +268,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
 
     def __init__(
         self,
+        domain: str,
         participant: str,
         user: str,
         client_type: ClientType,
@@ -259,6 +280,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         """Create a new MMS client with the given participant, user, client type, and authentication.
 
         Arguments:
+        domain (str):               The domain to use when signing the content ID to MTOM attachments.
         participant (str):          The MMS code of the business entity to which the requesting user belongs.
         user (str):                 The user name of the person making the request.
         client_type (ClientType):   The type of client to use for making requests to the MMS server.
@@ -269,6 +291,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         test (bool):                Whether to use the test server.
         """
         # First, save the base field associated with the client
+        self._domain = domain
         self._participant = participant
         self._user = user
         self._client_type = client_type
@@ -295,6 +318,11 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         """Return the user name of the person making the request."""
         return self._user
 
+    @property
+    def client_type(self) -> ClientType:
+        """Return the type of client to use for making requests to the MMS server."""
+        return self._client_type
+
     def verify_audience(self, config: EndpointConfiguration) -> None:
         """Verify that the client type is allowed.
 
@@ -329,23 +357,29 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
 
         Returns:    The response from the MMS server.
         """
+        # Create a new ZWrapper for the given service
+        wrapper = self._get_wrapper(config.service)
+
         # First, create the MMS request from the payload and data.
         logger.debug(
             f"{config.name}: Starting request. Envelope: {type(envelope).__name__}, Data: {type(payload).__name__}",
         )
-        request = self._to_mms_request(config.request_type, config.service.serializer.serialize(envelope, payload))
+        request = self._to_mms_request(
+            wrapper, config.request_type, config.service.serializer.serialize(envelope, payload, config.for_report)
+        )
 
         # Next, submit the request to the MMS server and get and verify the response.
-        resp = self._get_wrapper(config.service).submit(request)
+        resp = wrapper.submit(request)
         self._verify_mms_response(resp, config)
 
         # Now, extract the attachments from the response
-        attachments = {a.name: a.data for a in resp.attachments}
+        attachments = {a.name: b64decode(a.data) for a in resp.attachments}
 
         # Finally, deserialize and verify the response
         envelope_type = config.response_envelope_type or type(envelope)
         data_type = config.response_data_type or type(payload)
-        data: Response[E, P] = config.service.serializer.deserialize(resp.payload, envelope_type, data_type)
+        deserializer = config.serializer or config.service.serializer
+        data: Response[E, P] = deserializer.deserialize(resp.payload, envelope_type, data_type, config.for_report)
         self._verify_response(data, config)
 
         # Return the response data and any attachments
@@ -369,6 +403,9 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
 
         Returns:    The multi-response from the MMS server.
         """
+        # Create a new ZWrapper for the given service
+        wrapper = self._get_wrapper(config.service)
+
         # First, create the MMS request from the payload and data.
         is_list = isinstance(payload, list)
         data_type = type(payload[0]) if is_list else type(payload)  # type: ignore[index]
@@ -379,26 +416,30 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
             ),
         )
         serialized = (
-            config.service.serializer.serialize_multi(envelope, payload, data_type)  # type: ignore[arg-type]
+            config.service.serializer.serialize_multi(
+                envelope, payload, data_type, config.for_report  # type: ignore[arg-type]
+            )
             if is_list
-            else config.service.serializer.serialize(envelope, payload)  # type: ignore[type-var]
+            else config.service.serializer.serialize(envelope, payload, config.for_report)  # type: ignore[type-var]
         )
-        request = self._to_mms_request(config.request_type, serialized)
+        request = self._to_mms_request(wrapper, config.request_type, serialized)
 
         # Next, submit the request to the MMS server and get and verify the response.
-        resp = self._get_wrapper(config.service).submit(request)
+        resp = wrapper.submit(request)
         self._verify_mms_response(resp, config)
 
         # Now, extract the attachments from the response
-        attachments = {a.name: a.data for a in resp.attachments}
+        attachments = {a.name: b64decode(a.data) for a in resp.attachments}
 
         # Finally, deserialize and verify the response
         envelope_type = config.response_envelope_type or type(envelope)
         data_type = config.response_data_type or data_type
-        data: MultiResponse[E, P] = config.service.serializer.deserialize_multi(
+        deserializer = config.serializer or config.service.serializer
+        data: MultiResponse[E, P] = deserializer.deserialize_multi(
             resp.payload,
             envelope_type,
             data_type,  # type: ignore[arg-type]
+            config.for_report,
         )
         self._verify_multi_response(data, config)
 
@@ -410,6 +451,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
 
     def _to_mms_request(
         self,
+        client: ZWrapper,
         req_type: RequestType,
         data: bytes,
         return_req: bool = False,
@@ -418,6 +460,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         """Convert the given data to an MMS request.
 
         Arguments:
+        client (ZWrapper):              The Zeep client to use for submitting the request.
         req_type (RequestType):         The type of request to submit to the MMS server.
         data (bytes):                   The data to submit to the MMS server.
         return_req (bool):              Whether to return the request data in the response. This is False by default.
@@ -425,16 +468,14 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
 
         Arguments:    The MMS request to submit to the MMS server.
         """
-        # Convert the attachments to the correct the MMS format
+        # First, convert the attachments to the correct the MMS format
         attachment_data = (
-            [
-                Attachment(signature=self._signer.sign(data), name=name, binaryData=data)
-                for name, data in attachments.items()
-            ]
-            if attachments
-            else []
+            [self._to_mms_attachment(client, name, data) for name, data in attachments.items()] if attachments else []
         )
 
+        # Next, convert the payload to a base-64 string
+        tag, signature = self._register_and_sign(client, "payload", data)
+
         # Embed the data and the attachments in the MMS request and return it
         logger.debug(
             f"Creating MMS request of type {req_type.name} to send {len(data)} bytes of data and "
@@ -445,11 +486,36 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
             adminRole=self._is_admin,
             requestDataType=RequestDataType.XML,
             sendRequestDataOnSuccess=return_req,
-            requestSignature=self._signer.sign(data),
-            requestData=data,
+            requestSignature=signature,
+            requestData=tag,
             attachmentData=attachment_data,
         )
 
+    def _to_mms_attachment(self, client: ZWrapper, name: str, data: bytes) -> Attachment:  # pragma: no cover
+        """Convert the given data to an MMS attachment.
+
+        Arguments:
+        client (ZWrapper):  The Zeep client to use for submitting the request.
+        name (str):         The name of the attachment.
+        data (bytes):       The data to be attached.
+
+        Returns:    The MMS attachment.
+        """
+        # Convert the data to a base-64 string
+        tag, signature = self._register_and_sign(client, name, data)
+
+        # Create the MMS attachment and return it
+        return Attachment(signature=signature, name=name, binaryData=tag)
+
+    def _register_and_sign(self, client: ZWrapper, name: str, data: bytes) -> Tuple[str, str]:
+        tag = client.register_attachment(name, data)
+
+        # Next, sign the data
+        signature = self._signer.sign(data)
+
+        # Finally, convert the encoded data to a string and return it and the signature
+        return tag, signature.decode("UTF-8")
+
     def _verify_mms_response(self, resp: MmsResponse, config: EndpointConfiguration) -> None:
         """Verify that the given MMS response is valid.
 
@@ -537,18 +603,18 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         Returns:    True to indicate that the response is valid, False otherwise.
         """
         # Log the request's processing statistics
-        logger.info(
-            f"{config.name} ({resp.statistics.timestamp_xml}): Recieved {resp.statistics.received}, "
-            f"Valid: {resp.statistics.valid}, Invalid: {resp.statistics.invalid}, "
-            f"Successful: {resp.statistics.successful}, Unsuccessful: {resp.statistics.unsuccessful} "
-            f"in {resp.statistics.time_ms}ms"
-        )
+        if resp.statistics is not None:
+            logger.info(
+                f"{config.name} ({resp.statistics.timestamp_xml}): Recieved {resp.statistics.received}, "
+                f"Valid: {resp.statistics.valid}, Invalid: {resp.statistics.invalid}, "
+                f"Successful: {resp.statistics.successful}, Unsuccessful: {resp.statistics.unsuccessful} "
+                f"in {resp.statistics.time_ms}ms"
+            )
 
         # Check if the response is invalid and if the envelope had any validation issues. If not, then we have a
         # valid base response so return True. Otherwise, return False.
-        return resp.statistics.invalid == 0 and self._verify_response_common(
-            config, type(resp.envelope), resp.envelope_validation
-        )
+        is_invalid = resp.statistics is not None and resp.statistics.invalid
+        return not is_invalid and self._verify_response_common(config, type(resp.envelope), resp.envelope_validation)
 
     def _verify_messages(self, config: EndpointConfiguration, resp: BaseResponse[E]) -> None:
         """Verify the messages in the given response.
@@ -558,12 +624,12 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         resp (BaseResponse):            The response to verify.
         """
         for path, messages in resp.messages.items():
-            for info in messages.information:
-                logger.info(f"{config.name} - {path}: {info.code}")
-            for warning in messages.warnings:
-                logger.warning(f"{config.name} - {path}: {warning.code}")
-            for error in messages.errors:
-                logger.error(f"{config.name} - {path}: {error.code}")
+            for info in messages.information:  # type: ignore[union-attr]
+                logger.info(f"{config.name} - {path}: {info}")
+            for warning in messages.warnings:  # type: ignore[union-attr]
+                logger.warning(f"{config.name} - {path}: {warning}")
+            for error in messages.errors:  # type: ignore[union-attr]
+                logger.error(f"{config.name} - {path}: {error}")
 
     def _verify_response_common(
         self, config: EndpointConfiguration, payload_type: type, resp: ResponseCommon, index: Optional[int] = None
@@ -597,6 +663,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         if service.interface not in self._wrappers:
             logger.debug(f"Creating wrapper for {service.interface.name} interface.")
             self._wrappers[service.interface] = ZWrapper(
+                self._domain,
                 self._client_type,
                 service.interface,
                 self._cert.to_adapter(),

mms_client/services/market.py

@@ -37,14 +37,14 @@ class MarketClientMixin:  # pylint: disable=unused-argument
     config = ServiceConfiguration(Interface.MI, Serializer(SchemaType.MARKET, "MarketData"))
 
     @mms_endpoint(
-        "MarketQuery_ReserveRequirementQuery",
-        config,
-        RequestType.INFO,
-        resp_envelope_type=MarketSubmit,
-        resp_data_type=ReserveRequirement,
+        name="MarketQuery_ReserveRequirementQuery",
+        service=config,
+        request_type=RequestType.INFO,
+        response_envelope_type=MarketSubmit,
+        response_data_type=ReserveRequirement,
     )
     def query_reserve_requirements(
-        self: ClientProto, request: ReserveRequirementQuery, date: Optional[Date] = None
+        self: ClientProto, request: ReserveRequirementQuery, days: int, date: Optional[Date] = None
     ) -> List[ReserveRequirement]:
         """Query the MMS server for reserve requirements.
 
@@ -54,6 +54,7 @@ class MarketClientMixin:  # pylint: disable=unused-argument
         request (ReserveRequirementQuery):  The query to submit to the MMS server.
         date (Date):                        The date of the transaction in the format "YYYY-MM-DD". This value defaults
                                             to the current date.
+        days (int):                         The number of days ahead for which the data is being queried.
 
         Returns:    A list of reserve requirements that match the query.
         """
@@ -62,10 +63,12 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             date=date or Date.today(),
             participant=self.participant,
             user=self.user,
-            days=1,
+            days=days,
         )
 
-    @mms_endpoint("MarketSubmit_OfferData", config, RequestType.INFO, [ClientType.BSP])
+    @mms_endpoint(
+        name="MarketSubmit_OfferData", service=config, request_type=RequestType.MARKET, allowed_clients=[ClientType.BSP]
+    )
     def put_offer(
         self: ClientProto, request: OfferData, market_type: MarketType, days: int, date: Optional[Date] = None
     ) -> OfferData:
@@ -91,7 +94,9 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             days=days,
         )
 
-    @mms_multi_endpoint("MarketSubmit_OfferData", config, RequestType.INFO, [ClientType.BSP])
+    @mms_multi_endpoint(
+        name="MarketSubmit_OfferData", service=config, request_type=RequestType.MARKET, allowed_clients=[ClientType.BSP]
+    )
     def put_offers(
         self: ClientProto, requests: List[OfferData], market_type: MarketType, days: int, date: Optional[Date] = None
     ) -> List[OfferData]:
@@ -118,7 +123,11 @@ class MarketClientMixin:  # pylint: disable=unused-argument
         )
 
     @mms_multi_endpoint(
-        "MarketQuery_OfferQuery", config, RequestType.INFO, resp_envelope_type=MarketSubmit, resp_data_type=OfferData
+        name="MarketQuery_OfferQuery",
+        service=config,
+        request_type=RequestType.MARKET,
+        response_envelope_type=MarketSubmit,
+        response_data_type=OfferData,
     )
     def query_offers(self: ClientProto, request: OfferQuery, days: int, date: Optional[Date] = None) -> List[OfferData]:
         """Query the MMS server for offers.
@@ -141,7 +150,12 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             days=days,
         )
 
-    @mms_endpoint("MarketCancel_OfferCancel", config, RequestType.INFO, [ClientType.BSP])
+    @mms_endpoint(
+        name="MarketCancel_OfferCancel",
+        service=config,
+        request_type=RequestType.MARKET,
+        allowed_clients=[ClientType.BSP],
+    )
     def cancel_offer(
         self: ClientProto, request: OfferCancel, market_type: MarketType, days: int, date: Optional[Date] = None
     ) -> OfferCancel:
@@ -167,7 +181,12 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             days=days,
         )
 
-    @mms_endpoint("MarketQuery_AwardResultsQuery", config, RequestType.INFO, resp_data_type=AwardResponse)
+    @mms_endpoint(
+        name="MarketQuery_AwardResultsQuery",
+        service=config,
+        request_type=RequestType.MARKET,
+        response_data_type=AwardResponse,
+    )
     def query_awards(self: ClientProto, request: AwardQuery, days: int, date: Optional[Date] = None) -> AwardResponse:
         """Query the MMS server for award results.