@raintree-technology/perps 0.1.0

package/dist/lib/credential-vault.js

@@ -0,0 +1,109 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { CREDENTIAL_VAULT_PATH } from "./paths.js";
+import { encryptSecret } from "./secrets.js";
+import { ensurePrivateDir, hardenPrivateFile, PRIVATE_FILE_MODE } from "./fs-security.js";
+const VAULT_SCHEMA_VERSION = 1;
+function createVault() {
+    return {
+        version: VAULT_SCHEMA_VERSION,
+        updatedAt: new Date().toISOString(),
+        entries: [],
+    };
+}
+function readVault() {
+    if (!existsSync(CREDENTIAL_VAULT_PATH)) {
+        return createVault();
+    }
+    try {
+        hardenPrivateFile(CREDENTIAL_VAULT_PATH);
+        const raw = readFileSync(CREDENTIAL_VAULT_PATH, "utf-8");
+        const parsed = JSON.parse(raw);
+        return {
+            version: VAULT_SCHEMA_VERSION,
+            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : new Date().toISOString(),
+            entries: Array.isArray(parsed.entries) ? parsed.entries : [],
+        };
+    }
+    catch {
+        return createVault();
+    }
+}
+function writeVault(vault) {
+    ensurePrivateDir(dirname(CREDENTIAL_VAULT_PATH));
+    writeFileSync(CREDENTIAL_VAULT_PATH, `${JSON.stringify(vault, null, 2)}\n`, {
+        mode: PRIVATE_FILE_MODE,
+    });
+    hardenPrivateFile(CREDENTIAL_VAULT_PATH);
+}
+function profileToSecretMap(profile) {
+    const secrets = {};
+    if (profile.credentials.hyperliquid?.privateKey) {
+        secrets.HYPERLIQUID_PRIVATE_KEY = profile.credentials.hyperliquid.privateKey;
+    }
+    if (profile.credentials.decibel?.apiWalletPrivateKey) {
+        secrets.DECIBEL_API_WALLET_PRIVATE_KEY = profile.credentials.decibel.apiWalletPrivateKey;
+    }
+    if (profile.credentials.decibel?.apiBearerToken) {
+        secrets.DECIBEL_API_BEARER_TOKEN = profile.credentials.decibel.apiBearerToken;
+    }
+    if (profile.credentials.aevo?.signingKey) {
+        secrets.AEVO_SIGNING_KEY = profile.credentials.aevo.signingKey;
+    }
+    if (profile.credentials.aevo?.apiKey) {
+        secrets.AEVO_API_KEY = profile.credentials.aevo.apiKey;
+    }
+    if (profile.credentials.aevo?.apiSecret) {
+        secrets.AEVO_API_SECRET = profile.credentials.aevo.apiSecret;
+    }
+    if (profile.credentials.orderly?.tradingSecret) {
+        secrets.ORDERLY_TRADING_SECRET = profile.credentials.orderly.tradingSecret;
+    }
+    if (profile.credentials.orderly?.key) {
+        secrets.ORDERLY_KEY = profile.credentials.orderly.key;
+    }
+    if (profile.credentials.orderly?.secret) {
+        secrets.ORDERLY_SECRET = profile.credentials.orderly.secret;
+    }
+    if (profile.credentials.paradex?.privateKey) {
+        secrets.PARADEX_PRIVATE_KEY = profile.credentials.paradex.privateKey;
+    }
+    if (profile.credentials.paradex?.apiBearerToken) {
+        secrets.PARADEX_API_BEARER_TOKEN = profile.credentials.paradex.apiBearerToken;
+    }
+    return secrets;
+}
+function buildId(profile) {
+    const day = profile.generatedAt.slice(0, 10).replace(/-/g, "");
+    const suffix = Math.random().toString(36).slice(2, 8);
+    return `onb-${day}-${suffix}`;
+}
+export function saveOnboardingProfileToVault(profile) {
+    const vault = readVault();
+    const id = buildId(profile);
+    const plainSecrets = profileToSecretMap(profile);
+    const encrypted = {};
+    for (const [key, value] of Object.entries(plainSecrets)) {
+        encrypted[key] = encryptSecret(value);
+    }
+    const entry = {
+        id,
+        createdAt: profile.generatedAt,
+        mode: profile.mode,
+        exchanges: [...profile.exchanges],
+        wallets: { ...profile.wallets },
+        encrypted,
+    };
+    vault.entries.unshift(entry);
+    vault.updatedAt = new Date().toISOString();
+    writeVault(vault);
+    return { id, path: CREDENTIAL_VAULT_PATH };
+}
+export function getCredentialVaultSummary() {
+    const vault = readVault();
+    return {
+        path: CREDENTIAL_VAULT_PATH,
+        entries: vault.entries.length,
+        updatedAt: vault.updatedAt,
+    };
+}

package/dist/lib/db/accounts.d.ts

@@ -0,0 +1,83 @@
+import type { Address, Hex } from "viem";
+/**
+ * Account types
+ */
+export type AccountType = "readonly" | "api_wallet";
+export type AccountSource = "cli_import";
+/**
+ * Account interface
+ */
+export interface Account {
+    id: number;
+    alias: string;
+    exchange: string;
+    userAddress: Address;
+    type: AccountType;
+    source: AccountSource;
+    apiWalletPrivateKey: Hex | null;
+    apiWalletPublicKey: Address | null;
+    isDefault: boolean;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * Input for creating an account
+ */
+export interface CreateAccountInput {
+    alias: string;
+    exchange: string;
+    userAddress: Address;
+    type: AccountType;
+    source?: AccountSource;
+    apiWalletPrivateKey?: Hex;
+    apiWalletPublicKey?: Address;
+    setAsDefault?: boolean;
+}
+/**
+ * Create a new account
+ */
+export declare function createAccount(input: CreateAccountInput): Account;
+/**
+ * Get an account by ID
+ */
+export declare function getAccountById(id: number): Account | null;
+/**
+ * Get an account by alias
+ */
+export declare function getAccountByAlias(alias: string, exchange?: string): Account | null;
+/**
+ * Get an account by alias scoped to a specific exchange
+ */
+export declare function getAccountByAliasForExchange(alias: string, exchange: string): Account | null;
+/**
+ * Get the default account
+ */
+export declare function getDefaultAccount(): Account | null;
+/**
+ * Get the default account for a specific exchange
+ */
+export declare function getDefaultAccountForExchange(exchange: string): Account | null;
+/**
+ * Get all accounts
+ */
+export declare function getAllAccounts(): Account[];
+/**
+ * Set an account as default by alias
+ */
+export declare function setDefaultAccount(alias: string, exchange?: string): Account;
+/**
+ * Delete an account by alias
+ */
+export declare function deleteAccount(alias: string, exchange?: string): boolean;
+/**
+ * Check if an alias is already taken
+ */
+export declare function isAliasTaken(alias: string, exchange?: string): boolean;
+/**
+ * Update an account's API wallet credentials
+ */
+export declare function updateAccountApiWallet(alias: string, apiWalletPrivateKey: Hex, apiWalletPublicKey: Address, exchange?: string): Account;
+/**
+ * Get account count
+ */
+export declare function getAccountCount(exchange?: string): number;

package/dist/lib/db/accounts.js

@@ -0,0 +1,203 @@
+import { getDb } from "./index.js";
+import { decryptSecret, encryptSecret, isEncryptedSecret } from "../secrets.js";
+function decodePrivateKey(row) {
+    if (!row.api_wallet_private_key) {
+        return null;
+    }
+    if (isEncryptedSecret(row.api_wallet_private_key)) {
+        return decryptSecret(row.api_wallet_private_key);
+    }
+    // Legacy plaintext rows are migrated in-place on first read.
+    const encrypted = encryptSecret(row.api_wallet_private_key);
+    getDb()
+        .prepare("UPDATE accounts SET api_wallet_private_key = ?, updated_at = strftime('%s', 'now') WHERE id = ?")
+        .run(encrypted, row.id);
+    return row.api_wallet_private_key;
+}
+/**
+ * Convert database row to Account object
+ */
+function rowToAccount(row) {
+    return {
+        id: row.id,
+        alias: row.alias,
+        exchange: row.exchange,
+        userAddress: row.user_address,
+        type: row.type,
+        source: row.source,
+        apiWalletPrivateKey: decodePrivateKey(row),
+        apiWalletPublicKey: row.api_wallet_public_key,
+        isDefault: row.is_default === 1,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+/**
+ * Create a new account
+ */
+export function createAccount(input) {
+    const db = getDb();
+    if (isAliasTaken(input.alias, input.exchange)) {
+        throw new Error(`Alias "${input.alias}" is already in use for exchange "${input.exchange}". Choose a different alias.`);
+    }
+    // If this is the first account or setAsDefault is true, make it default
+    const accountCount = db.prepare("SELECT COUNT(*) as count FROM accounts WHERE exchange = ?").get(input.exchange);
+    const shouldBeDefault = accountCount.count === 0 || input.setAsDefault;
+    // If setting as default for this exchange, unset current default first
+    if (shouldBeDefault) {
+        db.prepare("UPDATE accounts SET is_default = 0 WHERE is_default = 1 AND exchange = ?").run(input.exchange);
+    }
+    const result = db.prepare(`
+    INSERT INTO accounts (
+      alias,
+      exchange,
+      user_address,
+      type,
+      source,
+      api_wallet_private_key,
+      api_wallet_public_key,
+      is_default
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(input.alias, input.exchange, input.userAddress, input.type, input.source || "cli_import", input.apiWalletPrivateKey ? encryptSecret(input.apiWalletPrivateKey) : null, input.apiWalletPublicKey || null, shouldBeDefault ? 1 : 0);
+    return getAccountById(Number(result.lastInsertRowid));
+}
+/**
+ * Get an account by ID
+ */
+export function getAccountById(id) {
+    const db = getDb();
+    const row = db.prepare("SELECT * FROM accounts WHERE id = ?").get(id);
+    return row ? rowToAccount(row) : null;
+}
+/**
+ * Get an account by alias
+ */
+export function getAccountByAlias(alias, exchange) {
+    const db = getDb();
+    if (exchange) {
+        const row = db
+            .prepare("SELECT * FROM accounts WHERE alias = ? AND exchange = ?")
+            .get(alias, exchange);
+        return row ? rowToAccount(row) : null;
+    }
+    const rows = db.prepare("SELECT * FROM accounts WHERE alias = ? ORDER BY created_at ASC").all(alias);
+    if (rows.length === 0) {
+        return null;
+    }
+    if (rows.length > 1) {
+        throw new Error(`Multiple accounts found with alias "${alias}". Re-run with --exchange to disambiguate.`);
+    }
+    return rowToAccount(rows[0]);
+}
+/**
+ * Get an account by alias scoped to a specific exchange
+ */
+export function getAccountByAliasForExchange(alias, exchange) {
+    return getAccountByAlias(alias, exchange);
+}
+/**
+ * Get the default account
+ */
+export function getDefaultAccount() {
+    const db = getDb();
+    const row = db.prepare("SELECT * FROM accounts WHERE is_default = 1").get();
+    return row ? rowToAccount(row) : null;
+}
+/**
+ * Get the default account for a specific exchange
+ */
+export function getDefaultAccountForExchange(exchange) {
+    const db = getDb();
+    const row = db
+        .prepare("SELECT * FROM accounts WHERE is_default = 1 AND exchange = ?")
+        .get(exchange);
+    return row ? rowToAccount(row) : null;
+}
+/**
+ * Get all accounts
+ */
+export function getAllAccounts() {
+    const db = getDb();
+    const rows = db.prepare("SELECT * FROM accounts ORDER BY is_default DESC, created_at ASC").all();
+    return rows.map(rowToAccount);
+}
+/**
+ * Set an account as default by alias
+ */
+export function setDefaultAccount(alias, exchange) {
+    const db = getDb();
+    // Check if account exists
+    const account = getAccountByAlias(alias, exchange);
+    if (!account) {
+        const exchangeLabel = exchange ? ` for exchange "${exchange}"` : "";
+        throw new Error(`Account with alias "${alias}" not found${exchangeLabel}`);
+    }
+    // Unset current default for this exchange only
+    db.prepare("UPDATE accounts SET is_default = 0 WHERE is_default = 1 AND exchange = ?").run(account.exchange);
+    // Set new default
+    db.prepare("UPDATE accounts SET is_default = 1, updated_at = strftime('%s', 'now') WHERE id = ?").run(account.id);
+    return getAccountById(account.id);
+}
+/**
+ * Delete an account by alias
+ */
+export function deleteAccount(alias, exchange) {
+    const db = getDb();
+    const account = getAccountByAlias(alias, exchange);
+    if (!account) {
+        return false;
+    }
+    const wasDefault = account.isDefault;
+    db.prepare("DELETE FROM accounts WHERE id = ?").run(account.id);
+    // If deleted account was default, set the first remaining account as default
+    if (wasDefault) {
+        const firstAccount = db
+            .prepare("SELECT * FROM accounts WHERE exchange = ? ORDER BY created_at ASC LIMIT 1")
+            .get(account.exchange);
+        if (firstAccount) {
+            db.prepare("UPDATE accounts SET is_default = 1 WHERE id = ?").run(firstAccount.id);
+        }
+    }
+    return true;
+}
+/**
+ * Check if an alias is already taken
+ */
+export function isAliasTaken(alias, exchange) {
+    const db = getDb();
+    const row = exchange
+        ? db.prepare("SELECT 1 FROM accounts WHERE alias = ? AND exchange = ?").get(alias, exchange)
+        : db.prepare("SELECT 1 FROM accounts WHERE alias = ?").get(alias);
+    return row !== undefined;
+}
+/**
+ * Update an account's API wallet credentials
+ */
+export function updateAccountApiWallet(alias, apiWalletPrivateKey, apiWalletPublicKey, exchange) {
+    const db = getDb();
+    const account = getAccountByAlias(alias, exchange);
+    if (!account) {
+        const exchangeLabel = exchange ? ` for exchange "${exchange}"` : "";
+        throw new Error(`Account with alias "${alias}" not found${exchangeLabel}`);
+    }
+    db.prepare(`
+    UPDATE accounts
+    SET
+      api_wallet_private_key = ?,
+      api_wallet_public_key = ?,
+      type = 'api_wallet',
+      updated_at = strftime('%s', 'now')
+    WHERE id = ?
+  `).run(encryptSecret(apiWalletPrivateKey), apiWalletPublicKey, account.id);
+    return getAccountById(account.id);
+}
+/**
+ * Get account count
+ */
+export function getAccountCount(exchange) {
+    const db = getDb();
+    const result = exchange
+        ? db.prepare("SELECT COUNT(*) as count FROM accounts WHERE exchange = ?").get(exchange)
+        : db.prepare("SELECT COUNT(*) as count FROM accounts").get();
+    return result.count;
+}

package/dist/lib/db/funding-history.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Funding History Database Operations
+ * Store and retrieve funding rate history for arbitrage analysis
+ */
+export interface FundingRecord {
+    id?: number;
+    exchange: string;
+    market: string;
+    rate: number;
+    annualized: number;
+    nextFunding?: number;
+    recordedAt: number;
+}
+export interface FundingSpread {
+    market: string;
+    highExchange: string;
+    highRate: number;
+    lowExchange: string;
+    lowRate: number;
+    spread: number;
+    annualizedSpread: number;
+    recordedAt: number;
+}
+/**
+ * Store a funding rate record
+ */
+export declare function storeFundingRate(record: Omit<FundingRecord, "id">): number;
+/**
+ * Store multiple funding rate records
+ */
+export declare function storeFundingRates(records: Omit<FundingRecord, "id">[]): void;
+/**
+ * Get funding history for a specific market across all exchanges
+ */
+export declare function getFundingHistory(market: string, options?: {
+    hours?: number;
+    exchanges?: string[];
+}): FundingRecord[];
+/**
+ * Get latest funding rate for each exchange for a market
+ */
+export declare function getLatestFundingRates(market: string): FundingRecord[];
+/**
+ * Calculate average funding spreads over time
+ */
+export declare function getFundingSpreads(market: string, hours?: number): FundingSpread[];
+/**
+ * Get average spread statistics
+ */
+export declare function getSpreadStats(market: string, hours?: number): {
+    avgSpread: number;
+    avgAnnualized: number;
+    minSpread: number;
+    maxSpread: number;
+    consistency: number;
+    samples: number;
+    bestPair: {
+        high: string;
+        low: string;
+    } | null;
+};
+/**
+ * Clean up old records (keep last N days)
+ */
+export declare function cleanupOldRecords(daysToKeep?: number): number;
+/**
+ * Get record count
+ */
+export declare function getRecordCount(): number;

package/dist/lib/db/funding-history.js

@@ -0,0 +1,183 @@
+/**
+ * Funding History Database Operations
+ * Store and retrieve funding rate history for arbitrage analysis
+ */
+import { getDb } from "./index.js";
+/**
+ * Store a funding rate record
+ */
+export function storeFundingRate(record) {
+    const db = getDb();
+    const stmt = db.prepare(`
+    INSERT INTO funding_history (exchange, market, rate, annualized, next_funding, recorded_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+    const result = stmt.run(record.exchange, record.market, record.rate, record.annualized, record.nextFunding || null, record.recordedAt);
+    return result.lastInsertRowid;
+}
+/**
+ * Store multiple funding rate records
+ */
+export function storeFundingRates(records) {
+    const db = getDb();
+    const stmt = db.prepare(`
+    INSERT INTO funding_history (exchange, market, rate, annualized, next_funding, recorded_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+    const insertMany = db.transaction((items) => {
+        for (const r of items) {
+            stmt.run(r.exchange, r.market, r.rate, r.annualized, r.nextFunding || null, r.recordedAt);
+        }
+    });
+    insertMany(records);
+}
+/**
+ * Get funding history for a specific market across all exchanges
+ */
+export function getFundingHistory(market, options = {}) {
+    const db = getDb();
+    const hours = options.hours || 24;
+    const cutoff = Date.now() - hours * 60 * 60 * 1000;
+    let sql = `
+    SELECT id, exchange, market, rate, annualized, next_funding as nextFunding, recorded_at as recordedAt
+    FROM funding_history
+    WHERE market = ? AND recorded_at >= ?
+  `;
+    const params = [market, cutoff];
+    if (options.exchanges && options.exchanges.length > 0) {
+        sql += ` AND exchange IN (${options.exchanges.map(() => "?").join(",")})`;
+        params.push(...options.exchanges);
+    }
+    sql += " ORDER BY recorded_at DESC";
+    return db.prepare(sql).all(...params);
+}
+/**
+ * Get latest funding rate for each exchange for a market
+ */
+export function getLatestFundingRates(market) {
+    const db = getDb();
+    const sql = `
+    SELECT f.id, f.exchange, f.market, f.rate, f.annualized, 
+           f.next_funding as nextFunding, f.recorded_at as recordedAt
+    FROM funding_history f
+    INNER JOIN (
+      SELECT exchange, MAX(recorded_at) as max_time
+      FROM funding_history
+      WHERE market = ?
+      GROUP BY exchange
+    ) latest ON f.exchange = latest.exchange AND f.recorded_at = latest.max_time
+    WHERE f.market = ?
+    ORDER BY f.rate DESC
+  `;
+    return db.prepare(sql).all(market, market);
+}
+/**
+ * Calculate average funding spreads over time
+ */
+export function getFundingSpreads(market, hours = 24) {
+    const db = getDb();
+    const cutoff = Date.now() - hours * 60 * 60 * 1000;
+    // Get all records grouped by time bucket (hourly)
+    const sql = `
+    SELECT 
+      exchange,
+      market,
+      rate,
+      annualized,
+      recorded_at as recordedAt,
+      (recorded_at / 3600000) * 3600000 as bucket  -- Round to hour
+    FROM funding_history
+    WHERE market = ? AND recorded_at >= ?
+    ORDER BY bucket, rate DESC
+  `;
+    const records = db.prepare(sql).all(market, cutoff);
+    // Group by bucket and calculate spreads
+    const buckets = new Map();
+    for (const r of records) {
+        const existing = buckets.get(r.bucket) || [];
+        existing.push(r);
+        buckets.set(r.bucket, existing);
+    }
+    const spreads = [];
+    for (const [bucket, rates] of buckets) {
+        if (rates.length < 2)
+            continue;
+        const sorted = [...rates].sort((a, b) => b.rate - a.rate);
+        const high = sorted[0];
+        const low = sorted[sorted.length - 1];
+        spreads.push({
+            market,
+            highExchange: high.exchange,
+            highRate: high.rate,
+            lowExchange: low.exchange,
+            lowRate: low.rate,
+            spread: high.rate - low.rate,
+            annualizedSpread: (high.rate - low.rate) * 24 * 365,
+            recordedAt: bucket,
+        });
+    }
+    return spreads.sort((a, b) => b.recordedAt - a.recordedAt);
+}
+/**
+ * Get average spread statistics
+ */
+export function getSpreadStats(market, hours = 24) {
+    const spreads = getFundingSpreads(market, hours);
+    if (spreads.length === 0) {
+        return {
+            avgSpread: 0,
+            avgAnnualized: 0,
+            minSpread: 0,
+            maxSpread: 0,
+            consistency: 0,
+            samples: 0,
+            bestPair: null,
+        };
+    }
+    const avgSpread = spreads.reduce((sum, s) => sum + s.spread, 0) / spreads.length;
+    const avgAnnualized = spreads.reduce((sum, s) => sum + s.annualizedSpread, 0) / spreads.length;
+    const minSpread = Math.min(...spreads.map(s => s.spread));
+    const maxSpread = Math.max(...spreads.map(s => s.spread));
+    const positiveCount = spreads.filter(s => s.spread > 0.00001).length; // > 0.001%
+    // Find most common high/low pair
+    const pairCounts = new Map();
+    for (const s of spreads) {
+        const key = `${s.highExchange}|${s.lowExchange}`;
+        pairCounts.set(key, (pairCounts.get(key) || 0) + 1);
+    }
+    let bestPair = null;
+    let maxCount = 0;
+    for (const [key, count] of pairCounts) {
+        if (count > maxCount) {
+            maxCount = count;
+            const [high, low] = key.split("|");
+            bestPair = { high, low };
+        }
+    }
+    return {
+        avgSpread,
+        avgAnnualized,
+        minSpread,
+        maxSpread,
+        consistency: (positiveCount / spreads.length) * 100,
+        samples: spreads.length,
+        bestPair,
+    };
+}
+/**
+ * Clean up old records (keep last N days)
+ */
+export function cleanupOldRecords(daysToKeep = 7) {
+    const db = getDb();
+    const cutoff = Date.now() - daysToKeep * 24 * 60 * 60 * 1000;
+    const result = db.prepare("DELETE FROM funding_history WHERE recorded_at < ?").run(cutoff);
+    return result.changes;
+}
+/**
+ * Get record count
+ */
+export function getRecordCount() {
+    const db = getDb();
+    const result = db.prepare("SELECT COUNT(*) as count FROM funding_history").get();
+    return result.count;
+}

package/dist/lib/db/index.d.ts

@@ -0,0 +1,11 @@
+import Database from "better-sqlite3";
+/**
+ * Get or create the database connection
+ */
+export declare function getDb(): Database.Database;
+/**
+ * Close the database connection
+ */
+export declare function closeDb(): void;
+export * from "./accounts.js";
+export * from "./funding-history.js";