async function checkWalletBalance(token, walletId) {
  const response = await fetch(`https://merchant.paywize.in/api/payout/v1/balance?wallet_id=${walletId}`, {
    method: 'GET',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    }
  });

  const result = await response.json();

  if (result.resp_code === 2000) {
    return result.data;
  } else {
    throw new Error(`API Error ${result.resp_code}: ${result.resp_message}`);
  }
}

// Usage
try {
  const walletBalance = await checkWalletBalance(jwtToken, 'PAYWIZE12345679');
  console.log('Wallet Balance:', walletBalance);
  console.log('Available Balance: ₹', walletBalance.available_balance);

  // Check if sufficient balance for a transaction
  const transactionAmount = 1000.00;
  if (parseFloat(walletBalance.available_balance) >= transactionAmount) {
    console.log('✅ Sufficient balance for transaction');
  } else {
    console.log('❌ Insufficient balance for transaction');
  }
} catch (error) {
  console.error('Balance check failed:', error.message);
}

import requests
import json
from encryption_utils import decrypt_merchant_data

def check_wallet_balance(token, wallet_id):
    response = requests.get(
        f'https://merchant.paywize.in/api/payout/v1/balance?wallet_id={wallet_id}',
        headers={
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {token}'
        }
    )

    result = response.json()

    if result['resp_code'] == 2000:
        return result['data']
    else:
        raise Exception(f"API Error {result['resp_code']}: {result['resp_message']}")

# Usage
try:
    wallet_balance = check_wallet_balance(jwt_token, 'PAYWIZE12345679')
    print('Wallet Balance:', wallet_balance)
    print(f"Available Balance: ₹{wallet_balance['available_balance']}")
    print(f"Updated At: {wallet_balance['updated_at']}")

    # Check if sufficient balance for a transaction
    transaction_amount = 1000.00
    if float(wallet_balance['available_balance']) >= transaction_amount:
        print('✅ Sufficient balance for transaction')
    else:
        print('❌ Insufficient balance for transaction')
except Exception as error:
    print('Balance check failed:', str(error))

<?php

require_once 'PaywizeEncryption.php';

function checkWalletBalance($token, $walletId) {
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, "https://merchant.paywize.in/api/payout/v1/balance?wallet_id=$walletId");
    curl_setopt($ch, CURLOPT_HTTPGET, 1);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Content-Type: application/json',
        'Authorization: Bearer ' . $token
    ]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $response = curl_exec($ch);
    curl_close($ch);

    $result = json_decode($response, true);

    if ($result['resp_code'] == 2000) {
        return $result['data'];
    } else {
        throw new Exception("API Error {$result['resp_code']}: {$result['resp_message']}");
    }
}

// Usage
try {
    $walletBalance = checkWalletBalance($jwtToken, 'PAYWIZE12345679');
    echo "Wallet Balance: " . json_encode($walletBalance) . "\n";
    echo "Available Balance: ₹{$walletBalance['available_balance']}\n";
    echo "Updated At: {$walletBalance['updated_at']}\n";

    // Check if sufficient balance for a transaction
    $transactionAmount = 1000.00;
    if ((float)$walletBalance['available_balance'] >= $transactionAmount) {
        echo "✅ Sufficient balance for transaction\n";
    } else {
        echo "❌ Insufficient balance for transaction\n";
    }
} catch (Exception $error) {
    echo "Balance check failed: " . $error->getMessage() . "\n";
}

?>

curl -X GET "https://merchant.paywize.in/api/payout/v1/balance?wallet_id=PAYWIZE12345679" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"

async function validateSufficientBalance(token, transactionAmount, apiKey, secretKey) {
  try {
    const walletBalance = await checkWalletBalance(token, apiKey, secretKey);
    const availableBalance = parseFloat(walletBalance.available_balance);

    if (availableBalance >= transactionAmount) {
      return {
        sufficient: true,
        available: availableBalance,
        required: transactionAmount,
        excess: availableBalance - transactionAmount
      };
    } else {
      return {
        sufficient: false,
        available: availableBalance,
        required: transactionAmount,
        shortfall: transactionAmount - availableBalance
      };
    }
  } catch (error) {
    throw new Error(`Balance validation failed: ${error.message}`);
  }
}

// Usage
const validationResult = await validateSufficientBalance(jwtToken, 1000.00, apiKey, secretKey);

if (validationResult.sufficient) {
  console.log(`✅ Sufficient balance. Excess: ₹${validationResult.excess}`);
  // Proceed with transaction
} else {
  console.log(`❌ Insufficient balance. Shortfall: ₹${validationResult.shortfall}`);
  // Request balance top-up or reduce transaction amount
}

class WalletMonitor {
  constructor(token, apiKey, secretKey, minBalance = 1000) {
    this.token = token;
    this.apiKey = apiKey;
    this.secretKey = secretKey;
    this.minBalance = minBalance;
  }

  async monitorBalance() {
    try {
      const balance = await checkWalletBalance(this.token, this.apiKey, this.secretKey);
      const availableBalance = parseFloat(balance.available_balance);

      if (availableBalance < this.minBalance) {
        this.sendLowBalanceAlert(availableBalance);
      }

      return balance;
    } catch (error) {
      console.error('Balance monitoring failed:', error.message);
    }
  }

  sendLowBalanceAlert(currentBalance) {
    console.log(`🚨 LOW BALANCE ALERT: Current balance ₹${currentBalance} is below minimum threshold ₹${this.minBalance}`);
    // Send email, SMS, or push notification
  }
}

// Usage
const monitor = new WalletMonitor(jwtToken, apiKey, secretKey, 5000);
const balance = await monitor.monitorBalance();