private static final Gson gson = new GsonBuilder()

.setPrettyPrinting()

.create();

static void prettyPrintData(Object data) {

try {

String json = gson.toJson(data);

System.out.println(json);

} catch (Exception e) {

e.printStackTrace();

}

}

public static boolean verbose = false;

public static boolean sandbox = false;

public static boolean demo = false;

public static boolean noKeys = false;

public static ArrayList<String> exchangeIds = new ArrayList<String>();

public static String exchangesPath = FileSystems.getDefault().getPath("").toAbsolutePath() + "../../../../.." + "/exchanges.json";

public static void InitOptions(BaseExchange instance, String[] args) {

if (args.length > 0) {

for (String arg : args) {

if (arg.equals("--verbose")) {

verbose = true;

// instance.verbose = true;

} else if (arg.equals("--sandbox")) {

sandbox = true;

instance.setSandboxMode(true);

} else if (arg.equals("--demo")) {

demo = true;

// instance.setDemoMode(true);

instance.enableDemoTrading(true);

} else if (arg.equals("--no-keys")) {

noKeys = true;

}

}

}

}

public static Object[] getParamsFromArgs(String[] args) {

ArrayList<Object> params = new ArrayList<Object>();

if (args.length > 2) {

for (int i = 2; i < args.length; i++) {

var arg = args[i];

if (arg.startsWith("{") || arg.startsWith("[")) {

try {

ObjectMapper mapper = new ObjectMapper();

Object json = mapper.readValue(arg, Object.class);

params.add(json);

} catch (Exception e) {

params.add(arg);

}

} else if (arg.equals("true") || arg.equals("false")) {

params.add(Boolean.parseBoolean(arg));

} else if (arg.equals("null")) {

params.add(null);

} else if (arg.matches("-?\\d+")) {

params.add(Integer.parseInt(arg));

} else if (arg.matches("-?\\d+\\.\\d+")) {

params.add(Double.parseDouble(arg));

}

else {

params.add(arg);

}

}

}

return params.toArray();

}

public static void setCredentials(BaseExchange instance) throws IllegalArgumentException, IllegalAccessException, IOException {

var basePath = FileSystems.getDefault().getPath("").toAbsolutePath().toString();

var prefix = (basePath.endsWith("cli")) ? "/../../" : "/../";

var keysJsonPath = basePath + prefix + "keys.json";

Map<String, Object> keysJsonContent = null;

if (FileSystems.getDefault().getPath(keysJsonPath).toFile().exists()) {

System.out.println("Loading credentials from: " + keysJsonPath);

String content = new String(Files.readAllBytes(Paths.get(keysJsonPath)));

try {

ObjectMapper mapper = new ObjectMapper();

keysJsonContent = mapper.readValue(content, Map.class);

} catch (Exception e) {

System.out.println("Error parsing keys.json: " + e.getMessage());

}

}

Map<String, Boolean> credentials = (Map<String, Boolean>)instance.requiredCredentials;

if (noKeys || credentials == null) {

return;

}

for (Map.Entry<String, Boolean> entry : credentials.entrySet()) {

String key = entry.getKey();

// attempt every declared credential, not only required ones: some exchanges (e.g.

// polymarket) mark all credentials optional and validate at call time, but still need

// them set from keys.json / env to function

String instanceIdKey = instance.id;

String credentialValue = null;

if (keysJsonContent != null && keysJsonContent.containsKey(instanceIdKey)) {

Map<String, Object> instanceCredentials = (Map<String, Object>)keysJsonContent.get(instanceIdKey);

if (instanceCredentials.containsKey(key)) {

credentialValue = instanceCredentials.get(key).toString();

System.out.println("Setting credential from keys.json: " + instanceIdKey + "." + key);

setProperty(instance, key, credentialValue);

continue;

}

}

String envKey = instanceIdKey.toUpperCase() + "_" + key.toUpperCase();

credentialValue = System.getenv(envKey);

if (credentialValue != null && credentialValue.startsWith("-----BEGIN")) {

credentialValue = credentialValue.replace("\\n", "\n");

}

if (credentialValue != null) {

System.out.println("Setting credential from ENV: " + envKey);

setProperty(instance, key, credentialValue);

}

}

}

private static void setProperty(BaseExchange instance, String key, String value)

throws IllegalArgumentException, IllegalAccessException {

Class<?> clazz = instance.getClass();

Field field = null;

// look for the field in this class and its superclasses

while (clazz != null) {

try {

field = clazz.getDeclaredField(key);

break; // found it

} catch (NoSuchFieldException e) {

clazz = clazz.getSuperclass(); // go up the hierarchy

}

}

if (field != null) {

field.setAccessible(true);

field.set(instance, value);

} else {

System.out.println("No field or setter found for credential: " + key);

}

}

public static Object callDynamic(Object instance, String methodName, Object... args) {

Class<?> clazz = instance.getClass();

try {

Class<?>[] paramTypes = Arrays.stream(args)

.map(a -> a == null ? null : a.getClass())

.toArray(Class<?>[]::new);

try {

Method m = clazz.getMethod(methodName, paramTypes);

return m.invoke(instance, args);

} catch (NoSuchMethodException ignore) {

// Try matching a varargs method

}

// Try varargs method: (Object, Object[])

for (Method m : clazz.getMethods()) {

if (!m.getName().equals(methodName)) continue;

if (m.isVarArgs()) {

Class<?>[] types = m.getParameterTypes();

int fixedCount = types.length - 1;

if (args.length < fixedCount) continue;

Object[] invokeArgs = new Object[types.length];

for (int i = 0; i < fixedCount; i++) {

invokeArgs[i] = args[i];

}

// Build the varargs array

Class<?> varType = types[fixedCount].getComponentType();

int varCount = args.length - fixedCount;

Object varArray = Array.newInstance(varType, varCount);

for (int i = 0; i < varCount; i++) {

Array.set(varArray, i, args[fixedCount + i]);

}

invokeArgs[fixedCount] = varArray;

return m.invoke(instance, invokeArgs);

}

}

throw new NoSuchMethodException("Method " + methodName + " not found");

} catch (Exception e) {

throw new RuntimeException("Error calling method: " + methodName, e);

}

}

public static void main(String[] args) throws IOException, InterruptedException {

System.out.println("[java][" + Version.VERSION +"] CCXT CLI");

// System.out.println("User Directory: " + userDirectory);

// -p / --prediction forces the prediction namespace for ids that exist in both

// (e.g. hyperliquid); prediction-only ids resolve there automatically as a fallback.

// strip the flag so it is not mistaken for a positional method argument

var forcePrediction = false;

ArrayList<String> positionalArgs = new ArrayList<String>();

for (String arg : args) {

if (arg.equals("-p") || arg.equals("--prediction")) {

forcePrediction = true;

} else {

positionalArgs.add(arg);

}

}

args = positionalArgs.toArray(new String[0]);

if (args.length < 2) {

System.out.println("Usage: java -cp <classpath> cli.Main [--verbose] [--sandbox] [-p|--prediction] <exchange-id> [arg1 arg2 ...]");

return;

}

var exchangeName = args[0];

var methodName = args[1];

var isWsMethod = methodName.startsWith("watch");

var params = getParamsFromArgs(args);

var isProExchange = MetaData.ProExchanges.contains(exchangeName);

var instance = Exchange.dynamicallyCreateInstance(exchangeName, null, isProExchange, forcePrediction);

var callExpressionString = instance.id + "." + methodName + "(" + java.util.Arrays.toString(params) + ")";

System.out.println(callExpressionString);

try {

InitOptions(instance, args);

setCredentials(instance);

if (Main.verbose) {

instance.verbose = true;

}

instance.loadMarkets().get();

while (true) {

var f = callDynamic(instance, methodName, params);

Object response;

if (f instanceof CompletableFuture) {

response = ((CompletableFuture<?>) f).get();

} else {

response = f;

}

PrettyPrinter.prettyPrintData(response);

if (!isWsMethod) {

break;

}

}

} catch (Exception e) {

System.out.println(e);

}

}

}