feat: README file updated

Author: Emmanuelonyo

README.md

@@ -1 +1,168 @@
-# cngn-pyhon-library
+# cngn-python-library
+
+CNGnManager is a Python library for interacting with a CNGN API. It provides a simple interface for various operations such as checking balance, swapping between chains, depositing for redemption, creating virtual accounts, and more.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [Available Methods](#available-methods)
+- [Testing](#testing)
+- [Error Handling](#error-handling)
+- [Types](#types)
+- [Security](#security)
+- [Contributing](#contributing)
+- [Support](#support)
+- [License](#license)
+
+## Installation
+
+To install CNGnManager and its dependencies, run:
+
+```bash
+pip install cngn-manager
+```
+
+## Usage
+
+First, import the `CNGnManager` class using it namespace WrappedCBDC\CNGNManager: and all necessary constants.
+
+```python
+from cngn_manager import CNGnManager, Network, ProviderType
+```
+
+Then, create an instance of `CNGnManager` with your secrets:
+
+```python
+import os
+
+api_key = "cngn_live_sk**********"
+encryption_key = "yourencryptionkey"
+ssh_private_key = """-----BEGIN OPENSSH PRIVATE KEY-----
+your ssh key
+-----END OPENSSH PRIVATE KEY-----"""
+
+# NOTE: You can also get your private key from a file using
+# ssh_private_key = os.open("/path/to/sshkey.key").read()
+
+manager = CNGnManager(api_key, ssh_private_key, encryption_key)
+# Example: Get balance
+balance = manager.get_balance()
+print(balance)
+```
+
+## Available Methods
+
+### Get Balance
+
+```python
+balance = manager.get_balance()
+print(balance)
+```
+
+### Get Transaction History
+
+```python
+transactions = manager.get_transaction_history()
+print(transactions)
+
+```
+
+### Swap Between Chains
+
+```python
+swap_params = {
+    "amount": 100,
+    "address": "0x1234...",
+    "network": Network.BSC
+}
+
+swap_result = manager.swap_between_chains(swap_params)
+print(swap_result)
+
+```
+
+### Deposit for Redemption
+
+```python
+deposit_params = {
+    "amount": 1000,
+    "bank": "Example Bank",
+    "accountNumber": "1234567890"
+}
+
+deposit_result = manager.deposit_for_redemption(deposit_params)
+print(deposit_result)
+
+```
+
+### Create Virtual Account
+
+```python
+mint_params = {
+    "provider": ProviderType.KORAPAY
+}
+
+virtual_account = manager.create_virtual_account(mint_params)
+print(virtual_account)
+
+```
+
+### Whitelist Address
+
+```python
+whitelist_params = {
+    "bscAddress": "0x1234...",
+    "bankName": "Example Bank",
+    "bankAccountNumber": "1234567890"
+}
+
+whitelist_result = manager.whitelist_address(whitelist_params)
+print(whitelist_result)
+
+```
+
+## Testing
+
+This project uses Jest for testing. To run the tests, follow these steps:
+
+1. Run the test command:
+
+```bash
+python3 -m unittest discover tests
+```
+
+This will run all tests in the `tests` directory.
+
+### Test Structure
+
+The tests are located in the `tests` directory. They cover various aspects of the CNGnManager class, including:
+
+- API calls for different endpoints (GET and POST requests)
+- Encryption and decryption of data
+- Error handling for various scenarios
+
+
+## Error Handling
+
+The library uses a custom error handling mechanism. All API errors are caught and thrown as `Error` objects with descriptive messages.
+
+## Types
+
+The library includes python definitions for all parameters and return types. Please refer to the type definitions in the source code for more details.
+
+## Security
+
+This library uses AES encryption for request payloads and Ed25519 decryption for response data. Ensure that your `encryptionKey` and `privateKey` are kept secure.
+
+## Contributing
+
+Contributions, issues, and feature requests are welcome. Feel free to check [issues page](https://github.com/wrappedcbdc/cngn-python-library/issues) if you want to contribute.
+
+## Support
+
+If you have any questions or need help using the library, please open an issue in the GitHub repository.
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

cngn_manager/__init__.py

@@ -0,0 +1,16 @@
+#   ____ _   _  ____       __  __                                   
+#  / ___| \ | |/ ___|_ __ |  \/  | __ _ _ __   __ _  __ _  ___ _ __ 
+# | |   |  \| | |  _| '_ \| |\/| |/ _` | '_ \ / _` |/ _` |/ _ \ '__|
+# | |___| |\  | |_| | | | | |  | | (_| | | | | (_| | (_| |  __/ |   
+#  \____|_| \_|\____|_| |_|_|  |_|\__,_|_| |_|\__,_|\__, |\___|_|   
+#                                                   |___/           
+# 
+
+"""
+cNGN HTTP Library
+~~~~~~~~~~~~~~~~~~~~~
+
+"""
+
+from .main import CNGnManager
+from .constants import Network, ProviderType

cngn_manager/__version__.py

@@ -10,7 +10,7 @@
 __title__ = "cngn_manager"
 __description__ = "Python HTTP for Humans."
 __url__ = "https://docs.cngn.co"
-__version__ = "0.0.1"
+__version__ = "0.0.2"
 __author__ = "Emmanuel Onyo"
 __author_email__ = "[email protected]"
 __license__ = "MIT License"

cngn_manager/main.py

@@ -7,11 +7,14 @@
 # 
 
 
-import requests # type: ignore
 import json
+from typing import Optional, Dict, Any
+import requests
+from requests.exceptions import RequestException, HTTPError
 from cngn_manager.AESCrypto import AESCrypto
 from cngn_manager.Ed25519Crypto import Ed25519Crypto
 
+
 """
     CNGnManager class is a wrapper around the CNGn API.
     It provides methods to interact with the CNGn API endpoints.
@@ -27,6 +30,7 @@ class CNGnManager:
 
     def __init__(self, api_key: str, private_key: str, encryption_key: str):
         self.api_key = api_key
+        self.api_url = self.API_URL
         self.private_key = private_key
         self.encryption_key = encryption_key
         self.client = requests.Session()
@@ -36,57 +40,55 @@ def __init__(self, api_key: str, private_key: str, encryption_key: str):
             'Accept': 'application/json',
         })
 
-    def handle_api_error(self, error):
-        # Handle the API error
-        pass
-
-    def __make_calls(self, method: str, endpoint: str, data: dict = None) -> str:
-
-
+    def __make_calls(self, method: str, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         aes_crypto = AESCrypto()
         ed_crypto = Ed25519Crypto()
 
         try:
-            if data is not None:
-                new_data = json.dumps(data)
-                encrypted_data = aes_crypto.encrypt(new_data, self.encryption_key)
-                data = encrypted_data
-                response = self.client.request(method, f'{self.API_URL}/{self.API_CURRENT_VERSION}{endpoint}', json=data)
-            else:
-                response = self.client.request(method, f'{self.API_URL}/{self.API_CURRENT_VERSION}{endpoint}')
-
-            response_data = response.json()
-
-            if response_data.get("data") is not None:                
-                decrypted_response = ed_crypto.decrypt_with_private_key(self.private_key, response_data["data"])
-                response_data["data"] = json.loads(decrypted_response)
-
-            return json.dumps(response_data)
-
-        except (requests.exceptions.RequestException, requests.exceptions.HTTPError) as e:
-            error_body = {
-                'success': False,
-                'error': 'API request failed',
-                'message': str(e),
-                'status_code': e.response.status_code if e.response else None,
-            }
-
-            if e.response:
-                resp = e.response.json()
-                message = json.loads(resp.get('message', '{}'))
-                resp["message"] = message
-                return json.dumps(resp)
-
-            return json.dumps(error_body)
+            url = f'{self.api_url}/{self.API_CURRENT_VERSION}{endpoint}'
+            request_data = self._prepare_request_data(data, aes_crypto)
+            response = self._send_request(method, url, request_data)
+            return self._process_response(response, ed_crypto)
 
+        except (RequestException, HTTPError) as e:
+            return self._handle_request_error(e)
         except Exception as e:
-            return json.dumps({
-                'success': False,
-                'error': 'An unexpected error occurred',
-                'message': str(e.message if hasattr(e, 'message') else str(e)),
-                'status_code': 500,
-            })
-
+            return self._handle_unexpected_error(e)
+
+    def _prepare_request_data(self, data: Optional[Dict[str, Any]], aes_crypto: AESCrypto) -> Optional[str]:
+        if data is None:
+            return None
+        json_data = json.dumps(data)
+        return aes_crypto.encrypt(json_data, self.encryption_key)
+
+    def _send_request(self, method: str, url: str, data: Optional[str]) -> requests.Response:
+        return self.client.request(method, url, json=data)
+
+    def _process_response(self, response: requests.Response, ed_crypto: Ed25519Crypto) -> Dict[str, Any]:
+        response_data = response.json()
+        if "data" in response_data:
+            decrypted_response = ed_crypto.decrypt_with_private_key(self.private_key, response_data["data"])
+            response_data["data"] = json.loads(decrypted_response)
+        return response_data
+
+    def _handle_request_error(self, error: RequestException) -> Dict[str, Any]:
+        if error.response:
+            return error.response.json()
+        return {
+            'success': False,
+            'error': 'API request failed',
+            'message': str(error),
+            'status_code': error.response.status_code if error.response else None,
+        }
+
+    def _handle_unexpected_error(self, error: Exception) -> Dict[str, Any]:
+        return {
+            'success': False,
+            'error': 'An unexpected error occurred',
+            'message': str(error),
+            'status_code': 500,
+        }
+    
     def get_balance(self) -> str:
         return self.__make_calls("GET", "/api/balance")