POST https://pay.yilise.com/api/v1/payout/create
Content-Type: application/json

{
  "merchantId": "M100001",
  "merchantOrderNo": "PO20260719001",
  "amount": 500.00,
  "currency": "INR",
  "ipAddress": "192.168.1.100",
  "notifyUrl": "https://merchant.com/notify",
  "bankCode": "HDFC0001234",
  "accountNo": "1234567890",
  "accountName": "John Doe",
  "email": "john@example.com",
  "phone": "+91-9876543210",
  "bankName": "HDFC Bank",
  "subBranch": "Mumbai Main",
  "province": "Maharashtra",
  "city": "Mumbai",
  "bankType": "IMPS",
  "remark": "Salary payment",
  "sign": "xxxxxxxxxxxxxxxxxxxx"
}

{
  "code": "0000",
  "msg": "下单成功",
  "data": {
    "payoutOrderNo": "PW20260719123456",
    "status": "PAYOUT_ING"
  }
}

POST https://pay.yilise.com/api/v1/payout/query
Content-Type: application/json

{
  "merchantId": "M100001",
  "payoutOrderNo": "PW20260719123456",
  "sign": "xxxxxxxxxxxxxxxxxxxx"
}

{
  "code": "0000",
  "msg": "查询成功",
  "data": {
    "respCode": "0000",
    "respDesc": "查询成功",
    "payoutOrderNo": "PW20260719123456",
    "merchantOrderNo": "PO20260719001",
    "status": "PAYOUT_SUCCESS",
    "payoutSuccessTime": "2026-07-19 14:30:00"
  }
}

POST https://pay.yilise.com/api/v1/payout/balance
Content-Type: application/json

{
  "merchantId": "M100001",
  "sign": "xxxxxxxxxxxxxxxxxxxx"
}

{
  "code": "0000",
  "msg": "查询成功",
  "data": {
    "respCode": "0000",
    "respDesc": "查询成功",
    "availableBalance": 125680.50
  }
}

{
  "respCode": "0000",
  "respDesc": "付款成功",
  "merchantOrderNo": "PO20260719001",
  "payoutOrderNo": "PW20260719123456",
  "status": "PAYOUT_SUCCESS",
  "payoutSuccessTime": "2026-07-19 14:30:00",
  "sign": "xxxxxxxxxxxxxxxxxxxx"
}

package com.xpay.common.util;

import lombok.extern.slf4j.Slf4j;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

@Slf4j
public class RSAUtil {
    private static final String RSA_KEY_ALGORITHM = "RSA";
    private static final String RSA_SIGNATURE_ALGORITHM = "SHA1withRSA";
    private static final String RSA2_SIGNATURE_ALGORITHM = "SHA256withRSA";
    private static final int KEY_SIZE = 1024;

    public static Map<String, String> generateKey() {
        KeyPairGenerator keygen;
        try {
            keygen = KeyPairGenerator.getInstance(RSA_KEY_ALGORITHM);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("RSA初始化密钥出现错误,算法异常");
        }
        SecureRandom secrand = new SecureRandom();
        secrand.setSeed(String.valueOf(System.currentTimeMillis()).getBytes());
        keygen.initialize(KEY_SIZE, secrand);
        KeyPair keyPair = keygen.genKeyPair();
        byte[] pub_key = keyPair.getPublic().getEncoded();
        String publicKeyStr = Base64.getEncoder().encodeToString(pub_key);
        byte[] pri_key = keyPair.getPrivate().getEncoded();
        String privateKeyStr = Base64.getEncoder().encodeToString(pri_key);
        Map<String, String> keyPairMap = new HashMap<>();
        keyPairMap.put("publicKeyStr", publicKeyStr);
        keyPairMap.put("privateKeyStr", privateKeyStr);
        return keyPairMap;
    }

    public static String encryptByPublicKey(String data, String publicKeyStr) {
        try {
            byte[] decodePublicKeyByte = Base64.getDecoder().decode(publicKeyStr);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodePublicKeyByte);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PublicKey publicKey = keyFactory.generatePublic(keySpec);
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            byte[] bytesContent = data.getBytes();
            int inputLen = bytesContent.length;
            int offLen = 0;
            int i = 0;
            ByteArrayOutputStream bops = new ByteArrayOutputStream();
            while (inputLen - offLen > 0) {
                byte[] cache;
                if (inputLen - offLen > 117) {
                    cache = cipher.doFinal(bytesContent, offLen, 117);
                } else {
                    cache = cipher.doFinal(bytesContent, offLen, inputLen - offLen);
                }
                bops.write(cache);
                i++;
                offLen = 117 * i;
            }
            bops.close();
            byte[] encryptedData = bops.toByteArray();
            String encode = Base64.getEncoder().encodeToString(encryptedData);
            return encode;
        } catch (Exception e) {
            log.error("加密失败：", e);
            return "";
        }
    }

    public static String decryptByPrivateKey(String data, String privateKeyStr) throws Exception {
        try {
            byte[] priKey = Base64.getDecoder().decode(privateKeyStr);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKey);
            KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[] bytesContent = Base64.getDecoder().decode(data.getBytes());
            int inputLen = bytesContent.length;
            int offLen = 0;
            int i = 0;
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            while (inputLen - offLen > 0) {
                byte[] cache;
                if (inputLen - offLen > 128) {
                    cache = cipher.doFinal(bytesContent, offLen, 128);
                } else {
                    cache = cipher.doFinal(bytesContent, offLen, inputLen - offLen);
                }
                byteArrayOutputStream.write(cache);
                i++;
                offLen = 128 * i;
            }
            byteArrayOutputStream.close();
            byte[] byteArray = byteArrayOutputStream.toByteArray();
            return new String(byteArray);
        } catch (Exception e) {
            log.error("解密失败,待加密内容：{}", data, e);
            return "";
        }
    }

    public static String sign(byte[] data, byte[] priKey, String signType) throws Exception {
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKey);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        String algorithm = RSA_KEY_ALGORITHM.equals(signType) ? RSA_SIGNATURE_ALGORITHM : RSA2_SIGNATURE_ALGORITHM;
        Signature signature = Signature.getInstance(algorithm);
        signature.initSign(privateKey);
        signature.update(data);
        byte[] sign = signature.sign();
        return Base64.getEncoder().encodeToString(sign);
    }

    public static boolean verify(byte[] data, byte[] sign, byte[] pubKey, String signType) throws Exception {
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKey);
        PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
        String algorithm = RSA_KEY_ALGORITHM.equals(signType) ? RSA_SIGNATURE_ALGORITHM : RSA2_SIGNATURE_ALGORITHM;
        Signature signature = Signature.getInstance(algorithm);
        signature.initVerify(publicKey);
        signature.update(data);
        return signature.verify(sign);
    }
}