@raintree-technology/perps 0.1.0

package/dist/lib/config.js

@@ -0,0 +1,427 @@
+import { privateKeyToAccount } from "viem/accounts";
+import { getDefaultAccountForExchange } from "./db/index.js";
+import { parseEnv } from "./schema.js";
+import { recordTelemetryMetric } from "./telemetry.js";
+const DECIBEL_NETWORK_DEFAULTS = {
+    testnet: {
+        fullnodeUrl: "https://api.testnet.aptoslabs.com/v1",
+        restUrl: "https://api.testnet.aptoslabs.com/decibel",
+        wsUrl: "wss://api.testnet.aptoslabs.com/decibel/ws",
+        packageAddress: "0x95254fcb0816b9f3ec71aa4de5f5f7f8f3efeef9239f0d705a4cd3fe2f452de3",
+    },
+    mainnet: {
+        fullnodeUrl: "https://api.mainnet.aptoslabs.com/v1",
+        restUrl: "https://api.mainnet.aptoslabs.com/decibel",
+        wsUrl: "wss://api.mainnet.aptoslabs.com/decibel/ws",
+        packageAddress: "0xb8a5788314451ce4d2fbbad32e1bad88d4184b73943b7fe5166eab93cf1a5a95",
+    },
+};
+const ORDERLY_DEFAULTS = {
+    testnet: "https://testnet-api.orderly.org/v1",
+    mainnet: "https://api-evm.orderly.org/v1",
+};
+const AEVO_DEFAULTS = {
+    testnet: "https://api-testnet.aevo.xyz",
+    mainnet: "https://api.aevo.xyz",
+};
+const PARADEX_DEFAULTS = {
+    testnet: "https://api.testnet.paradex.trade/v1",
+    mainnet: "https://api.prod.paradex.trade/v1",
+};
+const PARADEX_CHAIN_DEFAULTS = {
+    testnet: "SN_SEPOLIA",
+    mainnet: "SN_MAIN",
+};
+function resolveExchangeNetwork(defaultTestnet, override) {
+    if (override) {
+        return override;
+    }
+    return defaultTestnet ? "testnet" : "mainnet";
+}
+function loadDefaultAccount(exchangeId) {
+    try {
+        return getDefaultAccountForExchange(exchangeId);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveStoredAccount(exchangeId) {
+    const defaultAccount = loadDefaultAccount(exchangeId);
+    if (defaultAccount) {
+        return {
+            privateKey: defaultAccount.apiWalletPrivateKey || undefined,
+            walletAddress: defaultAccount.userAddress,
+            account: {
+                alias: defaultAccount.alias,
+                type: defaultAccount.type,
+            },
+        };
+    }
+    return {};
+}
+function resolveHyperliquidSettings(testnet, env) {
+    const stored = resolveStoredAccount("hyperliquid");
+    const network = resolveExchangeNetwork(testnet, env.HYPERLIQUID_NETWORK);
+    if (stored.walletAddress || stored.privateKey) {
+        return {
+            network,
+            privateKey: stored.privateKey,
+            walletAddress: stored.walletAddress,
+        };
+    }
+    const privateKey = env.HYPERLIQUID_PRIVATE_KEY;
+    let walletAddress = env.HYPERLIQUID_WALLET_ADDRESS;
+    if (privateKey && !walletAddress) {
+        walletAddress = privateKeyToAccount(privateKey).address;
+    }
+    return {
+        network,
+        privateKey,
+        walletAddress,
+    };
+}
+function resolveDecibelSettings(testnet, env) {
+    const network = resolveExchangeNetwork(testnet, env.DECIBEL_NETWORK);
+    const defaults = DECIBEL_NETWORK_DEFAULTS[network];
+    const credentials = {
+        apiWalletPrivateKey: env.DECIBEL_API_WALLET_PRIVATE_KEY,
+        apiWalletAddress: env.DECIBEL_API_WALLET_ADDRESS,
+        apiBearerToken: env.DECIBEL_API_BEARER_TOKEN,
+        subaccountAddress: env.DECIBEL_SUBACCOUNT_ADDRESS,
+    };
+    const hasAnyCredentials = !!credentials.apiWalletPrivateKey ||
+        !!credentials.apiWalletAddress ||
+        !!credentials.apiBearerToken ||
+        !!credentials.subaccountAddress;
+    return {
+        network,
+        fullnodeUrl: env.DECIBEL_FULLNODE_URL ?? defaults.fullnodeUrl,
+        restUrl: env.DECIBEL_REST_URL ?? defaults.restUrl,
+        wsUrl: env.DECIBEL_WS_URL ?? defaults.wsUrl,
+        packageAddress: env.DECIBEL_PACKAGE_ADDRESS ?? defaults.packageAddress,
+        credentials: hasAnyCredentials ? credentials : undefined,
+    };
+}
+function resolveAevoSettings(testnet, env) {
+    const network = resolveExchangeNetwork(testnet, env.AEVO_NETWORK);
+    return {
+        network,
+        restUrl: env.AEVO_REST_URL ?? AEVO_DEFAULTS[network],
+        apiKey: env.AEVO_API_KEY,
+        apiSecret: env.AEVO_API_SECRET,
+        signingKey: env.AEVO_SIGNING_KEY,
+    };
+}
+function resolveOrderlySettings(testnet, env) {
+    const network = resolveExchangeNetwork(testnet, env.ORDERLY_NETWORK);
+    return {
+        network,
+        restUrl: env.ORDERLY_REST_URL ?? ORDERLY_DEFAULTS[network],
+        accountId: env.ORDERLY_ACCOUNT_ID,
+        key: env.ORDERLY_KEY,
+        secret: env.ORDERLY_SECRET,
+        tradingKey: env.ORDERLY_TRADING_KEY,
+        tradingSecret: env.ORDERLY_TRADING_SECRET,
+    };
+}
+function resolveParadexSettings(testnet, env) {
+    const network = resolveExchangeNetwork(testnet, env.PARADEX_NETWORK);
+    return {
+        network,
+        restUrl: env.PARADEX_REST_URL ?? PARADEX_DEFAULTS[network],
+        apiBearerToken: env.PARADEX_API_BEARER_TOKEN,
+        account: env.PARADEX_ACCOUNT_ADDRESS,
+        ethereumAccount: env.PARADEX_ETHEREUM_ACCOUNT,
+        privateKey: env.PARADEX_PRIVATE_KEY,
+        chainId: env.PARADEX_CHAIN_ID ?? PARADEX_CHAIN_DEFAULTS[network],
+    };
+}
+function resolveSelectedExchangeNetwork(exchangeId, settings, fallbackTestnet) {
+    switch (exchangeId) {
+        case "hyperliquid":
+            return settings.hyperliquid.network;
+        case "decibel":
+            return settings.decibel.network;
+        case "aevo":
+            return settings.aevo.network;
+        case "orderly":
+            return settings.orderly.network;
+        case "paradex":
+            return settings.paradex.network;
+        default:
+            return fallbackTestnet ? "testnet" : "mainnet";
+    }
+}
+export function loadConfig(testnet, exchangeId = "hyperliquid") {
+    const env = parseEnv(process.env);
+    const normalizedExchangeId = exchangeId.toLowerCase();
+    const selectedAccount = resolveStoredAccount(normalizedExchangeId);
+    const hyperliquid = resolveHyperliquidSettings(testnet, env);
+    const decibel = resolveDecibelSettings(testnet, env);
+    const aevo = resolveAevoSettings(testnet, env);
+    const orderly = resolveOrderlySettings(testnet, env);
+    const paradex = resolveParadexSettings(testnet, env);
+    const exchanges = {
+        hyperliquid,
+        decibel,
+        aevo,
+        orderly,
+        paradex,
+    };
+    const selectedNetwork = resolveSelectedExchangeNetwork(normalizedExchangeId, exchanges, testnet);
+    if (selectedAccount.walletAddress || selectedAccount.privateKey) {
+        if (normalizedExchangeId === "decibel") {
+            decibel.credentials = {
+                ...decibel.credentials,
+                apiWalletPrivateKey: selectedAccount.privateKey ?? decibel.credentials?.apiWalletPrivateKey,
+                apiWalletAddress: selectedAccount.walletAddress ?? decibel.credentials?.apiWalletAddress,
+                subaccountAddress: decibel.credentials?.subaccountAddress ??
+                    selectedAccount.walletAddress ??
+                    decibel.credentials?.apiWalletAddress,
+            };
+        }
+        else if (normalizedExchangeId === "aevo") {
+            if (!aevo.signingKey && selectedAccount.privateKey) {
+                aevo.signingKey = selectedAccount.privateKey;
+            }
+        }
+        else if (normalizedExchangeId === "orderly") {
+            if (!orderly.accountId && selectedAccount.walletAddress) {
+                orderly.accountId = selectedAccount.walletAddress;
+            }
+            if (!orderly.tradingSecret && selectedAccount.privateKey) {
+                orderly.tradingSecret = selectedAccount.privateKey;
+            }
+        }
+        else if (normalizedExchangeId === "paradex") {
+            if (!paradex.privateKey && selectedAccount.privateKey) {
+                paradex.privateKey = selectedAccount.privateKey;
+            }
+            if (!paradex.account && selectedAccount.walletAddress) {
+                paradex.account = selectedAccount.walletAddress;
+            }
+        }
+    }
+    let privateKey;
+    let walletAddress;
+    if (selectedAccount.walletAddress || selectedAccount.privateKey) {
+        privateKey = selectedAccount.privateKey;
+        walletAddress = selectedAccount.walletAddress;
+    }
+    else if (normalizedExchangeId === "decibel") {
+        privateKey = decibel.credentials?.apiWalletPrivateKey;
+        walletAddress = undefined;
+    }
+    else if (normalizedExchangeId === "hyperliquid") {
+        privateKey = hyperliquid.privateKey;
+        walletAddress = hyperliquid.walletAddress;
+    }
+    else if (normalizedExchangeId === "aevo") {
+        privateKey = aevo.signingKey;
+        walletAddress = privateKey ? privateKeyToAccount(privateKey).address : undefined;
+    }
+    return {
+        privateKey,
+        walletAddress,
+        testnet: selectedNetwork === "testnet",
+        account: selectedAccount.account,
+        risk: {
+            maxPositionSizeUsd: env.RISK_MAX_POSITION_SIZE_USD,
+            maxTotalExposureUsd: env.RISK_MAX_TOTAL_EXPOSURE_USD,
+            maxLeverage: env.RISK_MAX_LEVERAGE,
+            minSignalConfidence: env.RISK_MIN_SIGNAL_CONFIDENCE,
+            maxDrawdownPct: env.RISK_MAX_DRAWDOWN_PCT,
+            defaultLeverage: env.RISK_DEFAULT_LEVERAGE,
+        },
+        executionSafety: {
+            stopLossPct: env.EXECUTION_STOP_LOSS_PCT,
+            takeProfitPct: env.EXECUTION_TAKE_PROFIT_PCT,
+            spreadOffset: env.EXECUTION_SPREAD_OFFSET_PCT / 100,
+        },
+        operator: {
+            heartbeatIntervalMs: env.OPERATOR_HEARTBEAT_INTERVAL_MS,
+        },
+        exchanges,
+    };
+}
+export function getExchangeCredentials(config, exchangeId, requirement = {}) {
+    const id = exchangeId.toLowerCase();
+    const recordAuth = (scope, status) => {
+        recordTelemetryMetric({
+            metric: `auth.${id}.${scope}`,
+            status,
+        });
+    };
+    if (id === "hyperliquid") {
+        const credentials = {
+            privateKey: config.exchanges.hyperliquid.privateKey,
+            walletAddress: config.exchanges.hyperliquid.walletAddress,
+            network: config.exchanges.hyperliquid.network,
+        };
+        if (requirement.requireReadAccess && !credentials.walletAddress && !credentials.privateKey) {
+            recordAuth("read", "failed");
+            throw new Error("No Hyperliquid account configured. Run 'perps account add' or set HYPERLIQUID_WALLET_ADDRESS.");
+        }
+        if (requirement.requireReadAccess) {
+            recordAuth("read", "success");
+        }
+        if (requirement.requireTrading && !credentials.privateKey) {
+            recordAuth("trade", "failed");
+            throw new Error("Hyperliquid trading requires HYPERLIQUID_PRIVATE_KEY or an API-wallet account from 'perps account add'.");
+        }
+        if (requirement.requireTrading) {
+            recordAuth("trade", "success");
+        }
+        return credentials;
+    }
+    if (id === "decibel") {
+        const decibel = config.exchanges.decibel;
+        const credentials = {
+            privateKey: decibel.credentials?.apiWalletPrivateKey,
+            accountAddress: decibel.credentials?.apiWalletAddress,
+            apiBearerToken: decibel.credentials?.apiBearerToken,
+            subaccountAddress: decibel.credentials?.subaccountAddress ?? decibel.credentials?.apiWalletAddress,
+            packageAddress: decibel.packageAddress,
+            restUrl: decibel.restUrl,
+            wsUrl: decibel.wsUrl,
+            fullnodeUrl: decibel.fullnodeUrl,
+            network: decibel.network,
+        };
+        if (requirement.requireReadAccess &&
+            (!credentials.apiBearerToken || !credentials.accountAddress)) {
+            recordAuth("read", "failed");
+            throw new Error("Decibel authenticated reads require DECIBEL_API_WALLET_ADDRESS + DECIBEL_API_BEARER_TOKEN.");
+        }
+        if (requirement.requireReadAccess) {
+            recordAuth("read", "success");
+        }
+        if (requirement.requireTrading &&
+            (!credentials.privateKey ||
+                !credentials.accountAddress ||
+                !credentials.apiBearerToken ||
+                !credentials.packageAddress)) {
+            recordAuth("trade", "failed");
+            throw new Error("Decibel trading requires DECIBEL_API_WALLET_PRIVATE_KEY, DECIBEL_API_WALLET_ADDRESS, DECIBEL_API_BEARER_TOKEN, and package/network settings.");
+        }
+        if (requirement.requireTrading) {
+            recordAuth("trade", "success");
+        }
+        return credentials;
+    }
+    if (id === "aevo") {
+        const aevo = config.exchanges.aevo;
+        const credentials = {
+            restUrl: aevo.restUrl,
+            network: aevo.network,
+            apiKey: aevo.apiKey,
+            apiSecret: aevo.apiSecret,
+            privateKey: aevo.signingKey,
+            walletAddress: aevo.signingKey ? privateKeyToAccount(aevo.signingKey).address : undefined,
+        };
+        if (requirement.requireReadAccess && (!credentials.apiKey || !credentials.apiSecret)) {
+            recordAuth("read", "failed");
+            throw new Error("Aevo account reads require AEVO_API_KEY and AEVO_API_SECRET.");
+        }
+        if (requirement.requireReadAccess) {
+            recordAuth("read", "success");
+        }
+        if (requirement.requireTrading &&
+            (!credentials.apiKey || !credentials.apiSecret || !credentials.privateKey)) {
+            recordAuth("trade", "failed");
+            throw new Error("Aevo trading requires AEVO_API_KEY, AEVO_API_SECRET, and AEVO_SIGNING_KEY.");
+        }
+        if (requirement.requireTrading) {
+            recordAuth("trade", "success");
+        }
+        return credentials;
+    }
+    if (id === "orderly") {
+        const orderly = config.exchanges.orderly;
+        const credentials = {
+            network: orderly.network,
+            restUrl: orderly.restUrl,
+            orderlyAccountId: orderly.accountId,
+            orderlyKey: orderly.key,
+            orderlySecret: orderly.secret,
+            orderlyTradingKey: orderly.tradingKey,
+            orderlyTradingSecret: orderly.tradingSecret,
+            accountAddress: orderly.accountId,
+            apiKey: orderly.key,
+            apiSecret: orderly.secret,
+            passphrase: orderly.tradingSecret,
+            subaccountId: orderly.tradingKey,
+        };
+        if (requirement.requireReadAccess &&
+            (!credentials.orderlyAccountId || !credentials.orderlyKey || !credentials.orderlySecret)) {
+            recordAuth("read", "failed");
+            throw new Error("Orderly account reads require ORDERLY_ACCOUNT_ID, ORDERLY_KEY, and ORDERLY_SECRET.");
+        }
+        if (requirement.requireReadAccess) {
+            recordAuth("read", "success");
+        }
+        if (requirement.requireTrading &&
+            (!credentials.orderlyAccountId ||
+                !credentials.orderlyKey ||
+                !credentials.orderlySecret ||
+                !credentials.orderlyTradingSecret)) {
+            recordAuth("trade", "failed");
+            throw new Error("Orderly trading requires ORDERLY_ACCOUNT_ID, ORDERLY_KEY, ORDERLY_SECRET, and ORDERLY_TRADING_SECRET.");
+        }
+        if (requirement.requireTrading) {
+            recordAuth("trade", "success");
+        }
+        return credentials;
+    }
+    if (id === "paradex") {
+        const paradex = config.exchanges.paradex;
+        const credentials = {
+            network: paradex.network,
+            restUrl: paradex.restUrl,
+            apiBearerToken: paradex.apiBearerToken,
+            paradexAccount: paradex.account,
+            paradexEthereumAccount: paradex.ethereumAccount,
+            paradexChainId: paradex.chainId,
+            accountAddress: paradex.account,
+            privateKey: paradex.privateKey,
+        };
+        const canRead = !!credentials.apiBearerToken || !!(credentials.paradexAccount && credentials.privateKey);
+        if (requirement.requireReadAccess && !canRead) {
+            recordAuth("read", "failed");
+            throw new Error("Paradex reads require PARADEX_API_BEARER_TOKEN or PARADEX_ACCOUNT_ADDRESS + PARADEX_PRIVATE_KEY.");
+        }
+        if (requirement.requireReadAccess) {
+            recordAuth("read", "success");
+        }
+        if (requirement.requireTrading &&
+            !credentials.apiBearerToken &&
+            !(credentials.paradexAccount && credentials.privateKey)) {
+            recordAuth("trade", "failed");
+            throw new Error("Paradex trading requires PARADEX_API_BEARER_TOKEN or PARADEX_ACCOUNT_ADDRESS + PARADEX_PRIVATE_KEY.");
+        }
+        if (requirement.requireTrading) {
+            recordAuth("trade", "success");
+        }
+        return credentials;
+    }
+    const generic = {
+        privateKey: config.privateKey,
+        walletAddress: config.walletAddress,
+        network: config.testnet ? "testnet" : "mainnet",
+    };
+    if (requirement.requireReadAccess && !generic.walletAddress && !generic.privateKey) {
+        recordAuth("read", "failed");
+        throw new Error(`No ${exchangeId} account configured. Run 'perps -e ${exchangeId} account add' or set credentials in the environment.`);
+    }
+    if (requirement.requireReadAccess) {
+        recordAuth("read", "success");
+    }
+    if (requirement.requireTrading && !generic.privateKey) {
+        recordAuth("trade", "failed");
+        throw new Error(`${exchangeId} trading requires a private key. Run 'perps -e ${exchangeId} account add' with API wallet support or set credentials in the environment.`);
+    }
+    if (requirement.requireTrading) {
+        recordAuth("trade", "success");
+    }
+    return generic;
+}

package/dist/lib/constants.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Constants and Configuration
+ */
+/** Default timeout for API requests (ms) */
+export declare const DEFAULT_TIMEOUT_MS = 10000;
+/** Default number of retries for failed requests */
+export declare const DEFAULT_RETRIES = 2;
+/** Default delay between retries (ms) */
+export declare const DEFAULT_RETRY_DELAY_MS = 1000;
+/** Maximum concurrent API requests per exchange */
+export declare const MAX_CONCURRENT_REQUESTS = 3;
+/** Rate limit: max requests per window */
+export declare const RATE_LIMIT_REQUESTS = 10;
+export declare const RATE_LIMIT_WINDOW_MS = 1000;
+/** Standard funding interval (hours) */
+export declare const FUNDING_INTERVAL_HOURS = 8;
+/** Major markets for bulk queries (to avoid rate limits) */
+export declare const MAJOR_MARKETS: readonly ["BTC-PERP", "ETH-PERP", "SOL-PERP", "DOGE-PERP", "ARB-PERP", "OP-PERP"];
+/** Common assets for arbitrage tracking */
+export declare const COMMON_ASSETS: readonly ["BTC", "ETH", "SOL", "DOGE", "ARB", "OP", "WIF", "PEPE", "AVAX", "LINK"];
+/** Default orderbook depth */
+export declare const DEFAULT_ORDERBOOK_DEPTH = 20;
+/** Default number of trades to fetch */
+export declare const DEFAULT_TRADES_LIMIT = 100;
+/** Default position size for arb execution (USD) */
+export declare const DEFAULT_ARB_SIZE_USD = 1000;
+/** Minimum annualized spread to consider profitable (%) */
+export declare const MIN_PROFITABLE_SPREAD_PCT = 10;
+/** Days to keep funding history */
+export declare const FUNDING_HISTORY_RETENTION_DAYS = 7;
+/** Default hours for historical analysis */
+export declare const DEFAULT_HISTORY_HOURS = 24;
+/** Default tracking interval (ms) */
+export declare const DEFAULT_TRACK_INTERVAL_MS: number;
+/** Default watch mode refresh (seconds) */
+export declare const DEFAULT_WATCH_INTERVAL_SEC = 30;
+/** Alert check interval (ms) */
+export declare const DEFAULT_ALERT_INTERVAL_MS: number;
+/** Map exchange display names to IDs */
+export declare const EXCHANGE_NAME_TO_ID: Record<string, string>;
+/** Map exchange IDs to display names */
+export declare const EXCHANGE_ID_TO_NAME: Record<string, string>;
+/**
+ * Get exchange ID from display name
+ */
+export declare function getExchangeIdByName(name: string): string;
+/**
+ * Get display name from exchange ID
+ */
+export declare function getExchangeNameById(id: string): string;

package/dist/lib/constants.js

@@ -0,0 +1,84 @@
+/**
+ * Constants and Configuration
+ */
+/** Default timeout for API requests (ms) */
+export const DEFAULT_TIMEOUT_MS = 10000;
+/** Default number of retries for failed requests */
+export const DEFAULT_RETRIES = 2;
+/** Default delay between retries (ms) */
+export const DEFAULT_RETRY_DELAY_MS = 1000;
+/** Maximum concurrent API requests per exchange */
+export const MAX_CONCURRENT_REQUESTS = 3;
+/** Rate limit: max requests per window */
+export const RATE_LIMIT_REQUESTS = 10;
+export const RATE_LIMIT_WINDOW_MS = 1000;
+/** Standard funding interval (hours) */
+export const FUNDING_INTERVAL_HOURS = 8;
+/** Major markets for bulk queries (to avoid rate limits) */
+export const MAJOR_MARKETS = [
+    "BTC-PERP",
+    "ETH-PERP",
+    "SOL-PERP",
+    "DOGE-PERP",
+    "ARB-PERP",
+    "OP-PERP",
+];
+/** Common assets for arbitrage tracking */
+export const COMMON_ASSETS = [
+    "BTC",
+    "ETH",
+    "SOL",
+    "DOGE",
+    "ARB",
+    "OP",
+    "WIF",
+    "PEPE",
+    "AVAX",
+    "LINK",
+];
+/** Default orderbook depth */
+export const DEFAULT_ORDERBOOK_DEPTH = 20;
+/** Default number of trades to fetch */
+export const DEFAULT_TRADES_LIMIT = 100;
+/** Default position size for arb execution (USD) */
+export const DEFAULT_ARB_SIZE_USD = 1000;
+/** Minimum annualized spread to consider profitable (%) */
+export const MIN_PROFITABLE_SPREAD_PCT = 10;
+/** Days to keep funding history */
+export const FUNDING_HISTORY_RETENTION_DAYS = 7;
+/** Default hours for historical analysis */
+export const DEFAULT_HISTORY_HOURS = 24;
+/** Default tracking interval (ms) */
+export const DEFAULT_TRACK_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+/** Default watch mode refresh (seconds) */
+export const DEFAULT_WATCH_INTERVAL_SEC = 30;
+/** Alert check interval (ms) */
+export const DEFAULT_ALERT_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+/** Map exchange display names to IDs */
+export const EXCHANGE_NAME_TO_ID = {
+    "Hyperliquid": "hyperliquid",
+    "Aevo": "aevo",
+    "Paradex": "paradex",
+    "Orderly Network": "orderly",
+    "Decibel": "decibel",
+};
+/** Map exchange IDs to display names */
+export const EXCHANGE_ID_TO_NAME = {
+    "hyperliquid": "Hyperliquid",
+    "aevo": "Aevo",
+    "paradex": "Paradex",
+    "orderly": "Orderly Network",
+    "decibel": "Decibel",
+};
+/**
+ * Get exchange ID from display name
+ */
+export function getExchangeIdByName(name) {
+    return EXCHANGE_NAME_TO_ID[name] || name.toLowerCase().replace(/\s+/g, "");
+}
+/**
+ * Get display name from exchange ID
+ */
+export function getExchangeNameById(id) {
+    return EXCHANGE_ID_TO_NAME[id] || id;
+}

package/dist/lib/contracts.d.ts

@@ -0,0 +1,7 @@
+export declare const JSON_SCHEMA_VERSION = 1;
+export interface JsonContractEnvelope<T> {
+    schemaVersion: number;
+    type: string;
+    data: T;
+}
+export declare function withJsonContract<T>(type: string, data: T): JsonContractEnvelope<T>;

package/dist/lib/contracts.js

@@ -0,0 +1,8 @@
+export const JSON_SCHEMA_VERSION = 1;
+export function withJsonContract(type, data) {
+    return {
+        schemaVersion: JSON_SCHEMA_VERSION,
+        type,
+        data,
+    };
+}

package/dist/lib/credential-vault.d.ts

@@ -0,0 +1,22 @@
+import type { OnboardingProfile } from "./onboarding.js";
+export interface CredentialVaultEntry {
+    id: string;
+    createdAt: string;
+    mode: string;
+    exchanges: string[];
+    wallets: {
+        evmAddress?: string;
+        aptosAddress?: string;
+        starkPublicKey?: string;
+    };
+    encrypted: Record<string, string>;
+}
+export declare function saveOnboardingProfileToVault(profile: OnboardingProfile): {
+    id: string;
+    path: string;
+};
+export declare function getCredentialVaultSummary(): {
+    path: string;
+    entries: number;
+    updatedAt?: string;
+};