Transaction

AsyncTransaction

Bases: BaseAsyncAPIWrapper

Source code in pykuda2/wrappers/async_wrappers/transaction.py

class AsyncTransaction(BaseAsyncAPIWrapper):
    async def get_banks(self, request_reference: Optional[str] = None) -> APIResponse:
        """Retrieves all the banks available from NIPS

         In production, the list of banks and bank codes may change based on
         the responses gotten from NIBSS (Nigerian Interbank Settlement System).

         Args:
             request_reference: a unique identifier for this api call.
                it is automatically generated if not provided.

         Returns:
            An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
                of calling this function.

        Raises:
            ConnectionException: when the request times out or in the absence of an internet connection.
        """
        return await self._api_call(
            service_type=ServiceType.BANK_LIST, request_reference=request_reference
        )

    async def confirm_transfer_recipient(
        self,
        beneficiary_account_number: str,
        beneficiary_bank_code: str,
        sender_tracking_reference: Optional[str],
        is_request_from_virtual_account: bool,
        request_reference: Optional[str] = None,
    ) -> APIResponse:
        """
        Retrieves information of a beneficiary for validation before initiating a transfer.

        Args:
            beneficiary_account_number: Destination bank account number.
            beneficiary_bank_code: Destination bank code.
            sender_tracking_reference: Tracking reference of the virtual account trying to
                do the actual transfer. Leave it empty if the intended transfer is going to
                be from the main account.
            is_request_from_virtual_account: If the intended transfer is to be made by the
                virtual account.
            request_reference: a unique identifier for this api call.
                it is automatically generated if not provided.

        Returns:
            An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
                of calling this function.

        Raises:
            ConnectionException: when the request times out or in the absence of an internet connection.
        """
        data = {
            "beneficiaryAccountNumber": beneficiary_account_number,
            "beneficiaryBankCode": beneficiary_bank_code,
            "SenderTrackingReference": sender_tracking_reference,
            "isRequestFromVirtualAccount": is_request_from_virtual_account,
        }
        return await self._api_call(
            service_type=ServiceType.NAME_ENQUIRY,
            data=data,
            request_reference=request_reference,
        )

    async def fund_transfer(
        self,
        beneficiary_account: str,
        beneficiary_bank_code: str,
        beneficiary_name: str,
        amount: Union[int, float],
        narration: str,
        name_enquiry_session_id: str,
        sender_name: str,
        client_fee_charge: int = 0,
        client_account_number: Optional[str] = None,
        request_reference: Optional[str] = None,
    ) -> APIResponse:
        """
        Sends money from your main Kuda account to another bank accounts.

        Please, do not use sensitive data while doing test transactions so
        as not to save it in your sandbox environment.

        Args:
            beneficiary_account: Destination bank account number.
            beneficiary_bank_code: Destination bank code.
            beneficiary_name: Name of the recipient.
            amount: Amount to be transferred. Note care should be taken when performing calculations as money is involved.
                a `Decimal` would have been the preferred type compared to `Union[int, float]` that was used.
                it is advisable that static values are passed for this parameter. see
                https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency
            narration: User defined reason for the transaction.
            name_enquiry_session_id: Session ID generated from the nameEnquiry request.
            sender_name: Name of the person sending money.
            client_fee_charge: It is an amount a client wishes to charge their customer
                for a transfer being carried out.
            client_account_number: Account number of the client where the charged fee is
                sent to.
            request_reference: a unique identifier for this api call.
                it is automatically generated if not provided.

        Returns:
            An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
                of calling this function.

        Raises:
            ConnectionException: when the request times out or in the absence of an internet connection.
        """
        data = {
            "ClientAccountNumber": client_account_number,
            "beneficiaryAccount": beneficiary_account,
            "beneficiaryBankCode": beneficiary_bank_code,
            "beneficiaryName": beneficiary_name,
            "amount": amount,
            "narration": narration,
            "nameEnquirySessionID": name_enquiry_session_id,
            "senderName": sender_name,
            "clientFeeCharge": client_fee_charge,
        }
        return await self._api_call(
            service_type=ServiceType.SINGLE_FUND_TRANSFER,
            data=data,
            request_reference=request_reference,
        )

    async def virtual_account_fund_transfer(
        self,
        tracking_reference: str,
        beneficiary_account: str,
        amount: Union[int, float],
        beneficiary_name: str,
        narration: str,
        beneficiary_bank_code: str,
        sender_name: str,
        name_enquiry_id: str,
        client_fee_charge: Union[int, float] = 0,
        client_account_number: Optional[str] = None,
        request_reference: Optional[str] = None,
    ) -> APIResponse:
        """Transfer money from a virtual account to another and any other Nigerian bank account.

        Args:
            tracking_reference: Unique identifier of the sender.
            beneficiary_account: Destination bank account number.
            beneficiary_bank_code: Destination bank code.
            beneficiary_name: Name of the recipient.
            amount: Amount to be transferred. Note care should be taken when performing calculations as money is involved.
                a `Decimal` would have been the preferred type compared to `Union[int, float]` that was used.
                it is advisable that static values are passed for this parameter. see
                https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency
            narration: User defined reason for the transaction.
            name_enquiry_id: Session ID generated from the nameEnquiry request.
            sender_name: Name of the person sending money.
            client_fee_charge: It is an amount a client wishes to charge their customer
                for a transfer being carried out. Note care should be taken when performing calculations as money is involved.
                a `Decimal` would have been the preferred type compared to `Union[int, float]` that was used.
                it is advisable that static values are passed for this parameter. see
                https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency
            client_account_number: Account number of the client where the charged fee is
                sent to.
            request_reference: a unique identifier for this api call.
                it is automatically generated if not provided.

        Returns:
            An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
                of calling this function.

        Raises:
            ConnectionException: when the request times out or in the absence of an internet connection.
        """
        data = {
            "trackingReference": tracking_reference,
            "beneficiaryAccount": beneficiary_account,
            "amount": amount,
            "narration": narration,
            "beneficiaryBankCode": beneficiary_bank_code,
            "beneficiaryName": beneficiary_name,
            "senderName": sender_name,
            "nameEnquiryId": name_enquiry_id,
            "clientFeeCharge": client_fee_charge,
            "ClientAccountNumber": client_account_number,
        }
        return await self._api_call(
            service_type=ServiceType.VIRTUAL_ACCOUNT_FUND_TRANSFER,
            data=data,
            request_reference=request_reference,
        )

    async def process_transfers(
        self,
        fund_transfer_instructions: list[TransferInstruction],
        request_reference: Optional[str] = None,
    ) -> APIResponse:
        """Allows you to send a list of transfer instructions to Kuda, to make the payments on your behalf.

        Args:
            fund_transfer_instructions: A list of transfer instructions for transfers to be made.
            request_reference: a unique identifier for this api call.
                it is automatically generated if not provided.

        Returns:
            An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
                of calling this function.

        Raises:
            ConnectionException: when the request times out or in the absence of an internet connection.
        """
        data = {
            "FundTransferInstructions": [
                fund_transfer_instruction.to_dict()
                for fund_transfer_instruction in fund_transfer_instructions
            ]
        }
        return await self._api_call(
            service_type=ServiceType.FUND_TRANSFER_INSTRUCTION,
            data=data,
            request_reference=request_reference,
        )

    async def get_transfer_instructions(
        self,
        account_number: str,
        reference: str,
        amount: Union[int, float],
        original_request_ref: str,
        status: TransactionStatus,
        page_number: int,
        page_size: int,
        request_reference: Optional[str] = None,
    ) -> APIResponse:
        """Retrieves transfer instructions and returns the status of the transaction.

        Args:
            account_number: The beneficiary’s account number.
            reference: The reference on the transfer instruction.
            amount: The transaction amount. Note care should be taken when performing calculations as money is involved.
                a `Decimal` would have been the preferred type compared to `Union[int, float]` that was used.
                it is advisable that static values are passed for this parameter. see
                https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency
            original_request_ref: The request reference used in logging the instruction.
            status: The status of the transaction.
            page_size: This specifies the number of transfer instructions to be retrieved.
            page_number: This specifies the index of the paginated results retrieved.
            request_reference: a unique identifier for this api call.
                it is automatically generated if not provided.

        Returns:
            An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
                of calling this function.

        Raises:
            ConnectionException: when the request times out or in the absence of an internet connection.
        """
        data = {
            "AccountNumber": account_number,
            "Reference": reference,
            "Amount": amount,
            "OriginalRequestRef": original_request_ref,
            "Status": status,
            "PageNumber": page_number,
            "PageSize": page_size,
        }
        return await self._api_call(
            service_type=ServiceType.SEARCH_FUND_TRANSFER_INSTRUCTION,
            data=data,
            request_reference=request_reference,
        )

    async def get_transaction_logs(
        self,
        request_reference: str,
        response_reference: str,
        transaction_date: str,
        has_transaction_date_range_filter: bool,
        start_date: str,
        end_date: str,
        page_size: int,
        page_number: int,
        fetch_successful_records: bool =False,
    ) -> APIResponse:
        """Retrieves all transactions.

        Args:
            request_reference: a unique identifier for this api call.
                it is automatically generated if not provided.
            response_reference: Transaction response reference.
            fetch_successful_records: If set to `True`, only successful transactions
                will be retrieved.
            transaction_date: The transaction date. Format (YYYY-MM-DD)
            has_transaction_date_range_filter: Is set to `True`, then the `start_date` and
                `end_date` parameter will be used instead of `transaction_date`
            start_date: Transaction start date. Format (YYYY-MM-DD)
            end_date: Transaction end date. Format (YYYY-MM-DD)
            page_size: This specifies the number of transactions to be retrieved.
            page_number: This specifies the index of the paginated results retrieved.

        Returns:
            An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
                of calling this function.

        Raises:
            ConnectionException: when the request times out or in the absence of an internet connection.
        """
        data = {
            "RequestReference": request_reference,
            "ResponseReference": response_reference,
            "FetchSuccessfulRecords": fetch_successful_records,
            "TransactionDate": transaction_date,
            "HasTransactionDateRangeFilter": has_transaction_date_range_filter,
            "StartDate": start_date,
            "EndDate": end_date,
            "PageSize": page_size,
            "PageNumber": page_number,
        }
        return await self._api_call(
            service_type=ServiceType.RETRIEVE_TRANSACTION_LOGS,
            data=data,
            request_reference=request_reference,
        )

    async def get_transaction_history(
        self, page_size: int, page_number: int, request_reference: Optional[str] = None
    ) -> APIResponse:
        """Retrieves a list of all main account transactions.

        Args:
            page_size: This specifies the number of transactions to be retrieved.
            page_number: This specifies the index of the paginated results retrieved.
            request_reference: a unique identifier for this api call.
                it is automatically generated if not provided.

        Returns:
            An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
                of calling this function.

        Raises:
            ConnectionException: when the request times out or in the absence of an internet connection.
        """
        data = {"pageSize": page_size, "pageNumber": page_number}
        return await self._api_call(
            service_type=ServiceType.ADMIN_MAIN_ACCOUNT_TRANSACTIONS,
            data=data,
            request_reference=request_reference,
        )

    async def get_filtered_transaction_history(
        self,
        page_size: int,
        page_number: int,
        start_date: str,
        end_date: str,
        request_reference: Optional[str] = None,
    ) -> APIResponse:
        """Retrieves a filtered transaction history.

        Args:
            start_date: Transaction start date. Format (YYYY-MM-DD)
            end_date: Transaction end date. Format (YYYY-MM-DD)
            page_size: This specifies the number of transactions to be retrieved.
            page_number: This specifies the index of the paginated results retrieved.
            request_reference: a unique identifier for this api call.
                it is automatically generated if not provided.

        Returns:
            An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
                of calling this function.

        Raises:
            ConnectionException: when the request times out or in the absence of an internet connection.
        """
        data = {
            "pageSize": page_size,
            "pageNumber": page_number,
            "startDate": start_date,
            "endDate": end_date,
        }
        return await self._api_call(
            service_type=ServiceType.ADMIN_MAIN_ACCOUNT_FILTERED_TRANSACTIONS,
            data=data,
            request_reference=request_reference,
        )

    async def get_virtual_account_transaction_history(
        self,
        tracking_reference: str,
        page_size: int,
        page_number: int,
        request_reference: Optional[str] = None,
    ) -> APIResponse:
        """Retrieves a list of all virtual account transactions.

        Args:
            tracking_reference: The virtual account unique identifier.
            page_size: This specifies the number of transactions to be retrieved.
            page_number: This specifies the index of the paginated results retrieved.
            request_reference: a unique identifier for this api call.
                it is automatically generated if not provided.

        Returns:
            An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
                of calling this function.

        Raises:
            ConnectionException: when the request times out or in the absence of an internet connection.
        """
        data = {
            "trackingReference": tracking_reference,
            "pageSize": page_size,
            "pageNumber": page_number,
        }
        return await self._api_call(
            service_type=ServiceType.ADMIN_VIRTUAL_ACCOUNT_TRANSACTIONS,
            data=data,
            request_reference=request_reference,
        )

    async def get_virtual_account_filtered_transaction_history(
        self,
        tracking_reference: str,
        page_size: int,
        page_number: int,
        start_date: str,
        end_date: str,
        request_reference: Optional[str] = None,
    ) -> APIResponse:
        """Retrieves a filtered list of all virtual account transactions.

        Args:
            tracking_reference: The virtual account unique identifier.
            page_size: This specifies the number of transactions to be retrieved.
            page_number: This specifies the index of the paginated results retrieved.
            start_date: Transaction start date. Format (YYYY-MM-DD)
            end_date: Transaction end date. Format (YYYY-MM-DD)
            request_reference: a unique identifier for this api call.
                it is automatically generated if not provided.

        Returns:
            An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
                of calling this function.

        Raises:
            ConnectionException: when the request times out or in the absence of an internet connection.
        """
        data = {
            "trackingReference": tracking_reference,
            "pageSize": page_size,
            "pageNumber": page_number,
            "startDate": start_date,
            "endDate": end_date,
        }
        return await self._api_call(
            service_type=ServiceType.ADMIN_VIRTUAL_ACCOUNT_FILTERED_TRANSACTIONS,
            data=data,
            request_reference=request_reference,
        )

    async def get_status(
        self,
        is_third_party_bank_transfer: bool,
        transaction_request_reference: str,
        request_reference: Optional[str] = None,
    ) -> APIResponse:
        """Retrieves the status of a transaction.

        Args:
            is_third_party_bank_transfer: Flag to determine if the transaction was interbank or
                intra-bank.
            transaction_request_reference: The request reference used when make transaction.
            request_reference: a unique identifier for this api call.
                it is automatically generated if not provided.

        Returns:
            An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
                of calling this function.

        Raises:
            ConnectionException: when the request times out or in the absence of an internet connection.
        """
        data = {
            "isThirdPartyBankTransfer": is_third_party_bank_transfer,
            "transactionRequestReference": transaction_request_reference,
        }
        return await self._api_call(
            service_type=ServiceType.TRANSACTION_STATUS_QUERY,
            data=data,
            request_reference=request_reference,
        )

    async def fund_virtual_account(
        self,
        tracking_reference: str,
        amount: Union[int, float],
        narration: str,
        request_reference: Optional[str] = None,
    ) -> APIResponse:
        """Add funds to a virtual account.

        Args:
            tracking_reference: The virtual account tracking reference.
            amount: The amount you want to fund your account. Note care should be taken when performing calculations as money is involved.
                a `Decimal` would have been the preferred type compared to `Union[int, float]` that was used.
                it is advisable that static values are passed for this parameter. see
                https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency
            narration: The additional description for the transaction.
            request_reference: a unique identifier for this api call.
                it is automatically generated if not provided.

        Returns:
            An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
                of calling this function.

        Raises:
            ConnectionException: when the request times out or in the absence of an internet connection.
        """
        data = {
            "trackingReference": tracking_reference,
            "amount": amount,
            "narration": narration,
        }
        return await self._api_call(
            service_type=ServiceType.FUND_VIRTUAL_ACCOUNT,
            data=data,
            request_reference=request_reference,
        )

    async def withdraw_from_virtual_account(
        self,
        tracking_reference: str,
        amount: Union[int, float],
        narration: str,
        client_fee_charge: int = 0,
        request_reference: Optional[str] = None,
    ) -> APIResponse:
        """Transfer funds from a virtual account to an associated Kuda account or to any other Nigerian Bank account.

        Args:
            tracking_reference: The virtual account tracking reference.
            amount: The amount you want to fund your account. Note care should be taken when performing calculations as money is involved.
                a `Decimal` would have been the preferred type compared to `Union[int, float]` that was used.
                it is advisable that static values are passed for this parameter. see
                https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency
            narration: The additional description for the transaction.
            client_fee_charge: It is an amount a client wishes to charge their customer for a transfer
                being carried out.
            request_reference: a unique identifier for this api call.
                it is automatically generated if not provided.

        Returns:
            An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
                of calling this function.

        Raises:
            ConnectionException: when the request times out or in the absence of an internet connection.
        """
        data = {
            "trackingReference": tracking_reference,
            "amount": amount,
            "narration": narration,
            "ClientFeeCharge": client_fee_charge,
        }
        return await self._api_call(
            service_type=ServiceType.WITHDRAW_VIRTUAL_ACCOUNT,
            data=data,
            request_reference=request_reference,
        )

confirm_transfer_recipient(beneficiary_account_number, beneficiary_bank_code, sender_tracking_reference, is_request_from_virtual_account, request_reference=None) async

Retrieves information of a beneficiary for validation before initiating a transfer.

Parameters:

Name	Type	Description	Default
beneficiary_account_number	str	Destination bank account number.	required
beneficiary_bank_code	str	Destination bank code.	required
sender_tracking_reference	Optional[str]	Tracking reference of the virtual account trying to do the actual transfer. Leave it empty if the intended transfer is going to be from the main account.	required
is_request_from_virtual_account	bool	If the intended transfer is to be made by the virtual account.	required
request_reference	Optional[str]	a unique identifier for this api call. it is automatically generated if not provided.	None

Returns:

Type	Description
APIResponse	An APIResponse which is basically just a dataclass containing the data returned by the server as result of calling this function.

Raises:

Type	Description
ConnectionException	when the request times out or in the absence of an internet connection.

Source code in pykuda2/wrappers/async_wrappers/transaction.py

async def confirm_transfer_recipient(
    self,
    beneficiary_account_number: str,
    beneficiary_bank_code: str,
    sender_tracking_reference: Optional[str],
    is_request_from_virtual_account: bool,
    request_reference: Optional[str] = None,
) -> APIResponse:
    """
    Retrieves information of a beneficiary for validation before initiating a transfer.

    Args:
        beneficiary_account_number: Destination bank account number.
        beneficiary_bank_code: Destination bank code.
        sender_tracking_reference: Tracking reference of the virtual account trying to
            do the actual transfer. Leave it empty if the intended transfer is going to
            be from the main account.
        is_request_from_virtual_account: If the intended transfer is to be made by the
            virtual account.
        request_reference: a unique identifier for this api call.
            it is automatically generated if not provided.

    Returns:
        An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
            of calling this function.

    Raises:
        ConnectionException: when the request times out or in the absence of an internet connection.
    """
    data = {
        "beneficiaryAccountNumber": beneficiary_account_number,
        "beneficiaryBankCode": beneficiary_bank_code,
        "SenderTrackingReference": sender_tracking_reference,
        "isRequestFromVirtualAccount": is_request_from_virtual_account,
    }
    return await self._api_call(
        service_type=ServiceType.NAME_ENQUIRY,
        data=data,
        request_reference=request_reference,
    )

fund_transfer(beneficiary_account, beneficiary_bank_code, beneficiary_name, amount, narration, name_enquiry_session_id, sender_name, client_fee_charge=0, client_account_number=None, request_reference=None) async

Sends money from your main Kuda account to another bank accounts.

Please, do not use sensitive data while doing test transactions so as not to save it in your sandbox environment.

Parameters:

Name	Type	Description	Default
beneficiary_account	str	Destination bank account number.	required
beneficiary_bank_code	str	Destination bank code.	required
beneficiary_name	str	Name of the recipient.	required
amount	Union[int, float]	Amount to be transferred. Note care should be taken when performing calculations as money is involved. a Decimal would have been the preferred type compared to Union[int, float] that was used. it is advisable that static values are passed for this parameter. see https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency	required
narration	str	User defined reason for the transaction.	required
name_enquiry_session_id	str	Session ID generated from the nameEnquiry request.	required
sender_name	str	Name of the person sending money.	required
client_fee_charge	int	It is an amount a client wishes to charge their customer for a transfer being carried out.	0
client_account_number	Optional[str]	Account number of the client where the charged fee is sent to.	None
request_reference	Optional[str]	a unique identifier for this api call. it is automatically generated if not provided.	None

Returns:

Type	Description
APIResponse	An APIResponse which is basically just a dataclass containing the data returned by the server as result of calling this function.

Raises:

Type	Description
ConnectionException	when the request times out or in the absence of an internet connection.

Source code in pykuda2/wrappers/async_wrappers/transaction.py

async def fund_transfer(
    self,
    beneficiary_account: str,
    beneficiary_bank_code: str,
    beneficiary_name: str,
    amount: Union[int, float],
    narration: str,
    name_enquiry_session_id: str,
    sender_name: str,
    client_fee_charge: int = 0,
    client_account_number: Optional[str] = None,
    request_reference: Optional[str] = None,
) -> APIResponse:
    """
    Sends money from your main Kuda account to another bank accounts.

    Please, do not use sensitive data while doing test transactions so
    as not to save it in your sandbox environment.

    Args:
        beneficiary_account: Destination bank account number.
        beneficiary_bank_code: Destination bank code.
        beneficiary_name: Name of the recipient.
        amount: Amount to be transferred. Note care should be taken when performing calculations as money is involved.
            a `Decimal` would have been the preferred type compared to `Union[int, float]` that was used.
            it is advisable that static values are passed for this parameter. see
            https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency
        narration: User defined reason for the transaction.
        name_enquiry_session_id: Session ID generated from the nameEnquiry request.
        sender_name: Name of the person sending money.
        client_fee_charge: It is an amount a client wishes to charge their customer
            for a transfer being carried out.
        client_account_number: Account number of the client where the charged fee is
            sent to.
        request_reference: a unique identifier for this api call.
            it is automatically generated if not provided.

    Returns:
        An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
            of calling this function.

    Raises:
        ConnectionException: when the request times out or in the absence of an internet connection.
    """
    data = {
        "ClientAccountNumber": client_account_number,
        "beneficiaryAccount": beneficiary_account,
        "beneficiaryBankCode": beneficiary_bank_code,
        "beneficiaryName": beneficiary_name,
        "amount": amount,
        "narration": narration,
        "nameEnquirySessionID": name_enquiry_session_id,
        "senderName": sender_name,
        "clientFeeCharge": client_fee_charge,
    }
    return await self._api_call(
        service_type=ServiceType.SINGLE_FUND_TRANSFER,
        data=data,
        request_reference=request_reference,
    )

fund_virtual_account(tracking_reference, amount, narration, request_reference=None) async

Add funds to a virtual account.

Parameters:

Name	Type	Description	Default
tracking_reference	str	The virtual account tracking reference.	required
amount	Union[int, float]	The amount you want to fund your account. Note care should be taken when performing calculations as money is involved. a Decimal would have been the preferred type compared to Union[int, float] that was used. it is advisable that static values are passed for this parameter. see https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency	required
narration	str	The additional description for the transaction.	required
request_reference	Optional[str]	a unique identifier for this api call. it is automatically generated if not provided.	None

Returns:

Type	Description
APIResponse	An APIResponse which is basically just a dataclass containing the data returned by the server as result of calling this function.

Raises:

Type	Description
ConnectionException	when the request times out or in the absence of an internet connection.

Source code in pykuda2/wrappers/async_wrappers/transaction.py

async def fund_virtual_account(
    self,
    tracking_reference: str,
    amount: Union[int, float],
    narration: str,
    request_reference: Optional[str] = None,
) -> APIResponse:
    """Add funds to a virtual account.

    Args:
        tracking_reference: The virtual account tracking reference.
        amount: The amount you want to fund your account. Note care should be taken when performing calculations as money is involved.
            a `Decimal` would have been the preferred type compared to `Union[int, float]` that was used.
            it is advisable that static values are passed for this parameter. see
            https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency
        narration: The additional description for the transaction.
        request_reference: a unique identifier for this api call.
            it is automatically generated if not provided.

    Returns:
        An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
            of calling this function.

    Raises:
        ConnectionException: when the request times out or in the absence of an internet connection.
    """
    data = {
        "trackingReference": tracking_reference,
        "amount": amount,
        "narration": narration,
    }
    return await self._api_call(
        service_type=ServiceType.FUND_VIRTUAL_ACCOUNT,
        data=data,
        request_reference=request_reference,
    )

get_banks(request_reference=None) async

Retrieves all the banks available from NIPS

In production, the list of banks and bank codes may change based on the responses gotten from NIBSS (Nigerian Interbank Settlement System).

Args: request_reference: a unique identifier for this api call. it is automatically generated if not provided.

Returns: An APIResponse which is basically just a dataclass containing the data returned by the server as result of calling this function.

Raises:

Type	Description
ConnectionException	when the request times out or in the absence of an internet connection.

Source code in pykuda2/wrappers/async_wrappers/transaction.py

async def get_banks(self, request_reference: Optional[str] = None) -> APIResponse:
    """Retrieves all the banks available from NIPS

     In production, the list of banks and bank codes may change based on
     the responses gotten from NIBSS (Nigerian Interbank Settlement System).

     Args:
         request_reference: a unique identifier for this api call.
            it is automatically generated if not provided.

     Returns:
        An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
            of calling this function.

    Raises:
        ConnectionException: when the request times out or in the absence of an internet connection.
    """
    return await self._api_call(
        service_type=ServiceType.BANK_LIST, request_reference=request_reference
    )

get_filtered_transaction_history(page_size, page_number, start_date, end_date, request_reference=None) async

Retrieves a filtered transaction history.

Parameters:

Name	Type	Description	Default
start_date	str	Transaction start date. Format (YYYY-MM-DD)	required
end_date	str	Transaction end date. Format (YYYY-MM-DD)	required
page_size	int	This specifies the number of transactions to be retrieved.	required
page_number	int	This specifies the index of the paginated results retrieved.	required
request_reference	Optional[str]	a unique identifier for this api call. it is automatically generated if not provided.	None

Returns:

Type	Description
APIResponse	An APIResponse which is basically just a dataclass containing the data returned by the server as result of calling this function.

Raises:

Type	Description
ConnectionException	when the request times out or in the absence of an internet connection.

Source code in pykuda2/wrappers/async_wrappers/transaction.py

async def get_filtered_transaction_history(
    self,
    page_size: int,
    page_number: int,
    start_date: str,
    end_date: str,
    request_reference: Optional[str] = None,
) -> APIResponse:
    """Retrieves a filtered transaction history.

    Args:
        start_date: Transaction start date. Format (YYYY-MM-DD)
        end_date: Transaction end date. Format (YYYY-MM-DD)
        page_size: This specifies the number of transactions to be retrieved.
        page_number: This specifies the index of the paginated results retrieved.
        request_reference: a unique identifier for this api call.
            it is automatically generated if not provided.

    Returns:
        An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
            of calling this function.

    Raises:
        ConnectionException: when the request times out or in the absence of an internet connection.
    """
    data = {
        "pageSize": page_size,
        "pageNumber": page_number,
        "startDate": start_date,
        "endDate": end_date,
    }
    return await self._api_call(
        service_type=ServiceType.ADMIN_MAIN_ACCOUNT_FILTERED_TRANSACTIONS,
        data=data,
        request_reference=request_reference,
    )

get_status(is_third_party_bank_transfer, transaction_request_reference, request_reference=None) async

Retrieves the status of a transaction.

Parameters:

Name	Type	Description	Default
is_third_party_bank_transfer	bool	Flag to determine if the transaction was interbank or intra-bank.	required
transaction_request_reference	str	The request reference used when make transaction.	required
request_reference	Optional[str]	a unique identifier for this api call. it is automatically generated if not provided.	None

Returns:

Type	Description
APIResponse	An APIResponse which is basically just a dataclass containing the data returned by the server as result of calling this function.

Raises:

Type	Description
ConnectionException	when the request times out or in the absence of an internet connection.

Source code in pykuda2/wrappers/async_wrappers/transaction.py

async def get_status(
    self,
    is_third_party_bank_transfer: bool,
    transaction_request_reference: str,
    request_reference: Optional[str] = None,
) -> APIResponse:
    """Retrieves the status of a transaction.

    Args:
        is_third_party_bank_transfer: Flag to determine if the transaction was interbank or
            intra-bank.
        transaction_request_reference: The request reference used when make transaction.
        request_reference: a unique identifier for this api call.
            it is automatically generated if not provided.

    Returns:
        An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
            of calling this function.

    Raises:
        ConnectionException: when the request times out or in the absence of an internet connection.
    """
    data = {
        "isThirdPartyBankTransfer": is_third_party_bank_transfer,
        "transactionRequestReference": transaction_request_reference,
    }
    return await self._api_call(
        service_type=ServiceType.TRANSACTION_STATUS_QUERY,
        data=data,
        request_reference=request_reference,
    )

get_transaction_history(page_size, page_number, request_reference=None) async

Retrieves a list of all main account transactions.

Parameters:

Name	Type	Description	Default
page_size	int	This specifies the number of transactions to be retrieved.	required
page_number	int	This specifies the index of the paginated results retrieved.	required
request_reference	Optional[str]	a unique identifier for this api call. it is automatically generated if not provided.	None

Returns:

Type	Description
APIResponse	An APIResponse which is basically just a dataclass containing the data returned by the server as result of calling this function.

Raises:

Type	Description
ConnectionException	when the request times out or in the absence of an internet connection.

Source code in pykuda2/wrappers/async_wrappers/transaction.py

async def get_transaction_history(
    self, page_size: int, page_number: int, request_reference: Optional[str] = None
) -> APIResponse:
    """Retrieves a list of all main account transactions.

    Args:
        page_size: This specifies the number of transactions to be retrieved.
        page_number: This specifies the index of the paginated results retrieved.
        request_reference: a unique identifier for this api call.
            it is automatically generated if not provided.

    Returns:
        An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
            of calling this function.

    Raises:
        ConnectionException: when the request times out or in the absence of an internet connection.
    """
    data = {"pageSize": page_size, "pageNumber": page_number}
    return await self._api_call(
        service_type=ServiceType.ADMIN_MAIN_ACCOUNT_TRANSACTIONS,
        data=data,
        request_reference=request_reference,
    )

get_transaction_logs(request_reference, response_reference, transaction_date, has_transaction_date_range_filter, start_date, end_date, page_size, page_number, fetch_successful_records=False) async

Retrieves all transactions.

Parameters:

Name	Type	Description	Default
request_reference	str	a unique identifier for this api call. it is automatically generated if not provided.	required
response_reference	str	Transaction response reference.	required
fetch_successful_records	bool	If set to True, only successful transactions will be retrieved.	False
transaction_date	str	The transaction date. Format (YYYY-MM-DD)	required
has_transaction_date_range_filter	bool	Is set to True, then the start_date and end_date parameter will be used instead of transaction_date	required
start_date	str	Transaction start date. Format (YYYY-MM-DD)	required
end_date	str	Transaction end date. Format (YYYY-MM-DD)	required
page_size	int	This specifies the number of transactions to be retrieved.	required
page_number	int	This specifies the index of the paginated results retrieved.	required

Returns:

Type	Description
APIResponse	An APIResponse which is basically just a dataclass containing the data returned by the server as result of calling this function.

Raises:

Type	Description
ConnectionException	when the request times out or in the absence of an internet connection.

Source code in pykuda2/wrappers/async_wrappers/transaction.py

async def get_transaction_logs(
    self,
    request_reference: str,
    response_reference: str,
    transaction_date: str,
    has_transaction_date_range_filter: bool,
    start_date: str,
    end_date: str,
    page_size: int,
    page_number: int,
    fetch_successful_records: bool =False,
) -> APIResponse:
    """Retrieves all transactions.

    Args:
        request_reference: a unique identifier for this api call.
            it is automatically generated if not provided.
        response_reference: Transaction response reference.
        fetch_successful_records: If set to `True`, only successful transactions
            will be retrieved.
        transaction_date: The transaction date. Format (YYYY-MM-DD)
        has_transaction_date_range_filter: Is set to `True`, then the `start_date` and
            `end_date` parameter will be used instead of `transaction_date`
        start_date: Transaction start date. Format (YYYY-MM-DD)
        end_date: Transaction end date. Format (YYYY-MM-DD)
        page_size: This specifies the number of transactions to be retrieved.
        page_number: This specifies the index of the paginated results retrieved.

    Returns:
        An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
            of calling this function.

    Raises:
        ConnectionException: when the request times out or in the absence of an internet connection.
    """
    data = {
        "RequestReference": request_reference,
        "ResponseReference": response_reference,
        "FetchSuccessfulRecords": fetch_successful_records,
        "TransactionDate": transaction_date,
        "HasTransactionDateRangeFilter": has_transaction_date_range_filter,
        "StartDate": start_date,
        "EndDate": end_date,
        "PageSize": page_size,
        "PageNumber": page_number,
    }
    return await self._api_call(
        service_type=ServiceType.RETRIEVE_TRANSACTION_LOGS,
        data=data,
        request_reference=request_reference,
    )

get_transfer_instructions(account_number, reference, amount, original_request_ref, status, page_number, page_size, request_reference=None) async

Retrieves transfer instructions and returns the status of the transaction.

Parameters:

Name	Type	Description	Default
account_number	str	The beneficiary’s account number.	required
reference	str	The reference on the transfer instruction.	required
amount	Union[int, float]	The transaction amount. Note care should be taken when performing calculations as money is involved. a Decimal would have been the preferred type compared to Union[int, float] that was used. it is advisable that static values are passed for this parameter. see https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency	required
original_request_ref	str	The request reference used in logging the instruction.	required
status	TransactionStatus	The status of the transaction.	required
page_size	int	This specifies the number of transfer instructions to be retrieved.	required
page_number	int	This specifies the index of the paginated results retrieved.	required
request_reference	Optional[str]	a unique identifier for this api call. it is automatically generated if not provided.	None

Returns:

Type	Description
APIResponse	An APIResponse which is basically just a dataclass containing the data returned by the server as result of calling this function.

Raises:

Type	Description
ConnectionException	when the request times out or in the absence of an internet connection.

Source code in pykuda2/wrappers/async_wrappers/transaction.py

async def get_transfer_instructions(
    self,
    account_number: str,
    reference: str,
    amount: Union[int, float],
    original_request_ref: str,
    status: TransactionStatus,
    page_number: int,
    page_size: int,
    request_reference: Optional[str] = None,
) -> APIResponse:
    """Retrieves transfer instructions and returns the status of the transaction.

    Args:
        account_number: The beneficiary’s account number.
        reference: The reference on the transfer instruction.
        amount: The transaction amount. Note care should be taken when performing calculations as money is involved.
            a `Decimal` would have been the preferred type compared to `Union[int, float]` that was used.
            it is advisable that static values are passed for this parameter. see
            https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency
        original_request_ref: The request reference used in logging the instruction.
        status: The status of the transaction.
        page_size: This specifies the number of transfer instructions to be retrieved.
        page_number: This specifies the index of the paginated results retrieved.
        request_reference: a unique identifier for this api call.
            it is automatically generated if not provided.

    Returns:
        An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
            of calling this function.

    Raises:
        ConnectionException: when the request times out or in the absence of an internet connection.
    """
    data = {
        "AccountNumber": account_number,
        "Reference": reference,
        "Amount": amount,
        "OriginalRequestRef": original_request_ref,
        "Status": status,
        "PageNumber": page_number,
        "PageSize": page_size,
    }
    return await self._api_call(
        service_type=ServiceType.SEARCH_FUND_TRANSFER_INSTRUCTION,
        data=data,
        request_reference=request_reference,
    )

get_virtual_account_filtered_transaction_history(tracking_reference, page_size, page_number, start_date, end_date, request_reference=None) async

Retrieves a filtered list of all virtual account transactions.

Parameters:

Name	Type	Description	Default
tracking_reference	str	The virtual account unique identifier.	required
page_size	int	This specifies the number of transactions to be retrieved.	required
page_number	int	This specifies the index of the paginated results retrieved.	required
start_date	str	Transaction start date. Format (YYYY-MM-DD)	required
end_date	str	Transaction end date. Format (YYYY-MM-DD)	required
request_reference	Optional[str]	a unique identifier for this api call. it is automatically generated if not provided.	None

Returns:

Type	Description
APIResponse	An APIResponse which is basically just a dataclass containing the data returned by the server as result of calling this function.

Raises:

Type	Description
ConnectionException	when the request times out or in the absence of an internet connection.

Source code in pykuda2/wrappers/async_wrappers/transaction.py

async def get_virtual_account_filtered_transaction_history(
    self,
    tracking_reference: str,
    page_size: int,
    page_number: int,
    start_date: str,
    end_date: str,
    request_reference: Optional[str] = None,
) -> APIResponse:
    """Retrieves a filtered list of all virtual account transactions.

    Args:
        tracking_reference: The virtual account unique identifier.
        page_size: This specifies the number of transactions to be retrieved.
        page_number: This specifies the index of the paginated results retrieved.
        start_date: Transaction start date. Format (YYYY-MM-DD)
        end_date: Transaction end date. Format (YYYY-MM-DD)
        request_reference: a unique identifier for this api call.
            it is automatically generated if not provided.

    Returns:
        An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
            of calling this function.

    Raises:
        ConnectionException: when the request times out or in the absence of an internet connection.
    """
    data = {
        "trackingReference": tracking_reference,
        "pageSize": page_size,
        "pageNumber": page_number,
        "startDate": start_date,
        "endDate": end_date,
    }
    return await self._api_call(
        service_type=ServiceType.ADMIN_VIRTUAL_ACCOUNT_FILTERED_TRANSACTIONS,
        data=data,
        request_reference=request_reference,
    )

get_virtual_account_transaction_history(tracking_reference, page_size, page_number, request_reference=None) async

Retrieves a list of all virtual account transactions.

Parameters:

Name	Type	Description	Default
tracking_reference	str	The virtual account unique identifier.	required
page_size	int	This specifies the number of transactions to be retrieved.	required
page_number	int	This specifies the index of the paginated results retrieved.	required
request_reference	Optional[str]	a unique identifier for this api call. it is automatically generated if not provided.	None

Returns:

Type	Description
APIResponse	An APIResponse which is basically just a dataclass containing the data returned by the server as result of calling this function.

Raises:

Type	Description
ConnectionException	when the request times out or in the absence of an internet connection.

Source code in pykuda2/wrappers/async_wrappers/transaction.py

async def get_virtual_account_transaction_history(
    self,
    tracking_reference: str,
    page_size: int,
    page_number: int,
    request_reference: Optional[str] = None,
) -> APIResponse:
    """Retrieves a list of all virtual account transactions.

    Args:
        tracking_reference: The virtual account unique identifier.
        page_size: This specifies the number of transactions to be retrieved.
        page_number: This specifies the index of the paginated results retrieved.
        request_reference: a unique identifier for this api call.
            it is automatically generated if not provided.

    Returns:
        An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
            of calling this function.

    Raises:
        ConnectionException: when the request times out or in the absence of an internet connection.
    """
    data = {
        "trackingReference": tracking_reference,
        "pageSize": page_size,
        "pageNumber": page_number,
    }
    return await self._api_call(
        service_type=ServiceType.ADMIN_VIRTUAL_ACCOUNT_TRANSACTIONS,
        data=data,
        request_reference=request_reference,
    )

process_transfers(fund_transfer_instructions, request_reference=None) async

Allows you to send a list of transfer instructions to Kuda, to make the payments on your behalf.

Parameters:

Name	Type	Description	Default
fund_transfer_instructions	list[TransferInstruction]	A list of transfer instructions for transfers to be made.	required
request_reference	Optional[str]	a unique identifier for this api call. it is automatically generated if not provided.	None

Returns:

Type	Description
APIResponse	An APIResponse which is basically just a dataclass containing the data returned by the server as result of calling this function.

Raises:

Type	Description
ConnectionException	when the request times out or in the absence of an internet connection.

Source code in pykuda2/wrappers/async_wrappers/transaction.py

async def process_transfers(
    self,
    fund_transfer_instructions: list[TransferInstruction],
    request_reference: Optional[str] = None,
) -> APIResponse:
    """Allows you to send a list of transfer instructions to Kuda, to make the payments on your behalf.

    Args:
        fund_transfer_instructions: A list of transfer instructions for transfers to be made.
        request_reference: a unique identifier for this api call.
            it is automatically generated if not provided.

    Returns:
        An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
            of calling this function.

    Raises:
        ConnectionException: when the request times out or in the absence of an internet connection.
    """
    data = {
        "FundTransferInstructions": [
            fund_transfer_instruction.to_dict()
            for fund_transfer_instruction in fund_transfer_instructions
        ]
    }
    return await self._api_call(
        service_type=ServiceType.FUND_TRANSFER_INSTRUCTION,
        data=data,
        request_reference=request_reference,
    )

virtual_account_fund_transfer(tracking_reference, beneficiary_account, amount, beneficiary_name, narration, beneficiary_bank_code, sender_name, name_enquiry_id, client_fee_charge=0, client_account_number=None, request_reference=None) async

Transfer money from a virtual account to another and any other Nigerian bank account.

Parameters:

Name	Type	Description	Default
tracking_reference	str	Unique identifier of the sender.	required
beneficiary_account	str	Destination bank account number.	required
beneficiary_bank_code	str	Destination bank code.	required
beneficiary_name	str	Name of the recipient.	required
amount	Union[int, float]	Amount to be transferred. Note care should be taken when performing calculations as money is involved. a Decimal would have been the preferred type compared to Union[int, float] that was used. it is advisable that static values are passed for this parameter. see https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency	required
narration	str	User defined reason for the transaction.	required
name_enquiry_id	str	Session ID generated from the nameEnquiry request.	required
sender_name	str	Name of the person sending money.	required
client_fee_charge	Union[int, float]	It is an amount a client wishes to charge their customer for a transfer being carried out. Note care should be taken when performing calculations as money is involved. a Decimal would have been the preferred type compared to Union[int, float] that was used. it is advisable that static values are passed for this parameter. see https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency	0
client_account_number	Optional[str]	Account number of the client where the charged fee is sent to.	None
request_reference	Optional[str]	a unique identifier for this api call. it is automatically generated if not provided.	None

Returns:

Type	Description
APIResponse	An APIResponse which is basically just a dataclass containing the data returned by the server as result of calling this function.

Raises:

Type	Description
ConnectionException	when the request times out or in the absence of an internet connection.

Source code in pykuda2/wrappers/async_wrappers/transaction.py

async def virtual_account_fund_transfer(
    self,
    tracking_reference: str,
    beneficiary_account: str,
    amount: Union[int, float],
    beneficiary_name: str,
    narration: str,
    beneficiary_bank_code: str,
    sender_name: str,
    name_enquiry_id: str,
    client_fee_charge: Union[int, float] = 0,
    client_account_number: Optional[str] = None,
    request_reference: Optional[str] = None,
) -> APIResponse:
    """Transfer money from a virtual account to another and any other Nigerian bank account.

    Args:
        tracking_reference: Unique identifier of the sender.
        beneficiary_account: Destination bank account number.
        beneficiary_bank_code: Destination bank code.
        beneficiary_name: Name of the recipient.
        amount: Amount to be transferred. Note care should be taken when performing calculations as money is involved.
            a `Decimal` would have been the preferred type compared to `Union[int, float]` that was used.
            it is advisable that static values are passed for this parameter. see
            https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency
        narration: User defined reason for the transaction.
        name_enquiry_id: Session ID generated from the nameEnquiry request.
        sender_name: Name of the person sending money.
        client_fee_charge: It is an amount a client wishes to charge their customer
            for a transfer being carried out. Note care should be taken when performing calculations as money is involved.
            a `Decimal` would have been the preferred type compared to `Union[int, float]` that was used.
            it is advisable that static values are passed for this parameter. see
            https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency
        client_account_number: Account number of the client where the charged fee is
            sent to.
        request_reference: a unique identifier for this api call.
            it is automatically generated if not provided.

    Returns:
        An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
            of calling this function.

    Raises:
        ConnectionException: when the request times out or in the absence of an internet connection.
    """
    data = {
        "trackingReference": tracking_reference,
        "beneficiaryAccount": beneficiary_account,
        "amount": amount,
        "narration": narration,
        "beneficiaryBankCode": beneficiary_bank_code,
        "beneficiaryName": beneficiary_name,
        "senderName": sender_name,
        "nameEnquiryId": name_enquiry_id,
        "clientFeeCharge": client_fee_charge,
        "ClientAccountNumber": client_account_number,
    }
    return await self._api_call(
        service_type=ServiceType.VIRTUAL_ACCOUNT_FUND_TRANSFER,
        data=data,
        request_reference=request_reference,
    )

withdraw_from_virtual_account(tracking_reference, amount, narration, client_fee_charge=0, request_reference=None) async

Transfer funds from a virtual account to an associated Kuda account or to any other Nigerian Bank account.

Parameters:

Name	Type	Description	Default
tracking_reference	str	The virtual account tracking reference.	required
amount	Union[int, float]	The amount you want to fund your account. Note care should be taken when performing calculations as money is involved. a Decimal would have been the preferred type compared to Union[int, float] that was used. it is advisable that static values are passed for this parameter. see https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency	required
narration	str	The additional description for the transaction.	required
client_fee_charge	int	It is an amount a client wishes to charge their customer for a transfer being carried out.	0
request_reference	Optional[str]	a unique identifier for this api call. it is automatically generated if not provided.	None

Returns:

Type	Description
APIResponse	An APIResponse which is basically just a dataclass containing the data returned by the server as result of calling this function.

Raises:

Type	Description
ConnectionException	when the request times out or in the absence of an internet connection.

Source code in pykuda2/wrappers/async_wrappers/transaction.py

async def withdraw_from_virtual_account(
    self,
    tracking_reference: str,
    amount: Union[int, float],
    narration: str,
    client_fee_charge: int = 0,
    request_reference: Optional[str] = None,
) -> APIResponse:
    """Transfer funds from a virtual account to an associated Kuda account or to any other Nigerian Bank account.

    Args:
        tracking_reference: The virtual account tracking reference.
        amount: The amount you want to fund your account. Note care should be taken when performing calculations as money is involved.
            a `Decimal` would have been the preferred type compared to `Union[int, float]` that was used.
            it is advisable that static values are passed for this parameter. see
            https://stackoverflow.com/questions/3730019/why-not-use-double-or-float-to-represent-currency
        narration: The additional description for the transaction.
        client_fee_charge: It is an amount a client wishes to charge their customer for a transfer
            being carried out.
        request_reference: a unique identifier for this api call.
            it is automatically generated if not provided.

    Returns:
        An `APIResponse` which is basically just a dataclass containing the data returned by the server as result
            of calling this function.

    Raises:
        ConnectionException: when the request times out or in the absence of an internet connection.
    """
    data = {
        "trackingReference": tracking_reference,
        "amount": amount,
        "narration": narration,
        "ClientFeeCharge": client_fee_charge,
    }
    return await self._api_call(
        service_type=ServiceType.WITHDRAW_VIRTUAL_ACCOUNT,
        data=data,
        request_reference=request_reference,
    )