@raintree-technology/perps 0.1.0

package/dist/commands/account/add.js

@@ -0,0 +1,510 @@
+import { getContext, getOutputOptions } from "../../cli/program.js";
+import { output, outputError, outputSuccess } from "../../cli/output.js";
+import { validateAddressForExchange, validatePrivateKey } from "../../lib/validation.js";
+import { prompt, select, confirm } from "../../lib/prompts.js";
+import { createAccount, getAccountCount, isAliasTaken } from "../../lib/db/index.js";
+import { generateApiWallet, validateApiKey } from "../../lib/api-wallet.js";
+import { getExchangeId } from "../../lib/exchange.js";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+import { Ed25519Account, Ed25519PrivateKey } from "@aptos-labs/ts-sdk";
+import { ec } from "starknet";
+function maskSecret(secret) {
+    if (secret.length <= 12) {
+        return "[HIDDEN]";
+    }
+    return `${secret.slice(0, 6)}...${secret.slice(-4)}`;
+}
+async function maybeRevealGeneratedSecret(label, secret) {
+    console.log(`  ${label}: ${maskSecret(secret)} (hidden by default)`);
+    const shouldReveal = await confirm("Reveal full generated secret in terminal output?", false);
+    if (shouldReveal) {
+        console.log(`  ${label}: ${secret}`);
+        console.log("  Warning: terminal logs/history may expose full secret values.");
+    }
+}
+export function registerAddCommand(account) {
+    account
+        .command("add")
+        .description("Add a new account (interactive wizard)")
+        .action(async function () {
+        const ctx = getContext(this);
+        const outputOpts = getOutputOptions(this);
+        const isTestnet = ctx.config.testnet;
+        const exchangeId = getExchangeId();
+        try {
+            console.log("\n=== Add New Account ===\n");
+            // Step 1: Choose setup method
+            const setupMethod = await select("How would you like to add your account?", getSetupOptions(exchangeId, isTestnet));
+            if (setupMethod === "new") {
+                await handleGeneratedWallet(isTestnet, outputOpts, exchangeId);
+                return;
+            }
+            if (setupMethod === "existing") {
+                if (exchangeId === "hyperliquid") {
+                    await handleHyperliquidApiWallet(isTestnet, outputOpts, exchangeId);
+                }
+                else {
+                    await handleGenericSigningKey(outputOpts, exchangeId);
+                }
+            }
+            else {
+                await handleReadOnly(outputOpts, exchangeId);
+            }
+        }
+        catch (err) {
+            outputError(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+}
+function getSetupOptions(exchangeId, isTestnet) {
+    if (exchangeId === "hyperliquid") {
+        return [
+            {
+                value: "existing",
+                label: "Use existing API wallet",
+                description: `Import from ${isTestnet ? "https://app.hyperliquid-testnet.xyz/API" : "https://app.hyperliquid.xyz/API"}`,
+            },
+            {
+                value: "new",
+                label: "Create new wallet",
+                description: "Generate a new API wallet locally (stored encrypted in profile DB)",
+            },
+            {
+                value: "readonly",
+                label: "Add read-only account",
+                description: "Watch a wallet without trading capabilities",
+            },
+        ];
+    }
+    if (exchangeId === "orderly") {
+        return [
+            {
+                value: "existing",
+                label: "Import trading secret",
+                description: "Store account ID + trading secret for this profile",
+            },
+            {
+                value: "new",
+                label: "Generate trading secret",
+                description: "Generate a local trading secret and account profile",
+            },
+            {
+                value: "readonly",
+                label: "Add account identifier",
+                description: "Store an account identifier for tracking/default selection",
+            },
+        ];
+    }
+    return [
+        {
+            value: "existing",
+            label: "Import signing key",
+            description: "Store local trading key for this exchange profile",
+        },
+        {
+            value: "new",
+            label: "Generate signing key",
+            description: "Generate a local signing key and account profile",
+        },
+        {
+            value: "readonly",
+            label: "Add read-only account",
+            description: "Watch an account without storing a signing key",
+        },
+    ];
+}
+async function promptSetAsDefault(exchangeId) {
+    const existingCount = getAccountCount(exchangeId);
+    if (existingCount === 0) {
+        return false;
+    }
+    return confirm("\nSet this as your default account?", true);
+}
+function printAccountCreated(args) {
+    const { outputOpts, account, maskedPrivateKey = true, generatedPrivateKey, generatedPublicKey, userAddressLabel = "Address", } = args;
+    if (outputOpts.json) {
+        output({
+            ...account,
+            apiWalletPrivateKey: maskedPrivateKey ? "[REDACTED]" : account.apiWalletPrivateKey,
+            generated: generatedPublicKey
+                ? {
+                    publicKey: generatedPublicKey,
+                    privateKey: generatedPrivateKey ? "[REDACTED]" : undefined,
+                }
+                : undefined,
+        }, outputOpts);
+        return;
+    }
+    console.log("");
+    outputSuccess(`Account "${account.alias}" added successfully!`);
+    console.log("");
+    console.log("Account details:");
+    console.log(`  Alias: ${account.alias}`);
+    console.log(`  ${userAddressLabel}: ${account.userAddress}`);
+    console.log(`  Type: ${account.type}`);
+    if (account.apiWalletPublicKey) {
+        console.log(`  Signing Key Address: ${account.apiWalletPublicKey}`);
+    }
+    if (generatedPrivateKey) {
+        console.log(`  Generated Secret: ${maskSecret(generatedPrivateKey)} (full value hidden)`);
+        console.log("  Security:         stored encrypted in the local DB profile");
+    }
+    console.log(`  Default: ${account.isDefault ? "Yes" : "No"}`);
+    console.log("");
+}
+async function handleGeneratedWallet(isTestnet, outputOpts, exchangeId) {
+    if (exchangeId === "hyperliquid") {
+        const generated = generateApiWallet();
+        const apiUrl = isTestnet
+            ? "https://app.hyperliquid-testnet.xyz/API"
+            : "https://app.hyperliquid.xyz/API";
+        console.log("");
+        console.log("Generated Hyperliquid API wallet:");
+        console.log(`  API Wallet Address: ${generated.publicKey}`);
+        await maybeRevealGeneratedSecret("API Private Key", generated.privateKey);
+        console.log("");
+        console.log(`Register/approve this API wallet at: ${apiUrl}`);
+        console.log("");
+        const addressInput = await prompt("Enter your Hyperliquid master wallet address: ");
+        let userAddress = validateAddressForExchange(addressInput, exchangeId);
+        const shouldValidate = await confirm("Validate API wallet approval now?", true);
+        if (shouldValidate) {
+            console.log("\nValidating API wallet...");
+            const result = await validateApiKey(generated.privateKey, isTestnet);
+            if (!result.valid) {
+                throw new Error(`${result.error}. Approve wallet at ${apiUrl} and try again.`);
+            }
+            userAddress = result.masterAddress;
+            console.log(`Approved API wallet for ${userAddress.slice(0, 6)}...${userAddress.slice(-4)}`);
+        }
+        const alias = await promptForAlias(exchangeId);
+        const setAsDefault = await promptSetAsDefault(exchangeId);
+        const account = createAccount({
+            alias,
+            exchange: exchangeId,
+            userAddress,
+            type: "api_wallet",
+            source: "cli_import",
+            apiWalletPrivateKey: generated.privateKey,
+            apiWalletPublicKey: generated.publicKey,
+            setAsDefault,
+        });
+        printAccountCreated({
+            outputOpts,
+            account,
+            generatedPrivateKey: generated.privateKey,
+            generatedPublicKey: generated.publicKey,
+        });
+        return;
+    }
+    if (exchangeId === "decibel") {
+        const aptosPrivateKeyObj = Ed25519PrivateKey.generate();
+        const aptosPrivateKey = aptosPrivateKeyObj.toString();
+        const aptosAddress = new Ed25519Account({ privateKey: aptosPrivateKeyObj })
+            .accountAddress
+            .toString();
+        console.log("");
+        console.log("Generated Decibel signing wallet:");
+        console.log(`  Aptos Address: ${aptosAddress}`);
+        await maybeRevealGeneratedSecret("Private Key", aptosPrivateKey);
+        const alias = await promptForAlias(exchangeId);
+        const setAsDefault = await promptSetAsDefault(exchangeId);
+        const account = createAccount({
+            alias,
+            exchange: exchangeId,
+            userAddress: aptosAddress,
+            type: "api_wallet",
+            source: "cli_import",
+            apiWalletPrivateKey: aptosPrivateKey,
+            apiWalletPublicKey: aptosAddress,
+            setAsDefault,
+        });
+        printAccountCreated({
+            outputOpts,
+            account,
+            generatedPrivateKey: aptosPrivateKey,
+            generatedPublicKey: aptosAddress,
+        });
+        return;
+    }
+    if (exchangeId === "aevo") {
+        const privateKey = generatePrivateKey();
+        const address = privateKeyToAccount(privateKey).address;
+        console.log("");
+        console.log("Generated Aevo signing wallet:");
+        console.log(`  Address:     ${address}`);
+        await maybeRevealGeneratedSecret("Private Key", privateKey);
+        const alias = await promptForAlias(exchangeId);
+        const setAsDefault = await promptSetAsDefault(exchangeId);
+        const account = createAccount({
+            alias,
+            exchange: exchangeId,
+            userAddress: address,
+            type: "api_wallet",
+            source: "cli_import",
+            apiWalletPrivateKey: privateKey,
+            apiWalletPublicKey: address,
+            setAsDefault,
+        });
+        printAccountCreated({
+            outputOpts,
+            account,
+            generatedPrivateKey: privateKey,
+            generatedPublicKey: address,
+        });
+        return;
+    }
+    if (exchangeId === "orderly") {
+        const privateKey = generatePrivateKey();
+        const generatedAddress = privateKeyToAccount(privateKey).address;
+        console.log("");
+        console.log("Generated Orderly trading secret:");
+        console.log(`  Wallet Address: ${generatedAddress}`);
+        await maybeRevealGeneratedSecret("Trading Secret", privateKey);
+        console.log("  Note: complete Orderly account onboarding to issue account/key/secret values.");
+        const accountIdInput = await prompt("Enter your Orderly account ID (or press Enter to use generated wallet address): ");
+        const userAddress = accountIdInput.trim()
+            ? validateAddressForExchange(accountIdInput, exchangeId)
+            : generatedAddress;
+        const alias = await promptForAlias(exchangeId);
+        const setAsDefault = await promptSetAsDefault(exchangeId);
+        const account = createAccount({
+            alias,
+            exchange: exchangeId,
+            userAddress: userAddress,
+            type: "api_wallet",
+            source: "cli_import",
+            apiWalletPrivateKey: privateKey,
+            apiWalletPublicKey: generatedAddress,
+            setAsDefault,
+        });
+        printAccountCreated({
+            outputOpts,
+            account,
+            generatedPrivateKey: privateKey,
+            generatedPublicKey: generatedAddress,
+            userAddressLabel: "Account ID",
+        });
+        return;
+    }
+    if (exchangeId === "paradex") {
+        const starkPrivateKeyBytes = ec.starkCurve.utils.randomPrivateKey();
+        const privateKey = `0x${Buffer.from(starkPrivateKeyBytes).toString("hex")}`;
+        const publicKey = ec.starkCurve.getStarkKey(privateKey);
+        console.log("");
+        console.log("Generated Paradex signing key:");
+        console.log(`  Stark Public Key: ${publicKey}`);
+        await maybeRevealGeneratedSecret("Stark Private Key", privateKey);
+        const accountInput = await prompt("Enter your Paradex account address: ");
+        const userAddress = validateAddressForExchange(accountInput, exchangeId);
+        const alias = await promptForAlias(exchangeId);
+        const setAsDefault = await promptSetAsDefault(exchangeId);
+        const account = createAccount({
+            alias,
+            exchange: exchangeId,
+            userAddress: userAddress,
+            type: "api_wallet",
+            source: "cli_import",
+            apiWalletPrivateKey: privateKey,
+            apiWalletPublicKey: publicKey,
+            setAsDefault,
+        });
+        printAccountCreated({
+            outputOpts,
+            account,
+            generatedPrivateKey: privateKey,
+            generatedPublicKey: publicKey,
+            userAddressLabel: "Account",
+        });
+        return;
+    }
+    throw new Error(`Wallet generation is not supported for "${exchangeId}"`);
+}
+async function handleHyperliquidApiWallet(isTestnet, outputOpts, exchangeId) {
+    // Step 1: Get API private key
+    const apiUrl = isTestnet
+        ? "https://app.hyperliquid-testnet.xyz/API"
+        : "https://app.hyperliquid.xyz/API";
+    console.log(`\nVisit ${apiUrl} and click "Generate" to create one.\n`);
+    const apiKeyInput = await prompt("Enter your API wallet private key: ");
+    // Normalize the key (add 0x prefix if missing)
+    let apiPrivateKey;
+    if (apiKeyInput.startsWith("0x")) {
+        apiPrivateKey = apiKeyInput;
+    }
+    else {
+        apiPrivateKey = `0x${apiKeyInput}`;
+    }
+    // Validate key format
+    validatePrivateKey(apiPrivateKey);
+    // Step 2: Validate the API key
+    console.log("\nValidating API key...");
+    const result = await validateApiKey(apiPrivateKey, isTestnet);
+    if (!result.valid) {
+        throw new Error(result.error);
+    }
+    const apiWalletPublicKey = result.apiWalletAddress;
+    const userAddress = result.masterAddress;
+    console.log(`Valid API wallet for ${userAddress.slice(0, 6)}...${userAddress.slice(-4)}`);
+    // Step 3: Get alias
+    const alias = await promptForAlias(exchangeId);
+    // Step 4: Check if user wants to set as default
+    let setAsDefault = false;
+    const existingCount = getAccountCount(exchangeId);
+    if (existingCount > 0) {
+        setAsDefault = await confirm("\nSet this as your default account?", true);
+    }
+    // Step 5: Save account
+    const newAccount = createAccount({
+        alias,
+        exchange: exchangeId,
+        userAddress,
+        type: "api_wallet",
+        source: "cli_import",
+        apiWalletPrivateKey: apiPrivateKey,
+        apiWalletPublicKey,
+        setAsDefault,
+    });
+    if (outputOpts.json) {
+        output({
+            ...newAccount,
+            apiWalletPrivateKey: "[REDACTED]",
+        }, outputOpts);
+    }
+    else {
+        console.log("");
+        outputSuccess(`Account "${alias}" added successfully!`);
+        console.log("");
+        console.log("Account details:");
+        console.log(`  Alias: ${newAccount.alias}`);
+        console.log(`  Address: ${newAccount.userAddress}`);
+        console.log(`  Type: ${newAccount.type}`);
+        console.log(`  API Wallet: ${newAccount.apiWalletPublicKey}`);
+        console.log(`  Default: ${newAccount.isDefault ? "Yes" : "No"}`);
+        console.log("");
+    }
+}
+async function handleGenericSigningKey(outputOpts, exchangeId) {
+    console.log("");
+    const privateKeyInput = await prompt("Enter your signing private key: ");
+    const privateKey = normalizePrivateKey(privateKeyInput);
+    validatePrivateKey(privateKey);
+    let userAddress;
+    let apiWalletPublicKey;
+    if (exchangeId === "decibel") {
+        const account = new Ed25519Account({ privateKey: new Ed25519PrivateKey(privateKey) });
+        userAddress = account.accountAddress.toString();
+        apiWalletPublicKey = userAddress;
+    }
+    else if (exchangeId === "aevo") {
+        userAddress = privateKeyToAccount(privateKey).address;
+        apiWalletPublicKey = userAddress;
+    }
+    else if (exchangeId === "paradex") {
+        const accountInput = await prompt("Enter your Paradex account address: ");
+        userAddress = validateAddressForExchange(accountInput, exchangeId);
+    }
+    else if (exchangeId === "orderly") {
+        const accountId = await prompt("Enter your Orderly account ID: ");
+        userAddress = validateAddressForExchange(accountId, exchangeId);
+    }
+    else {
+        throw new Error(`Signing-key import is not supported for "${exchangeId}"`);
+    }
+    const alias = await promptForAlias(exchangeId);
+    let setAsDefault = false;
+    const existingCount = getAccountCount(exchangeId);
+    if (existingCount > 0) {
+        setAsDefault = await confirm("\nSet this as your default account?", true);
+    }
+    const newAccount = createAccount({
+        alias,
+        exchange: exchangeId,
+        userAddress: userAddress,
+        type: "api_wallet",
+        source: "cli_import",
+        apiWalletPrivateKey: privateKey,
+        apiWalletPublicKey: apiWalletPublicKey,
+        setAsDefault,
+    });
+    if (outputOpts.json) {
+        output({
+            ...newAccount,
+            apiWalletPrivateKey: "[REDACTED]",
+        }, outputOpts);
+        return;
+    }
+    console.log("");
+    outputSuccess(`Account "${alias}" added successfully!`);
+    console.log("");
+    console.log("Account details:");
+    console.log(`  Alias: ${newAccount.alias}`);
+    console.log(`  Address: ${newAccount.userAddress}`);
+    console.log(`  Type: ${newAccount.type}`);
+    if (newAccount.apiWalletPublicKey) {
+        console.log(`  Signing Key Address: ${newAccount.apiWalletPublicKey}`);
+    }
+    console.log(`  Default: ${newAccount.isDefault ? "Yes" : "No"}`);
+    console.log("");
+}
+async function handleReadOnly(outputOpts, exchangeId) {
+    // Step 1: Get wallet address
+    console.log("");
+    const promptLabel = exchangeId === "orderly"
+        ? "Enter the account identifier to watch: "
+        : "Enter the account address to watch: ";
+    const userAddressInput = await prompt(promptLabel);
+    const userAddress = validateAddressForExchange(userAddressInput, exchangeId);
+    // Step 2: Get alias
+    const alias = await promptForAlias(exchangeId);
+    // Step 3: Check if user wants to set as default
+    let setAsDefault = false;
+    const existingCount = getAccountCount(exchangeId);
+    if (existingCount > 0) {
+        setAsDefault = await confirm("\nSet this as your default account?", true);
+    }
+    // Step 4: Save account
+    const newAccount = createAccount({
+        alias,
+        exchange: exchangeId,
+        userAddress: userAddress,
+        type: "readonly",
+        source: "cli_import",
+        setAsDefault,
+    });
+    if (outputOpts.json) {
+        output(newAccount, outputOpts);
+    }
+    else {
+        console.log("");
+        outputSuccess(`Account "${alias}" added successfully!`);
+        console.log("");
+        console.log("Account details:");
+        console.log(`  Alias: ${newAccount.alias}`);
+        console.log(`  Address: ${newAccount.userAddress}`);
+        console.log(`  Type: ${newAccount.type}`);
+        console.log(`  Default: ${newAccount.isDefault ? "Yes" : "No"}`);
+        console.log("");
+    }
+}
+function normalizePrivateKey(raw) {
+    if (raw.startsWith("0x")) {
+        return raw;
+    }
+    return `0x${raw}`;
+}
+async function promptForAlias(exchangeId) {
+    while (true) {
+        const alias = await prompt("Enter an alias for this account (e.g., 'main', 'trading'): ");
+        if (!alias) {
+            console.log("Alias cannot be empty.");
+            continue;
+        }
+        if (isAliasTaken(alias, exchangeId)) {
+            console.log(`Alias "${alias}" is already taken on ${exchangeId}. Please choose another.`);
+            continue;
+        }
+        return alias;
+    }
+}

package/dist/commands/account/balances-simple.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simple balances command using the adapter interface
+ */
+import { Command } from "commander";
+export declare function registerBalancesSimpleCommand(account: Command): void;

package/dist/commands/account/balances-simple.js

@@ -0,0 +1,63 @@
+/**
+ * Simple balances command using the adapter interface
+ */
+import { getContext, getOutputOptions, getSelectedExchange } from "../../cli/program.js";
+import { output, outputError } from "../../cli/output.js";
+import { getExchangeAdapter } from "../../lib/exchange.js";
+import { getExchangeCredentials } from "../../lib/config.js";
+export function registerBalancesSimpleCommand(account) {
+    account
+        .command("balances")
+        .alias("bal")
+        .description("Show account balances")
+        .action(async function () {
+        const ctx = getContext(this);
+        const outputOpts = getOutputOptions(this);
+        const exchangeId = getSelectedExchange(this);
+        const adapter = getExchangeAdapter();
+        let connected = false;
+        try {
+            const credentials = getExchangeCredentials(ctx.config, exchangeId, {
+                requireReadAccess: true,
+            });
+            await adapter.connect({
+                testnet: ctx.config.testnet,
+                rpcUrl: credentials.fullnodeUrl,
+                wsUrl: credentials.wsUrl,
+                credentials,
+            });
+            connected = true;
+            const balances = await adapter.getBalances();
+            if (outputOpts.json) {
+                output(balances, outputOpts);
+            }
+            else {
+                console.log(`\n${adapter.info.name} Account Balance:\n`);
+                for (const bal of balances) {
+                    const total = parseFloat(bal.total);
+                    const available = parseFloat(bal.available);
+                    const locked = parseFloat(bal.locked);
+                    const pnl = parseFloat(bal.unrealizedPnl);
+                    const pnlColor = pnl >= 0 ? "\x1b[32m" : "\x1b[31m";
+                    const pnlStr = `${pnl >= 0 ? "+" : ""}$${pnl.toFixed(2)}`;
+                    console.log(`  ${bal.asset}`);
+                    console.log(`  ${"─".repeat(40)}`);
+                    console.log(`  Total:        $${total.toFixed(2)}`);
+                    console.log(`  Available:    $${available.toFixed(2)}`);
+                    console.log(`  In Positions: $${locked.toFixed(2)}`);
+                    console.log(`  Unrealized:   ${pnlColor}${pnlStr}\x1b[0m`);
+                    console.log("");
+                }
+            }
+        }
+        catch (err) {
+            outputError(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+        finally {
+            if (connected) {
+                await adapter.disconnect().catch(() => undefined);
+            }
+        }
+    });
+}

package/dist/commands/account/index.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerAccountCommands(program: Command): void;

package/dist/commands/account/index.js

@@ -0,0 +1,17 @@
+import { registerPositionsSimpleCommand } from "./positions-simple.js";
+import { registerBalancesSimpleCommand } from "./balances-simple.js";
+import { registerAddCommand } from "./add.js";
+import { registerLsCommand } from "./ls.js";
+import { registerSetDefaultCommand } from "./set-default.js";
+import { registerRemoveCommand } from "./remove.js";
+export function registerAccountCommands(program) {
+    const account = program.command("account").description("Account management and information");
+    // Account management commands
+    registerAddCommand(account);
+    registerLsCommand(account);
+    registerSetDefaultCommand(account);
+    registerRemoveCommand(account);
+    // Account information commands (using adapter)
+    registerPositionsSimpleCommand(account);
+    registerBalancesSimpleCommand(account);
+}

package/dist/commands/account/ls.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerLsCommand(account: Command): void;