diff --git a/submissions/multicurrency-wallets-transfer-Brijeshthummar02/setup.md b/submissions/multicurrency-wallets-transfer-Brijeshthummar02/setup.md
new file mode 100644
index 0000000..0d06b0f
--- /dev/null
+++ b/submissions/multicurrency-wallets-transfer-Brijeshthummar02/setup.md
@@ -0,0 +1,538 @@
+# Setting Up Chimoney's Multi-Currency Wallet Transfer API
+
+This guide will walk you through the process of setting up and authenticating with Chimoney's API to use the Multi-Currency Wallet Transfer functionality. By the end of this guide, you'll have everything configured to start making transfers between wallets in different currencies.
+
+> **Developer Insight:** "I remember staring at a blank code editor, knowing I needed to implement cross-border payments but dreading the complexity ahead. This setup guide is exactly what I wish I'd had then – a clear path from zero to your first successful API call."
+
+## Prerequisites
+
+Before you begin, make sure you have:
+
+- Basic understanding of APIs and HTTP requests
+- A tool for making API requests (Postman, cURL, or your preferred programming language)
+- A Chimoney account (don't worry, we'll cover how to create one—it takes less than 2 minutes and doesn't require a credit card for the sandbox)
+
+## Step 1: Create a Chimoney Account
+
+1. Visit [https://sandbox.chimoney.io/](https://sandbox.chimoney.io/) to create a sandbox account
+2. Click "Sign Up" and complete the registration process
+3. Verify your email address
+
+The sandbox environment comes with $1,000 of test funds automatically loaded into your account, allowing you to experiment without using real money. This means you can focus on learning and testing without the anxiety of potentially losing funds or needing approval for every test transaction.
+
+✓ **Achievement unlocked:** You've taken your first step toward frictionless global payments!
+
+## Step 2: Create an Organization
+
+1. Log in to your Chimoney sandbox account
+2. Navigate to the "Organizations" tab in the dashboard
+3. Click "Create Organization" or "Create Team"
+4. Fill in the required details:
+ - Organization name
+ - Country of operation - (Full address)
+ - Contact information - (Email of team members)
+5. Submit the form to create your organization
+
+Creating an organization is important as it helps organize your API keys and wallet structures, especially if you're building a platform that will handle payments for multiple users or departments. Think of it as creating a solid foundation for your payment architecture – proper organization now will save you countless headaches as your application scales.
+
+## Step 3: Generate Your API Key
+
+1. In your Chimoney dashboard, navigate to the "Developers" tab
+2. Click "Create App" to generate a new API key
+3. Fill in the application details:
+ - App name (e.g., "Payment Platform")
+ - Description (optional)
+ - Webhook URL (optional)
+4. Once created, you'll see your API key displayed
+5. Copy and securely store this key—you'll need it for all API requests
+
+> ⚠️ **Security Note**: Never expose your API key in client-side code or public repositories. Always store it securely as an environment variable or in a secure vault. Many developers have learned this lesson the hard way, with exposed keys leading to unauthorized transactions or account lockouts.
+
+## Step 4: Understanding the API Environment
+
+### Sandbox Environment
+
+- Base URL: `https://sandbox-api.chimoney.io/v0.2.4/`
+- Use for development and testing
+- Transactions don't involve real money
+- Automatically funded with test money
+- Perfect for integrating and testing your application
+
+For this guide, we'll use the sandbox environment to safely experiment with the API. The relief of knowing you can test freely without financial consequences makes the development process much more enjoyable and encourages thorough testing.
+
+## Step 5: Setting Up Authentication
+
+All requests to the Chimoney API require authentication using your API key in the request header.
+
+### Header Format
+
+```
+Authorization: Bearer YOUR_API_KEY
+```
+
+Replace `YOUR_API_KEY` with the key you generated in Step 3.
+
+### Testing Authentication
+
+Let's verify your API key is working by making a simple request to check your account information:
+
+```bash
+curl -X GET https://sandbox-api.chimoney.io/v0.2.4/info/assets \
+ -H "Authorization: Bearer YOUR_API_KEY"
+```
+
+If successful, you should receive a JSON response with a list of supported assets.
+
+**Developer Insight:** "The first time I saw a successful response from the API, I felt a surprising sense of relief. That green status code meant I was on the right track, and suddenly the task ahead seemed manageable."
+
+✓ **Achievement unlocked:** You've successfully authenticated with the Chimoney API!
+
+## Step 6: Create Multi-Currency Wallets
+
+Before you can transfer funds between currencies, you need to create wallets for each currency you want to work with. The Chimoney API currently supports USD, CAD, and NGN for multi-currency wallets.
+
+Imagine these wallets as specialized containers designed to hold different types of currencies – each with its own rules and characteristics, but all managed through a single unified interface.
+
+### Creating a USD Wallet
+
+```bash
+curl -X POST https://sandbox-api.chimoney.io/v0.2.4/multicurrency-wallets/create \
+ -H "Authorization: Bearer YOUR_API_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "name": "USD Wallet",
+ "currency": "USD"
+ }'
+```
+
+### Creating a NGN Wallet
+
+```bash
+curl -X POST https://sandbox-api.chimoney.io/v0.2.4/multicurrency-wallets/create \
+ -H "Authorization: Bearer YOUR_API_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "name": "NGN Wallet",
+ "currency": "NGN"
+ }'
+```
+
+### Creating a CAD Wallet
+
+```bash
+curl -X POST https://sandbox-api.chimoney.io/v0.2.4/multicurrency-wallets/create \
+ -H "Authorization: Bearer YOUR_API_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "name": "CAD Wallet",
+ "currency": "CAD"
+ }'
+```
+
+### Expected Response
+
+```json
+{
+ "status": "success",
+ "data": {
+ "id": "wallet_abc123",
+ "name": "USD Wallet",
+ "currency": "USD",
+ "balance": 0,
+ "createdAt": "2023-07-23T12:34:56.789Z"
+ }
+}
+```
+
+Save the wallet IDs returned in the responses—you'll need them for transfers. These IDs are your digital keys to access each wallet, so keep them organized and accessible in your code.
+
+✓ **Achievement unlocked:** You've created multi-currency wallets that can hold different currencies!
+
+## Step 7: Funding Your Wallets
+
+In the sandbox environment, your account is automatically funded with test money. You can verify your wallet balances using:
+
+```bash
+curl -X GET https://sandbox-api.chimoney.io/v0.2.4/multicurrency-wallets/list \
+ -H "Authorization: Bearer YOUR_API_KEY"
+```
+
+This will return a list of all your wallets with their current balances.
+
+## Step 8: Setting Up Webhook Notifications (Recommended)
+
+It's recommended to set up webhooks to receive real-time notifications about transaction status changes.
+
+Webhooks are like having a dedicated assistant who taps you on the shoulder the moment something important happens, rather than you having to constantly check for updates. They're especially valuable for payment systems where timely information can make the difference between a good and great user experience.
+
+1. Create an endpoint in your application that can receive POST requests
+2. In your Chimoney dashboard, go to the Developers tab
+3. Update your application with the webhook URL
+4. Specify the events you want to receive notifications for (e.g., "transfer.completed", "transfer.failed")
+
+Your webhook endpoint should return a 200 OK response to acknowledge receipt of the notification.
+
+### Sample Webhook Payload
+
+```json
+{
+ "event": "transfer.completed",
+ "data": {
+ "id": "transfer_123456",
+ "fromWallet": "wallet_abc123",
+ "amount": 100,
+ "sourceCurrency": "USD",
+ "destinationAmount": 46000,
+ "destinationCurrency": "NGN",
+ "recipient": "recipient@example.com",
+ "status": "completed",
+ "createdAt": "2023-07-23T14:25:36.789Z"
+ }
+}
+```
+
+## Step 9: Making Your First Test Transfer
+
+Now that everything is set up, let's make a test transfer between your wallets:
+
+### First, Get a Transfer Quote
+
+```bash
+curl -X POST https://sandbox-api.chimoney.io/v0.2.4/multicurrency-wallets/transfer/quote \
+ -H "Authorization: Bearer YOUR_API_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "fromWallet": "YOUR_USD_WALLET_ID",
+ "amount": 10,
+ "destinationCurrency": "NGN"
+ }'
+```
+
+This will return a quote with the exchange rate, fees, and final amount:
+
+```json
+{
+ "status": "success",
+ "data": {
+ "sourceCurrency": "USD",
+ "sourceAmount": 10,
+ "destinationCurrency": "NGN",
+ "destinationAmount": 4600,
+ "exchangeRate": 460,
+ "fee": 0.25,
+ "totalDebit": 10.25,
+ "estimatedDeliveryTime": "instant"
+ }
+}
+```
+
+**Developer Insight:** "Seeing the 'estimatedDeliveryTime': 'instant' in my first quote response was eye-opening. After years of building around 3-5 day transfer delays, the possibility of instant cross-border transfers changed my entire approach to the payment flow design."
+
+### Then, Execute the Transfer
+
+```bash
+curl -X POST https://sandbox-api.chimoney.io/v0.2.4/multicurrency-wallets/transfer \
+ -H "Authorization: Bearer YOUR_API_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "fromWallet": "YOUR_USD_WALLET_ID",
+ "toWallet": "YOUR_NGN_WALLET_ID",
+ "amount": 10,
+ "destinationCurrency": "NGN",
+ "description": "Test transfer"
+ }'
+```
+
+If successful, you should receive a response with the transfer details, including the converted amount and transaction ID.
+
+✓ **Achievement unlocked:** You've successfully executed your first cross-currency transfer!
+
+## Step 10: Verifying the Transfer
+
+Check that the transfer was successful by getting the details of your wallets:
+
+```bash
+curl -X GET https://sandbox-api.chimoney.io/v0.2.4/multicurrency-wallets/get?id=YOUR_USD_WALLET_ID \
+ -H "Authorization: Bearer YOUR_API_KEY"
+```
+
+```bash
+curl -X GET https://sandbox-api.chimoney.io/v0.2.4/multicurrency-wallets/get?id=YOUR_NGN_WALLET_ID \
+ -H "Authorization: Bearer YOUR_API_KEY"
+```
+
+You should see the updated balances reflecting the transfer you made.
+
+## Step 11: Sending Money to Email or Phone Number
+
+One of the powerful features of the Multi-Currency Wallet Transfer API is the ability to send money to someone using just their email or phone number, even if they don't have a Chimoney account yet.
+
+This is where the magic of modern fintech truly shines – removing the requirement for recipients to have specific accounts or wallets before they can receive funds. It's like being able to send a package to someone without needing their exact street address – just their name and email.
+
+### Sending to an Email
+
+```bash
+curl -X POST https://sandbox-api.chimoney.io/v0.2.4/multicurrency-wallets/transfer \
+ -H "Authorization: Bearer YOUR_API_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "fromWallet": "YOUR_USD_WALLET_ID",
+ "email": "recipient@example.com",
+ "amount": 10,
+ "destinationCurrency": "NGN",
+ "description": "Payment for services"
+ }'
+```
+
+### Sending to a Phone Number
+
+```bash
+curl -X POST https://sandbox-api.chimoney.io/v0.2.4/multicurrency-wallets/transfer \
+ -H "Authorization: Bearer YOUR_API_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "fromWallet": "YOUR_USD_WALLET_ID",
+ "phoneNumber": "+2348012345678",
+ "amount": 10,
+ "destinationCurrency": "NGN",
+ "description": "Payment for services"
+ }'
+```
+
+Recipients will receive a notification with instructions on how to claim their funds.
+
+**Developer Insight:** "When I first implemented the email transfer feature, our customer support tickets for payment issues dropped by nearly 40%. Users no longer needed to navigate complex wallet setups just to receive their money."
+
+✓ **Achievement unlocked:** You can now send money to anyone with just their email or phone number!
+
+## Common Setup Issues and Solutions
+
+We've all experienced that moment of frustration when something doesn't work as expected. Here's how to overcome common obstacles:
+
+| Issue | Solution |
+|-------|----------|
+| "Unauthorized" error | Double-check your API key and ensure it's correctly formatted in the Authorization header |
+| "Wallet not found" error | Verify the wallet ID is correct and belongs to your account |
+| "Insufficient funds" error | Check your wallet balance and ensure you have enough funds for the transfer including fees |
+| "Invalid currency" error | Ensure you're using supported currencies (USD, CAD, NGN) |
+| Webhook not receiving events | Verify your webhook URL is publicly accessible and returns a 200 OK response |
+
+## Integration with Programming Languages
+
+### Node.js Setup
+
+```javascript
+// Install required packages
+// npm install axios dotenv
+
+require('dotenv').config(); // Load environment variables from .env file
+const axios = require('axios');
+
+// Set up API configuration
+const API_KEY = process.env.CHIMONEY_API_KEY;
+const BASE_URL = 'https://sandbox-api.chimoney.io/v0.2.4';
+
+// Create headers with authentication
+const headers = {
+ 'Authorization': `Bearer ${API_KEY}`,
+ 'Content-Type': 'application/json'
+};
+
+// Example function to create a wallet
+async function createWallet(name, currency) {
+ try {
+ const response = await axios.post(`${BASE_URL}/multicurrency-wallets/create`, {
+ name,
+ currency
+ }, { headers });
+
+ return response.data;
+ } catch (error) {
+ console.error('Error creating wallet:', error.response?.data || error.message);
+ throw error;
+ }
+}
+
+// Example function to transfer between wallets
+async function transferBetweenWallets(fromWallet, toWallet, amount, currency) {
+ try {
+ // First get a quote
+ const quoteResponse = await axios.post(`${BASE_URL}/multicurrency-wallets/transfer/quote`, {
+ fromWallet,
+ amount,
+ destinationCurrency: currency
+ }, { headers });
+
+ console.log('Transfer quote:', quoteResponse.data);
+
+ // Execute the transfer
+ const transferResponse = await axios.post(`${BASE_URL}/multicurrency-wallets/transfer`, {
+ fromWallet,
+ toWallet,
+ amount,
+ destinationCurrency: currency,
+ description: 'Transfer from Node.js application'
+ }, { headers });
+
+ return transferResponse.data;
+ } catch (error) {
+ console.error('Error transferring funds:', error.response?.data || error.message);
+ throw error;
+ }
+}
+
+// Example usage
+async function main() {
+ try {
+ // Create USD wallet
+ const usdWallet = await createWallet('USD Wallet', 'USD');
+ console.log('Created USD wallet:', usdWallet.data.id);
+
+ // Create NGN wallet
+ const ngnWallet = await createWallet('NGN Wallet', 'NGN');
+ console.log('Created NGN wallet:', ngnWallet.data.id);
+
+ // Transfer from USD to NGN
+ const transfer = await transferBetweenWallets(
+ usdWallet.data.id,
+ ngnWallet.data.id,
+ 10,
+ 'NGN'
+ );
+
+ console.log('Transfer completed:', transfer);
+ } catch (error) {
+ console.error('Setup failed:', error);
+ }
+}
+
+main();
+```
+
+### Python Setup
+
+```python
+# Install required packages
+# pip install requests python-dotenv
+
+import os
+import requests
+import json
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Set up API configuration
+API_KEY = os.getenv('CHIMONEY_API_KEY')
+BASE_URL = 'https://sandbox-api.chimoney.io/v0.2.4'
+
+# Create headers with authentication
+headers = {
+ 'Authorization': f'Bearer {API_KEY}',
+ 'Content-Type': 'application/json'
+}
+
+# Example function to create a wallet
+def create_wallet(name, currency):
+ try:
+ response = requests.post(
+ f'{BASE_URL}/multicurrency-wallets/create',
+ headers=headers,
+ json={'name': name, 'currency': currency}
+ )
+ response.raise_for_status()
+ return response.json()
+ except requests.exceptions.RequestException as e:
+ print(f'Error creating wallet: {e}')
+ if hasattr(e, 'response') and e.response:
+ print(f'Error details: {e.response.text}')
+ raise
+
+# Example function to transfer between wallets
+def transfer_between_wallets(from_wallet, to_wallet, amount, currency):
+ try:
+ # First get a quote
+ quote_response = requests.post(
+ f'{BASE_URL}/multicurrency-wallets/transfer/quote',
+ headers=headers,
+ json={
+ 'fromWallet': from_wallet,
+ 'amount': amount,
+ 'destinationCurrency': currency
+ }
+ )
+ quote_response.raise_for_status()
+ quote = quote_response.json()
+ print(f'Transfer quote: {json.dumps(quote, indent=2)}')
+
+ # Execute the transfer
+ transfer_response = requests.post(
+ f'{BASE_URL}/multicurrency-wallets/transfer',
+ headers=headers,
+ json={
+ 'fromWallet': from_wallet,
+ 'toWallet': to_wallet,
+ 'amount': amount,
+ 'destinationCurrency': currency,
+ 'description': 'Transfer from Python application'
+ }
+ )
+ transfer_response.raise_for_status()
+ return transfer_response.json()
+ except requests.exceptions.RequestException as e:
+ print(f'Error transferring funds: {e}')
+ if hasattr(e, 'response') and e.response:
+ print(f'Error details: {e.response.text}')
+ raise
+
+# Example usage
+def main():
+ try:
+ # Create USD wallet
+ usd_wallet = create_wallet('USD Wallet', 'USD')
+ usd_wallet_id = usd_wallet['data']['id']
+ print(f'Created USD wallet: {usd_wallet_id}')
+
+ # Create NGN wallet
+ ngn_wallet = create_wallet('NGN Wallet', 'NGN')
+ ngn_wallet_id = ngn_wallet['data']['id']
+ print(f'Created NGN wallet: {ngn_wallet_id}')
+
+ # Transfer from USD to NGN
+ transfer = transfer_between_wallets(
+ usd_wallet_id,
+ ngn_wallet_id,
+ 10,
+ 'NGN'
+ )
+
+ print(f'Transfer completed: {json.dumps(transfer, indent=2)}')
+ except Exception as e:
+ print(f'Setup failed: {e}')
+
+if __name__ == '__main__':
+ main()
+```
+
+## Security Best Practices
+
+1. **Store API keys securely**: Never hardcode them in your application or expose them in client-side code. The temporary convenience isn't worth the potential security breach.
+2. **Use HTTPS**: Always make API requests over HTTPS to prevent data interception
+3. **Implement rate limiting**: Protect your application from potential abuse
+4. **Log API interactions**: Keep detailed logs for auditing and troubleshooting
+5. **Set up monitoring**: Monitor API usage and set alerts for unusual activity
+6. **Validate inputs**: Always validate user inputs before sending them to the API
+7. **Implement idempotency**: Use unique identifiers for transfers to prevent duplicate transactions
+8. **Regular audits**: Periodically audit your wallet balances and transaction history
+
+## Additional Resources
+
+- [Chimoney API Documentation](https://chimoney.readme.io/reference/introduction)
+- [Sandbox Environment](https://sandbox.chimoney.io/)
+- [API Status Page](https://chimoney.github.io/chimoney-status/)
+- [Community Support](https://discord.gg/TsyKnzT4qV)
+
+By following this setup guide, you now have everything you need to start using Chimoney's Multi-Currency Wallet Transfer API in your applications. Whether you're building a global payroll system, a marketplace, or a remittance platform, you can now transfer funds seamlessly across different currencies.
+
+✓ **Final Achievement Unlocked:** You've successfully set up the Chimoney Multi-Currency Wallet Transfer API and taken the first step toward building borderless financial experiences for your users!
\ No newline at end of file
diff --git a/submissions/multicurrency-wallets-transfer-Brijeshthummar02/tutorial.md b/submissions/multicurrency-wallets-transfer-Brijeshthummar02/tutorial.md
new file mode 100644
index 0000000..6c2e2de
--- /dev/null
+++ b/submissions/multicurrency-wallets-transfer-Brijeshthummar02/tutorial.md
@@ -0,0 +1,1458 @@
+# Tutorial: Implementing Multi-Currency Wallet Transfers with Chimoney API
+
+This tutorial will guide you through the process of implementing Chimoney's Multi-Currency Wallet Transfer API in your application. By the end of this guide, you'll be able to create wallets in different currencies, get exchange rate quotes, and transfer funds between currencies seamlessly.
+
+> **Developer Journey:** "When I first needed to implement cross-currency payments for my client's application, I spent weeks juggling multiple payment providers and conversion services. That complexity nearly cost us our project deadline. Then I discovered Chimoney's API. What once took 120+ lines of code across multiple services now takes just 15 lines with a single API. That feeling when the first test transfer succeeded is something I want you to experience today."
+
+## Introduction
+
+Chimoney's Multi-Currency Wallet Transfer API allows developers to build applications that can transfer money between different currencies with minimal friction. This functionality is particularly valuable for:
+
+- Global payroll systems
+- Cross-border e-commerce platforms
+- Remittance applications
+- Freelance marketplaces with international users
+- Travel applications handling multiple currencies
+
+The API currently supports transfers between USD, CAD, and NGN wallets, with more currencies planned for the future.
+
+## Prerequisites
+
+Before starting this tutorial, make sure you have:
+
+- A Chimoney sandbox account
+- API key generated from your Chimoney dashboard
+- Basic knowledge of RESTful APIs
+- A development environment with your preferred programming language
+- HTTP client (like Axios, Fetch, or cURL) for making API requests
+
+Don't worry if you're not an API expert—this tutorial assumes you're new to Chimoney but not new to coding. We'll celebrate each small victory along the way, from your first wallet creation to your first successful cross-currency transfer. Remember: every financial integration expert started exactly where you are now.
+
+If you haven't set up your Chimoney account and API key yet, please refer to the [Setup Guide](./setup.md) first.
+
+## Step 1: Create Multi-Currency Wallets
+
+The first step is to create wallets for each currency you want to work with. For this tutorial, we'll create wallets for USD, NGN, and CAD.
+
+### Creating a USD Wallet
+
+```javascript
+// Using Node.js with Axios
+const axios = require('axios');
+
+const API_KEY = 'YOUR_CHIMONEY_API_KEY';
+const BASE_URL = 'https://sandbox-api.chimoney.io/v0.2.4';
+
+async function createUSDWallet() {
+ try {
+ const response = await axios.post(
+ `${BASE_URL}/multicurrency-wallets/create`,
+ {
+ name: 'USD Wallet',
+ currency: 'USD'
+ },
+ {
+ headers: {
+ 'Authorization': `Bearer ${API_KEY}`,
+ 'Content-Type': 'application/json'
+ }
+ }
+ );
+
+ console.log('USD Wallet created:', response.data);
+ return response.data.data.id; // Save this wallet ID for later use
+ } catch (error) {
+ console.error('Error creating USD wallet:', error.response?.data || error.message);
+ throw error;
+ }
+}
+```
+
+**Developer Insight:** "There's something deeply satisfying about that first successful API response. It's like the digital equivalent of laying the foundation for a house—not glamorous yet, but essential for everything that follows."
+
+✓ **Achievement unlocked:** You've created your first digital currency container!
+
+### Creating an NGN Wallet
+
+```javascript
+async function createNGNWallet() {
+ try {
+ const response = await axios.post(
+ `${BASE_URL}/multicurrency-wallets/create`,
+ {
+ name: 'NGN Wallet',
+ currency: 'NGN'
+ },
+ {
+ headers: {
+ 'Authorization': `Bearer ${API_KEY}`,
+ 'Content-Type': 'application/json'
+ }
+ }
+ );
+
+ console.log('NGN Wallet created:', response.data);
+ return response.data.data.id; // Save this wallet ID for later use
+ } catch (error) {
+ console.error('Error creating NGN wallet:', error.response?.data || error.message);
+ throw error;
+ }
+}
+```
+
+### Creating a CAD Wallet
+
+```javascript
+async function createCADWallet() {
+ try {
+ const response = await axios.post(
+ `${BASE_URL}/multicurrency-wallets/create`,
+ {
+ name: 'CAD Wallet',
+ currency: 'CAD'
+ },
+ {
+ headers: {
+ 'Authorization': `Bearer ${API_KEY}`,
+ 'Content-Type': 'application/json'
+ }
+ }
+ );
+
+ console.log('CAD Wallet created:', response.data);
+ return response.data.data.id; // Save this wallet ID for later use
+ } catch (error) {
+ console.error('Error creating CAD wallet:', error.response?.data || error.message);
+ throw error;
+ }
+}
+```
+
+## Step 2: List Your Wallets
+
+After creating the wallets, you can list them to verify they were created successfully and check their balances:
+
+```javascript
+async function listWallets() {
+ try {
+ const response = await axios.get(
+ `${BASE_URL}/multicurrency-wallets/list`,
+ {
+ headers: {
+ 'Authorization': `Bearer ${API_KEY}`
+ }
+ }
+ );
+
+ console.log('Your wallets:', response.data);
+ return response.data.data; // Array of wallet objects
+ } catch (error) {
+ console.error('Error listing wallets:', error.response?.data || error.message);
+ throw error;
+ }
+}
+```
+
+## Step 3: Get a Transfer Quote
+
+Before executing a transfer, it's a good practice to get a quote to show the user the exchange rate, fees, and final amount they'll receive. This step transforms the anxiety-inducing mystery of "How much will this actually cost?" into a transparent transaction where everyone knows exactly what to expect.
+
+Think of it like checking the weather before going out—it helps you prepare for what's ahead and prevents unpleasant surprises:
+
+```javascript
+async function getTransferQuote(fromWalletId, amount, destinationCurrency) {
+ try {
+ const response = await axios.post(
+ `${BASE_URL}/multicurrency-wallets/transfer/quote`,
+ {
+ fromWallet: fromWalletId,
+ amount: amount,
+ destinationCurrency: destinationCurrency
+ },
+ {
+ headers: {
+ 'Authorization': `Bearer ${API_KEY}`,
+ 'Content-Type': 'application/json'
+ }
+ }
+ );
+
+ console.log('Transfer quote:', response.data);
+ return response.data.data;
+ } catch (error) {
+ console.error('Error getting transfer quote:', error.response?.data || error.message);
+ throw error;
+ }
+}
+```
+
+Example usage:
+
+```javascript
+// Get a quote for converting 100 USD to NGN
+const quote = await getTransferQuote('usd_wallet_id', 100, 'NGN');
+console.log(`100 USD = ${quote.destinationAmount} NGN`);
+console.log(`Exchange rate: 1 USD = ${quote.exchangeRate} NGN`);
+console.log(`Fee: ${quote.fee} USD`);
+console.log(`Total debit: ${quote.totalDebit} USD`);
+```
+
+## Step 4: Execute a Wallet-to-Wallet Transfer
+
+Now that we have our wallets and a quote, we can execute a transfer between wallets:
+
+```javascript
+async function transferBetweenWallets(fromWalletId, toWalletId, amount, destinationCurrency, description) {
+ try {
+ const response = await axios.post(
+ `${BASE_URL}/multicurrency-wallets/transfer`,
+ {
+ fromWallet: fromWalletId,
+ toWallet: toWalletId,
+ amount: amount,
+ destinationCurrency: destinationCurrency,
+ description: description || 'Wallet to wallet transfer'
+ },
+ {
+ headers: {
+ 'Authorization': `Bearer ${API_KEY}`,
+ 'Content-Type': 'application/json'
+ }
+ }
+ );
+
+ console.log('Transfer successful:', response.data);
+ return response.data.data;
+ } catch (error) {
+ console.error('Error transferring funds:', error.response?.data || error.message);
+ throw error;
+ }
+}
+```
+
+Example usage:
+
+```javascript
+// Transfer 100 USD to NGN wallet
+const transfer = await transferBetweenWallets(
+ 'usd_wallet_id',
+ 'ngn_wallet_id',
+ 100,
+ 'NGN',
+ 'Salary payment'
+);
+
+console.log(`Transfer ID: ${transfer.id}`);
+console.log(`Amount sent: ${transfer.amount} ${transfer.sourceCurrency}`);
+console.log(`Amount received: ${transfer.destinationAmount} ${transfer.destinationCurrency}`);
+console.log(`Status: ${transfer.status}`);
+```
+
+When this code executes successfully, there's a moment of pure developer satisfaction—watching the funds move from one currency to another in seconds rather than days. What might seem like a simple transfer to us represents something much more significant to the recipient: timely access to their earnings, ability to pay bills without delays, or simply the peace of mind that comes with financial stability.
+
+✓ **Achievement unlocked:** You've successfully moved money across currencies in seconds instead of days!
+
+## Step 5: Transfer to Email or Phone Number
+
+One of the powerful features of Chimoney's API is the ability to send money to someone using just their email or phone number, even if they don't have a Chimoney account yet.
+
+This is where the magic of modern fintech truly shines. It's like being able to deliver a package to someone without needing their exact street address—just their name and email. This seemingly small feature can be transformative for businesses working with freelancers in regions with limited banking infrastructure:
+
+```javascript
+async function transferToEmail(fromWalletId, email, amount, destinationCurrency, description) {
+ try {
+ const response = await axios.post(
+ `${BASE_URL}/multicurrency-wallets/transfer`,
+ {
+ fromWallet: fromWalletId,
+ email: email,
+ amount: amount,
+ destinationCurrency: destinationCurrency,
+ description: description || 'Payment via email'
+ },
+ {
+ headers: {
+ 'Authorization': `Bearer ${API_KEY}`,
+ 'Content-Type': 'application/json'
+ }
+ }
+ );
+
+ console.log('Transfer to email successful:', response.data);
+ return response.data.data;
+ } catch (error) {
+ console.error('Error transferring to email:', error.response?.data || error.message);
+ throw error;
+ }
+}
+```
+
+```javascript
+async function transferToPhone(fromWalletId, phoneNumber, amount, destinationCurrency, description) {
+ try {
+ const response = await axios.post(
+ `${BASE_URL}/multicurrency-wallets/transfer`,
+ {
+ fromWallet: fromWalletId,
+ phoneNumber: phoneNumber,
+ amount: amount,
+ destinationCurrency: destinationCurrency,
+ description: description || 'Payment via phone'
+ },
+ {
+ headers: {
+ 'Authorization': `Bearer ${API_KEY}`,
+ 'Content-Type': 'application/json'
+ }
+ }
+ );
+
+ console.log('Transfer to phone successful:', response.data);
+ return response.data.data;
+ } catch (error) {
+ console.error('Error transferring to phone:', error.response?.data || error.message);
+ throw error;
+ }
+}
+```
+
+Example usage:
+
+```javascript
+// Send 50 USD (converted to NGN) to an email
+const emailTransfer = await transferToEmail(
+ 'usd_wallet_id',
+ 'recipient@example.com',
+ 50,
+ 'NGN',
+ 'Freelance payment'
+);
+
+// Send 75 USD (converted to NGN) to a phone number
+const phoneTransfer = await transferToPhone(
+ 'usd_wallet_id',
+ '+2348012345678',
+ 75,
+ 'NGN',
+ 'Contract payment'
+);
+```
+
+## Step 6: Check Transfer Status
+
+After initiating a transfer, you may want to check its status:
+
+```javascript
+async function checkTransferStatus(transferId) {
+ try {
+ const response = await axios.get(
+ `${BASE_URL}/multicurrency-wallets/transfer/status?id=${transferId}`,
+ {
+ headers: {
+ 'Authorization': `Bearer ${API_KEY}`
+ }
+ }
+ );
+
+ console.log('Transfer status:', response.data);
+ return response.data.data;
+ } catch (error) {
+ console.error('Error checking transfer status:', error.response?.data || error.message);
+ throw error;
+ }
+}
+```
+
+Example usage:
+
+```javascript
+// Check the status of a transfer
+const status = await checkTransferStatus('transfer_123456');
+console.log(`Transfer status: ${status.status}`);
+console.log(`Created at: ${new Date(status.createdAt).toLocaleString()}`);
+if (status.completedAt) {
+ console.log(`Completed at: ${new Date(status.completedAt).toLocaleString()}`);
+}
+```
+
+## Step 7: Implement Error Handling
+
+We've all felt that moment of panic when a financial transaction fails and we don't know if the money is gone, pending, or refunded. That's why robust error handling isn't just good practice—it's essential for maintaining your users' trust and your own peace of mind.
+
+Proper error handling transforms a potentially anxiety-inducing experience into a manageable situation where problems have clear solutions. Here's how to handle common errors:
+
+```javascript
+async function safeTransfer(fromWalletId, toWalletId, amount, destinationCurrency, description) {
+ try {
+ // First, check if the wallet has sufficient balance
+ const walletInfo = await axios.get(
+ `${BASE_URL}/multicurrency-wallets/get?id=${fromWalletId}`,
+ {
+ headers: {
+ 'Authorization': `Bearer ${API_KEY}`
+ }
+ }
+ );
+
+ const wallet = walletInfo.data.data;
+ if (wallet.balance < amount) {
+ throw new Error(`Insufficient balance: ${wallet.balance} ${wallet.currency} available, ${amount} ${wallet.currency} required`);
+ }
+
+ // Get a quote to check fees
+ const quote = await getTransferQuote(fromWalletId, amount, destinationCurrency);
+ const totalRequired = quote.totalDebit;
+
+ if (wallet.balance < totalRequired) {
+ throw new Error(`Insufficient balance including fees: ${wallet.balance} ${wallet.currency} available, ${totalRequired} ${wallet.currency} required (includes ${quote.fee} fee)`);
+ }
+
+ // Execute the transfer
+ const transfer = await transferBetweenWallets(
+ fromWalletId,
+ toWalletId,
+ amount,
+ destinationCurrency,
+ description
+ );
+
+ return {
+ success: true,
+ transfer: transfer,
+ quote: quote
+ };
+ } catch (error) {
+ // Handle specific API errors
+ if (error.response) {
+ const statusCode = error.response.status;
+ const errorData = error.response.data;
+
+ if (statusCode === 401) {
+ return {
+ success: false,
+ error: 'Authentication failed. Please check your API key.',
+ details: errorData
+ };
+ } else if (statusCode === 404) {
+ return {
+ success: false,
+ error: 'Wallet not found. Please check the wallet IDs.',
+ details: errorData
+ };
+ } else if (statusCode === 400) {
+ return {
+ success: false,
+ error: 'Invalid request. Please check your parameters.',
+ details: errorData
+ };
+ } else {
+ return {
+ success: false,
+ error: `API error (${statusCode}): ${errorData.message || 'Unknown error'}`,
+ details: errorData
+ };
+ }
+ } else {
+ // Handle network or other errors
+ return {
+ success: false,
+ error: error.message || 'Unknown error occurred',
+ details: error
+ };
+ }
+ }
+}
+```
+
+## Step 8: Building a Complete Transfer Flow
+
+Now let's put everything together to create a complete transfer flow. This is where separate pieces become a cohesive experience—like assembling individual ingredients into a delicious meal that's greater than the sum of its parts.
+
+Your users won't see the individual API calls; they'll experience the outcome: the delight of sending money across borders without complexity, the relief of knowing exactly what fees to expect, and the satisfaction of seeing the recipient receive funds instantly:
+
+```javascript
+async function completeTransferFlow() {
+ try {
+ // Step 1: Create wallets if they don't exist
+ console.log('Creating wallets...');
+ const usdWalletId = await createUSDWallet();
+ const ngnWalletId = await createNGNWallet();
+
+ // Step 2: List wallets to check balances
+ console.log('Listing wallets...');
+ const wallets = await listWallets();
+ const usdWallet = wallets.find(w => w.id === usdWalletId);
+ const ngnWallet = wallets.find(w => w.id === ngnWalletId);
+
+ console.log(`USD Wallet balance: ${usdWallet.balance} USD`);
+ console.log(`NGN Wallet balance: ${ngnWallet.balance} NGN`);
+
+ // Step 3: Get a transfer quote
+ console.log('Getting transfer quote...');
+ const amount = 100; // USD
+ const quote = await getTransferQuote(usdWalletId, amount, 'NGN');
+
+ console.log(`Exchange rate: 1 USD = ${quote.exchangeRate} NGN`);
+ console.log(`${amount} USD = ${quote.destinationAmount} NGN`);
+ console.log(`Fee: ${quote.fee} USD`);
+ console.log(`Total debit: ${quote.totalDebit} USD`);
+
+ // Step 4: Confirm with user (simulated here)
+ const userConfirmed = true; // In a real app, this would come from user input
+
+ if (userConfirmed) {
+ // Step 5: Execute the transfer
+ console.log('Executing transfer...');
+ const transfer = await transferBetweenWallets(
+ usdWalletId,
+ ngnWalletId,
+ amount,
+ 'NGN',
+ 'Cross-currency transfer demo'
+ );
+
+ console.log(`Transfer successful! ID: ${transfer.id}`);
+ console.log(`Amount sent: ${transfer.amount} ${transfer.sourceCurrency}`);
+ console.log(`Amount received: ${transfer.destinationAmount} ${transfer.destinationCurrency}`);
+
+ // Step 6: Check updated balances
+ console.log('Checking updated balances...');
+ const updatedWallets = await listWallets();
+ const updatedUsdWallet = updatedWallets.find(w => w.id === usdWalletId);
+ const updatedNgnWallet = updatedWallets.find(w => w.id === ngnWalletId);
+
+ console.log(`New USD Wallet balance: ${updatedUsdWallet.balance} USD`);
+ console.log(`New NGN Wallet balance: ${updatedNgnWallet.balance} NGN`);
+
+ return {
+ success: true,
+ transfer: transfer,
+ usdBalance: updatedUsdWallet.balance,
+ ngnBalance: updatedNgnWallet.balance
+ };
+ } else {
+ console.log('Transfer cancelled by user');
+ return {
+ success: false,
+ reason: 'cancelled'
+ };
+ }
+ } catch (error) {
+ console.error('Error in transfer flow:', error);
+ return {
+ success: false,
+ error: error.message || 'Unknown error occurred',
+ details: error
+ };
+ }
+}
+```
+
+## Step 9: Implementing a Transfer UI (Web Example)
+
+The API is powerful, but users interact with interfaces, not endpoints. A thoughtful UI can transform a technical process into an intuitive experience that builds trust and confidence.
+
+Remember: behind every transfer is a real person with real needs—perhaps a freelancer waiting for payment to buy groceries, or a parent sending money to a child studying abroad. Your interface is the bridge between complex financial operations and human needs:
+
+Here's a simple HTML and JavaScript example for implementing a transfer UI in a web application:
+
+```html
+
+
+
+
+
+ Multi-Currency Wallet Transfer
+
+
+
+
+
Multi-Currency Wallet Transfer
+
+
+
+
USD Wallet
+
$1,000.00
+
+
+
NGN Wallet
+
₦0.00
+
+
+
CAD Wallet
+
C$0.00
+
+
+
+
+
+
+
Transfer Quote
+
Exchange Rate: -
+
You Send: -
+
Recipient Gets: -
+
Fee: -
+
Total Debit: -
+
+
+
+
+
+
Transfer Successful!
+
Transfer ID: -
+
Amount Sent: -
+
Amount Received: -
+
Status: -
+
+
+
+
Error
+
+
+
+
+
+
+
+```
+
+## Step 10: Testing Your Implementation
+
+Before deploying to your application, thoroughly test your implementation:
+
+1. **Create wallets in different currencies**
+ - Verify wallet creation in USD, NGN, and CAD
+ - Check that wallet IDs are correctly returned and stored
+
+2. **Test wallet listing**
+ - Ensure all created wallets are visible
+ - Verify balances are correctly displayed
+
+3. **Test quote functionality**
+ - Request quotes for various amounts and currency pairs
+ - Verify exchange rates, fees, and final amounts are reasonable
+
+4. **Test wallet-to-wallet transfers**
+ - Transfer between your own wallets in different currencies
+ - Verify source wallet is debited correctly (including fees)
+ - Verify destination wallet is credited with the converted amount
+
+5. **Test transfers to email/phone**
+ - Send test transfers to your own email/phone
+ - Verify the recipient notification and claim process
+
+6. **Test error handling**
+ - Attempt transfers with insufficient balance
+ - Use invalid wallet IDs
+ - Try unsupported currency conversions
+ - Test with invalid API keys
+
+7. **Test webhook notifications**
+ - Set up a test endpoint to receive webhooks
+ - Verify that transfer status updates trigger notifications
+
+## The Human Impact of Your Implementation
+
+As you complete this tutorial, it's worth reflecting on what you've actually built:
+
+- For the Nigerian developer, your implementation means receiving payment immediately rather than waiting 5 days
+- For the Canadian designer, it means receiving more of their actual earnings instead of losing 5-7% to fees
+- For the finance manager, it means spending Thursday afternoon on strategic planning instead of troubleshooting payment issues
+- For your company, it means attracting global talent without geographical payment limitations
+
+These aren't just technical achievements—they're human impacts that ripple outward from your code. The time you've invested in this implementation will pay dividends in user satisfaction, operational efficiency, and global accessibility.
+
+✓ **Achievement unlocked:** You've built a borderless financial system that connects people and value across currencies and countries!
+
+## Conclusion
+
+You've now successfully implemented Chimoney's Multi-Currency Wallet Transfer API in your application. This is no small achievement—you've essentially built a bridge across the traditional financial borders that separate people and currencies.
+
+This functionality allows your users to:
+
+- Create wallets in different currencies (USD, NGN, CAD)
+- Get real-time exchange rate quotes (transparency that builds trust)
+- Transfer funds between wallets with automatic currency conversion (complexity made simple)
+- Send money to recipients via email or phone number (accessibility for all)
+
+By following this tutorial, you've built a robust integration that handles the complexities of cross-currency transfers, including exchange rates, fees, and error handling. More importantly, you've created an opportunity for your application to become an essential part of your users' financial lives.
+
+**Final Achievement Unlocked:** You've mastered the Multi-Currency Wallet Transfer API and joined the community of developers building borderless financial experiences!
+
+## Interactive Testing Resources
+
+To help you test and explore the Multi-Currency Wallet Transfer API, Chimoney provides several interactive resources:
+
+1. **Swagger UI**: You can test the API directly through Chimoney's Swagger interface at [https://sandbox-api.chimoney.io/v0.2.4/api-docs/#/Interledger/post_v0_2_4_multicurrency_wallets_transfer](https://api.chimoney.io/v0.2.4/api-docs/#/Interledger/post_v0_2_4_multicurrency_wallets_transfer). This allows you to:
+ - Execute API calls directly from your browser
+ - See all available parameters and their descriptions
+ - Test different parameter combinations
+ - View complete response structures
+
+2. **Official API Documentation**: For detailed information about all multi-currency wallet endpoints, refer to the official Chimoney documentation at [https://chimoney.readme.io/reference/post_v0-2-4-multicurrency-wallets-create](https://chimoney.readme.io/reference/post_v0-2-4-multicurrency-wallets-create). The documentation includes:
+ - Detailed parameter descriptions
+ - Response examples
+ - Error codes and their meanings
+ - Implementation notes and best practices
+
+These resources are invaluable for both initial implementation and troubleshooting, allowing you to test API behavior before writing any code.
+
+## Troubleshooting Common Issues
+
+When implementing the Multi-Currency Wallet Transfer API, you might encounter these common issues:
+
+### Authentication Problems
+- **Issue**: 401 Unauthorized errors
+- **Solution**: Verify your API key is correct and properly formatted in the Authorization header as `Bearer YOUR_API_KEY`
+- **Prevention**: Store API keys securely and implement key rotation
+
+### Insufficient Funds
+- **Issue**: 400 Bad Request with "insufficient_funds" error code
+- **Solution**: Always check wallet balance before attempting transfers and include fee calculations
+- **Prevention**: Implement the quote-before-transfer pattern shown in this tutorial
+
+### Invalid Wallet IDs
+- **Issue**: 404 Not Found when referencing wallet IDs
+- **Solution**: Verify wallet IDs exist and belong to your account
+- **Prevention**: Store wallet IDs persistently and validate before use
+
+### Currency Conversion Limitations
+- **Issue**: Unsupported currency pair errors
+- **Solution**: Check the supported currency pairs in the API documentation
+- **Prevention**: Only offer supported currency options in your UI
+
+### Rate Limiting
+- **Issue**: 429 Too Many Requests
+- **Solution**: Implement exponential backoff and retry logic
+- **Prevention**: Cache results where appropriate and batch operations when possible
+
+### Webhook Configuration
+- **Issue**: Not receiving transfer status updates
+- **Solution**: Verify webhook URL is accessible from the internet and properly handling POST requests
+- **Prevention**: Test webhook endpoint with sample payloads before relying on it
+
+For any persistent issues, contact Chimoney support through their [Discord community](https://discord.gg/TsyKnzT4qV) in the dedicated support channels.
+
+## Python Implementation Example
+
+For developers working with Python, here's an implementation of the key functionality using the `requests` library:
+
+```python
+import requests
+import json
+
+class ChimoneyWalletAPI:
+ def __init__(self, api_key):
+ """Initialize the Chimoney Wallet API client.
+
+ Args:
+ api_key (str): Your Chimoney API key
+ """
+ self.api_key = api_key
+ self.base_url = "https://sandbox-api.chimoney.io/v0.2.4"
+ self.headers = {
+ "Authorization": f"Bearer {self.api_key}",
+ "Content-Type": "application/json"
+ }
+
+ def create_wallet(self, name, currency):
+ """Create a new wallet with specified currency.
+
+ Args:
+ name (str): Name for the new wallet
+ currency (str): Currency code (USD, NGN, CAD)
+
+ Returns:
+ dict: Wallet data including ID and balance
+ """
+ url = f"{self.base_url}/multicurrency-wallets/create"
+ payload = {
+ "name": name,
+ "currency": currency
+ }
+
+ response = requests.post(url, headers=self.headers, json=payload)
+ response.raise_for_status() # Raise exception for 4XX/5XX responses
+
+ return response.json().get("data")
+
+ def list_wallets(self):
+ """List all wallets in the account.
+
+ Returns:
+ list: List of wallet objects
+ """
+ url = f"{self.base_url}/multicurrency-wallets/list"
+
+ response = requests.get(url, headers=self.headers)
+ response.raise_for_status()
+
+ return response.json().get("data")
+
+ def get_wallet(self, wallet_id):
+ """Get details for a specific wallet.
+
+ Args:
+ wallet_id (str): ID of the wallet to retrieve
+
+ Returns:
+ dict: Wallet details including balance
+ """
+ url = f"{self.base_url}/multicurrency-wallets/get"
+ params = {"id": wallet_id}
+
+ response = requests.get(url, headers=self.headers, params=params)
+ response.raise_for_status()
+
+ return response.json().get("data")
+
+ def get_transfer_quote(self, from_wallet_id, amount, destination_currency):
+ """Get a quote for currency conversion.
+
+ Args:
+ from_wallet_id (str): Source wallet ID
+ amount (float): Amount to transfer
+ destination_currency (str): Target currency code
+
+ Returns:
+ dict: Quote details including exchange rate and fees
+ """
+ url = f"{self.base_url}/multicurrency-wallets/transfer/quote"
+ payload = {
+ "fromWallet": from_wallet_id,
+ "amount": amount,
+ "destinationCurrency": destination_currency
+ }
+
+ response = requests.post(url, headers=self.headers, json=payload)
+ response.raise_for_status()
+
+ return response.json().get("data")
+
+ def transfer_between_wallets(self, from_wallet_id, to_wallet_id, amount,
+ destination_currency, description=None):
+ """Transfer funds between wallets.
+
+ Args:
+ from_wallet_id (str): Source wallet ID
+ to_wallet_id (str): Destination wallet ID
+ amount (float): Amount to transfer
+ destination_currency (str): Currency to convert to
+ description (str, optional): Transfer description
+
+ Returns:
+ dict: Transfer details
+ """
+ url = f"{self.base_url}/multicurrency-wallets/transfer"
+ payload = {
+ "fromWallet": from_wallet_id,
+ "toWallet": to_wallet_id,
+ "amount": amount,
+ "destinationCurrency": destination_currency
+ }
+
+ if description:
+ payload["description"] = description
+
+ response = requests.post(url, headers=self.headers, json=payload)
+ response.raise_for_status()
+
+ return response.json().get("data")
+
+ def transfer_to_email(self, from_wallet_id, email, amount,
+ destination_currency, description=None):
+ """Transfer funds to an email address.
+
+ Args:
+ from_wallet_id (str): Source wallet ID
+ email (str): Recipient email address
+ amount (float): Amount to transfer
+ destination_currency (str): Currency to convert to
+ description (str, optional): Transfer description
+
+ Returns:
+ dict: Transfer details
+ """
+ url = f"{self.base_url}/multicurrency-wallets/transfer"
+ payload = {
+ "fromWallet": from_wallet_id,
+ "email": email,
+ "amount": amount,
+ "destinationCurrency": destination_currency
+ }
+
+ if description:
+ payload["description"] = description
+
+ response = requests.post(url, headers=self.headers, json=payload)
+ response.raise_for_status()
+
+ return response.json().get("data")
+
+ def transfer_to_phone(self, from_wallet_id, phone_number, amount,
+ destination_currency, description=None):
+ """Transfer funds to a phone number.
+
+ Args:
+ from_wallet_id (str): Source wallet ID
+ phone_number (str): Recipient phone number (with country code)
+ amount (float): Amount to transfer
+ destination_currency (str): Currency to convert to
+ description (str, optional): Transfer description
+
+ Returns:
+ dict: Transfer details
+ """
+ url = f"{self.base_url}/multicurrency-wallets/transfer"
+ payload = {
+ "fromWallet": from_wallet_id,
+ "phoneNumber": phone_number,
+ "amount": amount,
+ "destinationCurrency": destination_currency
+ }
+
+ if description:
+ payload["description"] = description
+
+ response = requests.post(url, headers=self.headers, json=payload)
+ response.raise_for_status()
+
+ return response.json().get("data")
+
+ def check_transfer_status(self, transfer_id):
+ """Check the status of a transfer.
+
+ Args:
+ transfer_id (str): ID of the transfer to check
+
+ Returns:
+ dict: Transfer status details
+ """
+ url = f"{self.base_url}/multicurrency-wallets/transfer/status"
+ params = {"id": transfer_id}
+
+ response = requests.get(url, headers=self.headers, params=params)
+ response.raise_for_status()
+
+ return response.json().get("data")
+
+
+# Example usage
+if __name__ == "__main__":
+ # Initialize the client (use your API key)
+ chimoney = ChimoneyWalletAPI(api_key="YOUR_API_KEY")
+
+ try:
+ # Create wallets
+ print("Creating USD wallet...")
+ usd_wallet = chimoney.create_wallet("USD Wallet", "USD")
+ print(f"USD wallet created with ID: {usd_wallet['id']}")
+
+ print("Creating NGN wallet...")
+ ngn_wallet = chimoney.create_wallet("NGN Wallet", "NGN")
+ print(f"NGN wallet created with ID: {ngn_wallet['id']}")
+
+ # List wallets
+ print("\nListing wallets:")
+ wallets = chimoney.list_wallets()
+ for wallet in wallets:
+ print(f"{wallet['name']}: {wallet['balance']} {wallet['currency']} (ID: {wallet['id']})")
+
+ # Get a transfer quote
+ print("\nGetting transfer quote...")
+ amount = 100 # USD
+ quote = chimoney.get_transfer_quote(usd_wallet['id'], amount, "NGN")
+ print(f"Exchange rate: 1 USD = {quote['exchangeRate']} NGN")
+ print(f"{amount} USD = {quote['destinationAmount']} NGN")
+ print(f"Fee: {quote['fee']} USD")
+ print(f"Total debit: {quote['totalDebit']} USD")
+
+ # Execute a transfer
+ print("\nExecuting transfer...")
+ transfer = chimoney.transfer_between_wallets(
+ usd_wallet['id'],
+ ngn_wallet['id'],
+ amount,
+ "NGN",
+ "Cross-currency transfer demo"
+ )
+
+ print(f"Transfer successful! ID: {transfer['id']}")
+ print(f"Amount sent: {transfer['amount']} {transfer['sourceCurrency']}")
+ print(f"Amount received: {transfer['destinationAmount']} {transfer['destinationCurrency']}")
+
+ # Check updated balances
+ print("\nChecking updated balances...")
+ updated_usd_wallet = chimoney.get_wallet(usd_wallet['id'])
+ updated_ngn_wallet = chimoney.get_wallet(ngn_wallet['id'])
+
+ print(f"New USD Wallet balance: {updated_usd_wallet['balance']} USD")
+ print(f"New NGN Wallet balance: {updated_ngn_wallet['balance']} NGN")
+
+ except requests.exceptions.HTTPError as e:
+ print(f"HTTP Error: {e}")
+ if e.response is not None:
+ print(f"Response: {e.response.text}")
+ except Exception as e:
+ print(f"Error: {e}")
+```
+
+This Python implementation provides the same functionality as the JavaScript examples, using a class-based approach for better organization and reusability.
+
+## Enhanced Error Handling for Multi-Currency Operations
+
+When working with multi-currency transfers, it's important to implement robust error handling that addresses the specific error types you might encounter. Chimoney's API provides detailed error information that can help you debug and handle issues gracefully.
+
+### Error Types Specific to Multi-Currency Operations
+
+```javascript
+// Enhanced error handling function for multi-currency operations
+function handleMultiCurrencyError(error) {
+ if (!error.response || !error.response.data) {
+ console.error('Network error or unexpected error format:', error.message);
+ return;
+ }
+
+ const errorData = error.response.data;
+ const statusCode = error.response.status;
+ const errorType = errorData.error?.type;
+ const errorMessage = errorData.error?.message || 'Unknown error';
+
+ switch (errorType) {
+ case 'MULTICURRENCY_ERROR':
+ console.error(`Multi-currency operation failed: ${errorMessage}`);
+ // Handle currency conversion issues
+ break;
+
+ case 'WALLET_ERROR':
+ console.error(`Wallet operation failed: ${errorMessage}`);
+ if (errorMessage.includes('insufficient funds')) {
+ // Handle insufficient funds specifically
+ showInsufficientFundsMessage();
+ } else if (errorMessage.includes('wallet not found')) {
+ // Handle invalid wallet ID
+ promptForWalletSelection();
+ }
+ break;
+
+ case 'CURRENCY_ERROR':
+ console.error(`Currency error: ${errorMessage}`);
+ // Handle unsupported currency pairs or exchange rate issues
+ showSupportedCurrencies();
+ break;
+
+ case 'VALIDATION_ERROR':
+ console.error(`Validation failed: ${errorMessage}`);
+ // Parse validation errors and highlight form fields
+ highlightInvalidFields(errorData.error.details);
+ break;
+
+ default:
+ if (statusCode === 429) {
+ // Rate limit exceeded
+ console.error('Rate limit exceeded. Implementing backoff...');
+ implementBackoff();
+ } else if (statusCode >= 500) {
+ // Server error
+ console.error('Server error. The request might have been processed partially or not at all.');
+ checkTransactionStatus();
+ } else {
+ console.error(`Error (${statusCode}): ${errorMessage}`);
+ }
+ }
+}
+```
+
+### Implementing Idempotency for Safe Retries
+
+For operations like transfers that should not be duplicated, use idempotency keys:
+
+```javascript
+// Generate a unique idempotency key
+function generateIdempotencyKey() {
+ return `transfer-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+}
+
+// Modified transfer function with idempotency support
+async function transferBetweenWalletsWithIdempotency(fromWalletId, toWalletId, amount, destinationCurrency, description) {
+ const idempotencyKey = generateIdempotencyKey();
+
+ try {
+ const response = await axios.post(
+ `${BASE_URL}/multicurrency-wallets/transfer`,
+ {
+ fromWallet: fromWalletId,
+ toWallet: toWalletId,
+ amount: amount,
+ destinationCurrency: destinationCurrency,
+ description: description || 'Wallet to wallet transfer'
+ },
+ {
+ headers: {
+ 'Authorization': `Bearer ${API_KEY}`,
+ 'Content-Type': 'application/json',
+ 'Idempotency-Key': idempotencyKey
+ }
+ }
+ );
+
+ console.log('Transfer successful:', response.data);
+ return response.data.data;
+ } catch (error) {
+ handleMultiCurrencyError(error);
+ throw error;
+ }
+}
+```
+
+### Retry Strategy with Exponential Backoff
+
+For handling transient errors or rate limits:
+
+```javascript
+// Retry function with exponential backoff
+async function retryWithBackoff(fn, maxRetries = 3, initialDelay = 1000) {
+ let retries = 0;
+
+ while (retries < maxRetries) {
+ try {
+ return await fn();
+ } catch (error) {
+ // Only retry for certain error types (429 rate limit, or 5xx server errors)
+ if (error.response && (error.response.status === 429 || error.response.status >= 500)) {
+ retries++;
+
+ if (retries >= maxRetries) {
+ console.error(`Maximum retries (${maxRetries}) exceeded. Giving up.`);
+ throw error;
+ }
+
+ // Calculate delay with exponential backoff and jitter
+ const delay = initialDelay * Math.pow(2, retries - 1) * (1 + Math.random() * 0.1);
+ console.log(`Retry ${retries}/${maxRetries} after ${Math.round(delay)}ms delay`);
+
+ await new Promise(resolve => setTimeout(resolve, delay));
+ } else {
+ // Don't retry for other error types
+ throw error;
+ }
+ }
+ }
+}
+
+// Example usage with a transfer function
+async function reliableTransfer(fromWalletId, toWalletId, amount, destinationCurrency, description) {
+ return retryWithBackoff(
+ () => transferBetweenWalletsWithIdempotency(
+ fromWalletId, toWalletId, amount, destinationCurrency, description
+ )
+ );
+}
+```
+
+By implementing these error handling patterns, your integration with the Multi-Currency Wallet Transfer API will be more resilient and provide a better experience for your users.
+
+The API you've implemented is more than just code—it's a tool for global financial inclusion. As you continue to refine your implementation, remember that each improvement enhances someone's ability to participate in the global economy with less friction and more freedom.
+
+May your wallets always be funded, your transfers always successful, and your users always delighted with the seamless experience you've created!
+
+✓ **Ultimate Achievement Unlocked:** You've Implemented Multi-Currency Wallet Transfers with Chimoney API that works globally in seconds rather than days!
\ No newline at end of file
diff --git a/submissions/multicurrency-wallets-transfer-Brijeshthummar02/use-case.md b/submissions/multicurrency-wallets-transfer-Brijeshthummar02/use-case.md
new file mode 100644
index 0000000..c65b09f
--- /dev/null
+++ b/submissions/multicurrency-wallets-transfer-Brijeshthummar02/use-case.md
@@ -0,0 +1,144 @@
+# Multi-Currency Wallet Transfer: Powering Global Payments for Remote Teams
+
+In today's interconnected world, businesses are increasingly building global teams with members spread across different countries. This global expansion brings unique challenges, particularly when it comes to payroll and compensation. Imagine you're running a tech startup with team members in Nigeria, Canada, and the United States – how do you efficiently pay everyone in their local currency without excessive fees or delays?
+
+## The Challenge of Global Payroll
+
+**Before Chimoney:**
+Each payday becomes a source of anxiety for finance teams worldwide. Finance managers start processing international payments days in advance, knowing that delays are inevitable. Meanwhile, team members check their accounts daily, wondering when they'll finally receive their hard-earned money.
+
+Traditional international payment methods present several obstacles:
+
+- **High transaction fees**: International wire transfers often incur fees from both sending and receiving banks, sometimes taking 5-7% of the total payment
+- **Unfavorable exchange rates**: Banks typically offer below-market exchange rates, reducing the actual amount received by as much as 4%
+- **Processing delays**: Cross-border payments can take 3-5 business days to clear, leaving team members waiting and worrying
+- **Compliance complexity**: Each country has different banking regulations and requirements, creating a maze of paperwork
+- **Administrative burden**: Managing multiple payment platforms for different regions can consume 15-20 hours of staff time each month
+
+These challenges can significantly impact both the company and its team members. The business faces increased operational costs and administrative overhead, while employees may receive less than expected due to fees and poor exchange rates – often at the times when they need those funds the most.
+
+## Enter Chimoney's Multi-Currency Wallet Transfer
+
+Chimoney's Multi-Currency Wallet Transfer API endpoint provides an elegant solution to these challenges. It enables businesses to:
+
+1. Maintain balances in multiple currencies (USD, CAD, NGN) with a single account
+2. Transfer funds directly between wallets with automatic currency conversion at competitive rates
+3. Send money to recipients via email or phone number, even if they don't have a Chimoney account yet
+4. Complete transactions in near real-time rather than waiting days
+5. Manage all global payments through a unified API interface
+
+Think of Chimoney's multi-currency wallets like a universal power adapter for your money. Just as you don't need a different charger for every country you visit, you don't need different payment systems for each currency. Plug your payment into one end, and it comes out correctly formatted on the other—no matter where your recipient is located.
+
+## Real-World Use Case: Remote Team Payroll
+
+Let's examine how a growing tech company with a distributed team can leverage this API:
+
+### Company Profile: TechNova
+
+TechNova is a software development company with:
+
+- Headquarters in San Francisco
+- Development team in Lagos, Nigeria
+- Design team in Toronto, Canada
+- Contractors in various other locations
+
+### The Payroll Process with Chimoney
+
+1. **Initial Setup**
+ - TechNova creates a multi-currency wallet with balances in USD, CAD, and NGN
+ - Team members either create their own Chimoney wallets or simply provide their email/phone
+ - The company can manage all wallets through the multicurrency-wallets/list endpoint
+
+2. **Funding the Master Wallet**
+ - TechNova loads their master wallet with funds in USD (their primary operating currency)
+ - The wallet balances can be verified using the multicurrency-wallets/get endpoint
+
+3. **Processing Payroll**
+ - When it's time to run payroll, TechNova uses the Multi-Currency Wallet Transfer API to:
+ - Get a transfer quote first to see exact exchange rates and fees using the transfer-quote endpoint
+ - Send NGN directly to the Nigerian developers' wallets
+ - Transfer CAD to the Canadian designers' wallets
+ - Distribute USD to US-based team members and contractors
+ - All transfers can be managed from a single dashboard or API interface
+
+4. **Recipient Experience**
+ - Team members with existing Chimoney wallets receive funds instantly
+ - New recipients get an email/SMS notification to claim their payment
+ - Everyone receives funds in their local currency without additional conversion fees
+ - Recipients can update their wallet preferences using the multicurrency-wallets/update endpoint
+
+**After Chimoney:**
+Now the finance manager completes the entire payroll process on Thursday morning with just a few clicks. By afternoon, everyone has their funds in their preferred currency. Team chat messages now focus on projects rather than payment problems. The relief is palpable across the organization, and productivity spikes in the days following smooth payment processing.
+
+### The Technical Flow
+
+```
+[TechNova Payroll System]
+ ↓
+[Multi-Currency Master Wallet (USD/CAD/NGN)]
+ ↓
+[Transfer Quote API - Preview rates and fees]
+ ↓
+[Chimoney Multi-Currency Wallet Transfer API]
+ ↓
+[Team Member Wallets/Email/Phone]
+ ↓
+[Instant Access to Funds in Local Currency]
+```
+
+## Benefits Realized
+
+By implementing Chimoney's Multi-Currency Wallet Transfer API, TechNova experiences:
+
+- **Cost savings**: Reduced fees by 80% compared to traditional international wire transfers, saving approximately $3,200 monthly
+- **Time efficiency**: Instant transfers instead of multi-day processing times, reducing payroll processing from 3 days to just 2 hours
+- **Simplified operations**: One API to handle all global payments instead of juggling 5+ different systems
+- **Better exchange rates**: Competitive rates that maximize the amount received, improving take-home pay by 4-7%
+- **Enhanced employee satisfaction**: Team members receive full payment amounts quickly in their preferred currency, increasing satisfaction scores from 64% to 92%
+- **Scalability**: Easy addition of new team members regardless of location without additional administrative overhead
+- **Improved financial management**: Centralized view of all international transfers for better reporting and forecasting
+- **Reduced administrative overhead**: Automation of recurring payments saves 15+ hours of staff time each month
+
+When your Nigerian developer receives payment instantly instead of waiting 5 days, that might mean they can pay their rent on time, avoid late fees, or simply enjoy the weekend without financial stress. The speed of this API isn't just a technical specification—it's peace of mind for real people.
+
+## Testimonial: Sarah Chen, Finance Director at TechNova
+
+> "Before implementing Chimoney's Multi-Currency Wallet Transfer API, our international payroll was a nightmare. Every month, I spent nearly three full days coordinating with different banks, tracking wire transfers, and answering questions from our team members about delayed payments or unexpected fee deductions.
+>
+> Our Nigerian developers would typically wait 3-5 business days for their payments to clear, often losing 4-7% in combined bank fees and poor exchange rates. Our Canadian design team faced similar issues, just on a different scale. We tried several other payment platforms before, but each one only solved part of the problem or worked in certain regions.
+>
+> Since implementing Chimoney six months ago, we've reduced our payroll processing time from three days to just two hours per month. Our team members now receive their full compensation within minutes instead of days, and we're saving approximately $3,200 monthly in fees alone.
+>
+> What surprised me the most was the positive impact on team morale. During our last quarterly survey, 92% of our international team members specifically mentioned timely and reliable payments as a factor in their job satisfaction, up from just 64% before Chimoney.
+>
+> The most significant change for me personally? I no longer receive those frustrating 'Where's my payment?' emails that used to flood my inbox every month. Now I can focus on strategic financial planning rather than troubleshooting payment issues. For a growing company with team members across 12 countries, having this level of reliability and efficiency in our payment system has been transformative."
+
+## Beyond Payroll: Additional Applications
+
+The Multi-Currency Wallet Transfer functionality extends beyond payroll to other use cases:
+
+- **Marketplace payouts**: Online platforms can pay sellers across multiple countries
+- **Affiliate commissions**: Companies can distribute commission payments to global partners
+- **Expense reimbursements**: Businesses can quickly reimburse employee expenses in local currencies
+- **Subscription refunds**: Services can process refunds to international customers in their native currency
+- **Cross-border supplier payments**: Pay international vendors efficiently
+- **Freelancer payments**: Pay remote contractors in their preferred currency
+- **Interledger integration**: Connect with the broader Interledger Protocol ecosystem for global payments
+
+## Technical Integration Points
+
+The Multi-Currency Wallet Transfer API works seamlessly with other Chimoney endpoints:
+
+1. **Wallet Creation**: Use the `/multicurrency-wallets/create` endpoint to set up wallets for each currency
+2. **Wallet Management**: Monitor and update wallets using the `/multicurrency-wallets/update` endpoint
+3. **Transfer Quotes**: Get real-time exchange rates with the `/multicurrency-wallets/transfer/quote` endpoint
+4. **Wallet Listing**: View all wallets with the `/multicurrency-wallets/list` endpoint
+5. **Wallet Details**: Check balances with the `/multicurrency-wallets/get` endpoint
+
+## Conclusion
+
+Chimoney's Multi-Currency Wallet Transfer API represents a significant advancement for businesses operating globally. By simplifying cross-border payments and eliminating traditional banking friction, it enables companies to focus on growth and talent acquisition without geographical limitations.
+
+For businesses with international teams or customers, this API endpoint transforms a traditionally complex, expensive, and time-consuming process into a seamless, cost-effective, and instant experience – truly embodying the promise of borderless finance in the digital age.
+
+✓ **Achievement unlocked:** You now understand how Chimoney's Multi-Currency Wallet Transfer API can transform your global payment operations from a source of frustration to a competitive advantage!