> ## Documentation Index
> Fetch the complete documentation index at: https://waasapi.uuwallet.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Base64Util

> Utility class for conversion between binary data and Base64 strings

## Overview

`Base64Util` is a core encoding/decoding tool in encrypted communication, primarily implementing mutual conversion between binary data and Base64 text. In API communication, Base64 encoding ensures encrypted binary data can be safely transmitted via HTTP protocol.

## Code Examples

<CodeGroup>
  ```java Base64Util.java theme={null}
  import java.util.Base64;

  public class Base64Util {
    /**
        * Encodes byte array to Base64 string
        *
        * @param bytes Original binary data
        * @return Base64 encoded string
        *
        * Usage scenario: Convert encrypted binary data to safely transmittable text format,
        *                suitable for HTTP request parameter encapsulation.
        */
        public static String encodeByte(byte[] bytes) {
            return Base64.getEncoder().encodeToString(bytes);
        }
        /**
        * Decodes Base64 string to byte array
        *
        * @param str Base64 encoded string
        * @return Decoded original binary data
        *
        * Usage scenario: Convert Base64 data from API responses to binary,
        *                preparing for subsequent decryption operations.
        */
        public static byte[] decodeString(String str) {
            return Base64.getDecoder().decode(str);
        }
    }
  ```

  ```javascript Base64Util.js theme={null}
  /**
  * Base64 Encoding/Decoding Utility Class
  *
  * Provides conversion between Base64 strings and binary data
  */
  class Base64Util {
    /**
     * Encodes a byte array to a Base64 string
     * @param {Buffer} bytes - Raw binary data
     * @returns {string} Base64 encoded string
     *
     * Usage scenario: Converts encrypted binary data to a safely transmittable text format,
     *                 suitable for HTTP request parameter encapsulation.
     */
    static encodeByte(bytes) {
        return bytes.toString('base64');
    }

    /**
     * Decodes a Base64 string to a byte array
     * @param {string} str - Base64 encoded string
     * @returns {Buffer} Decoded raw binary data
     *
     * Usage scenario: Converts Base64 data from API responses to binary format,
     *                 preparing for subsequent decryption operations.
     */
    static decodeString(str) {
        return Buffer.from(str, 'base64');
    }
  }

  module.exports = Base64Util;



  ```

  ```python Base64Util.py theme={null}
  import base64

  class Base64Util:
  # Base64 encoding/decoding utility class

  @staticmethod
  def encodeByte(data: bytes) -> str:
      # Encodes byte data to Base64 string
      # Parameters: data - original binary data (bytes type)
      # Returns: Base64 encoded string
      # Usage scenario: Convert encrypted binary data to safely transmittable text format
      return base64.b64encode(data).decode('utf-8')

  @staticmethod
  def decodeString(encoded_str: str) -> bytes:
      # Decodes Base64 string to byte data
      # Parameters: encoded_str - Base64 encoded string
      # Returns: Decoded original binary data (bytes type)
      # Usage scenario: Convert Base64 data from API responses to binary
      return base64.b64decode(encoded_str.encode('utf-8'))

  # Usage example
  if __name__ == "__main__":
  # Encoding example
  binary_data = b"Hello Base64!"
  encoded = Base64Util.encodeByte(binary_data)
  print(f"Encoded result: {encoded}")

  # Decoding example
  decoded = Base64Util.decodeString(encoded)
  print(f"Decoded result: {decoded}")
  print(f"Consistency verification: {binary_data == decoded}")
  ```
</CodeGroup>