openbroker 1.0.33

package/scripts/setup/onboard.ts

@@ -0,0 +1,242 @@
+#!/usr/bin/env npx tsx
+// Open Broker - Automated Onboarding for AI Agents
+// Creates wallet, configures environment, and approves builder fee
+
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { fileURLToPath } from 'url';
+
+const OPEN_BROKER_BUILDER_ADDRESS = '0xbb67021fA3e62ab4DA985bb5a55c5c1884381068';
+
+interface OnboardResult {
+  success: boolean;
+  walletAddress?: string;
+  privateKey?: string;
+  error?: string;
+}
+
+function createReadline(): readline.Interface {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+function prompt(rl: readline.Interface, question: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+
+function isValidPrivateKey(key: string): boolean {
+  // Check if it's a valid 64-char hex string with 0x prefix
+  return /^0x[a-fA-F0-9]{64}$/.test(key);
+}
+
+// Get project root relative to this script (scripts/setup/onboard.ts -> project root)
+function getProjectRoot(): string {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  return path.resolve(__dirname, '../..');
+}
+
+async function main(): Promise<OnboardResult> {
+  console.log('Open Broker - Automated Onboarding');
+  console.log('===================================\n');
+
+  const projectRoot = getProjectRoot();
+  const envPath = path.join(projectRoot, '.env');
+
+  // Check if .env already exists
+  if (fs.existsSync(envPath)) {
+    console.log('⚠️  .env file already exists!');
+    console.log('   To re-onboard, delete .env first or edit manually.\n');
+
+    // Read existing config and show wallet address
+    const envContent = fs.readFileSync(envPath, 'utf-8');
+    const keyMatch = envContent.match(/HYPERLIQUID_PRIVATE_KEY=0x([a-fA-F0-9]{64})/);
+
+    if (keyMatch) {
+      const existingKey = `0x${keyMatch[1]}` as `0x${string}`;
+      const account = privateKeyToAccount(existingKey);
+      console.log('Existing Configuration');
+      console.log('----------------------');
+      console.log(`Wallet Address: ${account.address}`);
+      console.log(`\nTo fund this wallet, send USDC to the address above on Arbitrum.`);
+      console.log(`Then deposit to Hyperliquid at: https://app.hyperliquid.xyz/`);
+
+      return {
+        success: true,
+        walletAddress: account.address,
+      };
+    }
+
+    return {
+      success: false,
+      error: 'Invalid .env file - missing or malformed private key',
+    };
+  }
+
+  // Ask user if they have an existing private key
+  const rl = createReadline();
+
+  console.log('Do you have an existing Hyperliquid private key?\n');
+  console.log('  1) Yes, I have a private key ready');
+  console.log('  2) No, generate a new wallet for me\n');
+
+  let choice = '';
+  while (choice !== '1' && choice !== '2') {
+    choice = await prompt(rl, 'Enter choice (1 or 2): ');
+    if (choice !== '1' && choice !== '2') {
+      console.log('Please enter 1 or 2');
+    }
+  }
+
+  let privateKey: `0x${string}`;
+
+  if (choice === '1') {
+    // User has existing key
+    console.log('\nEnter your private key (0x... format):');
+    console.log('(Input is hidden for security)\n');
+
+    let validKey = false;
+    while (!validKey) {
+      const inputKey = await prompt(rl, 'Private key: ');
+
+      if (isValidPrivateKey(inputKey)) {
+        privateKey = inputKey as `0x${string}`;
+        validKey = true;
+      } else {
+        console.log('Invalid private key format. Must be 0x followed by 64 hex characters.');
+        console.log('Example: 0x1234...abcd (66 characters total)\n');
+      }
+    }
+
+    console.log('\n✅ Private key accepted');
+  } else {
+    // Generate new wallet
+    console.log('\nGenerating new wallet...');
+    privateKey = generatePrivateKey();
+    console.log('✅ New wallet created');
+  }
+
+  rl.close();
+
+  // Derive account from private key
+  const account = privateKeyToAccount(privateKey);
+  console.log(`\nWallet Address: ${account.address}\n`);
+
+  // Create .env file
+  console.log('Creating .env file...');
+
+  const envContent = `# Open Broker - Environment Variables
+# Generated automatically during onboarding
+# WARNING: Keep this file secret! Never commit to git!
+
+# Your wallet private key
+HYPERLIQUID_PRIVATE_KEY=${privateKey}
+
+# Network: mainnet or testnet
+HYPERLIQUID_NETWORK=mainnet
+
+# Builder fee configuration (supports open-broker development)
+# Default: 1 bps (0.01%) on trades
+BUILDER_ADDRESS=${OPEN_BROKER_BUILDER_ADDRESS}
+BUILDER_FEE=10
+`;
+
+  fs.writeFileSync(envPath, envContent, { mode: 0o600 }); // Restricted permissions
+  console.log(`✅ .env created at: ${envPath}\n`);
+
+  // Approve builder fee
+  console.log('Approving builder fee...');
+  console.log('(This is free and required before trading)\n');
+
+  try {
+    // Import and run approve-builder inline
+    const { getClient } = await import('../core/client.js');
+    const client = getClient();
+
+    console.log(`   Account: ${client.address}`);
+    console.log(`   Builder: ${OPEN_BROKER_BUILDER_ADDRESS}`);
+
+    // Check if already approved
+    const currentApproval = await client.getMaxBuilderFee(client.address, OPEN_BROKER_BUILDER_ADDRESS);
+
+    if (currentApproval) {
+      console.log(`\n✅ Builder fee already approved (${currentApproval})`);
+    } else {
+      console.log('\n   Sending approval transaction...');
+      const result = await client.approveBuilderFee('0.1%', OPEN_BROKER_BUILDER_ADDRESS);
+
+      if (result.status === 'ok') {
+        console.log('✅ Builder fee approved successfully!');
+      } else {
+        console.log(`⚠️  Approval may have failed: ${result.response}`);
+        console.log('   You can retry later: npx tsx scripts/setup/approve-builder.ts');
+      }
+    }
+  } catch (error) {
+    console.log(`⚠️  Could not approve builder fee: ${error}`);
+    console.log('   You can retry later: npx tsx scripts/setup/approve-builder.ts');
+  }
+
+  // Final summary
+  console.log('\n========================================');
+  console.log('         ONBOARDING COMPLETE!          ');
+  console.log('========================================\n');
+
+  console.log('Your Trading Wallet');
+  console.log('-------------------');
+  console.log(`Address: ${account.address}`);
+  console.log(`Network: Hyperliquid (Mainnet)`);
+
+  if (choice === '2') {
+    console.log('\n⚠️  IMPORTANT: Save your private key!');
+    console.log('-----------------------------------');
+    console.log(`Private Key: ${privateKey}`);
+    console.log('\nThis key is stored in .env but you should back it up securely.');
+  }
+
+  console.log('\n📋 Next Step: Fund Your Wallet');
+  console.log('-------------------------------');
+  console.log('1. Send USDC to your wallet on Arbitrum:');
+  console.log(`   ${account.address}`);
+  console.log('');
+  console.log('2. Deposit USDC to Hyperliquid:');
+  console.log('   https://app.hyperliquid.xyz/');
+  console.log('   (Connect wallet → Deposit → Select amount)');
+  console.log('');
+  console.log('3. Start trading!');
+  console.log('   npx tsx scripts/info/account.ts');
+  console.log('   npx tsx scripts/operations/market-order.ts --coin ETH --side buy --size 0.01 --dry');
+
+  console.log('\n⚠️  SECURITY REMINDER');
+  console.log('---------------------');
+  console.log('Your private key is stored in .env');
+  console.log('NEVER share this file or commit it to git!');
+
+  return {
+    success: true,
+    walletAddress: account.address,
+    privateKey: privateKey,
+  };
+}
+
+// Export for programmatic use
+export { main as onboard };
+
+// Run if executed directly
+main().then(result => {
+  if (!result.success) {
+    console.error(`\nOnboarding failed: ${result.error}`);
+    process.exit(1);
+  }
+}).catch(error => {
+  console.error('Onboarding error:', error);
+  process.exit(1);
+});

package/scripts/strategies/dca.ts

@@ -0,0 +1,292 @@
+#!/usr/bin/env npx tsx
+// DCA (Dollar Cost Averaging) Strategy - Buy fixed amounts at regular intervals
+
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs, sleep } from '../core/utils.js';
+
+function printUsage() {
+  console.log(`
+Open Broker - DCA (Dollar Cost Average)
+=======================================
+
+Automatically buy a fixed USD amount at regular intervals to average into
+a position over time, reducing the impact of volatility.
+
+Usage:
+  npx tsx scripts/strategies/dca.ts --coin <COIN> --amount <USD> --interval <PERIOD> --count <N>
+
+Options:
+  --coin          Asset to accumulate (e.g., ETH, BTC)
+  --amount        USD amount per purchase
+  --interval      Time between purchases (e.g., 1h, 4h, 1d, 1w)
+  --count         Number of purchases to make
+  --total         OR total USD to invest (calculates amount per interval)
+  --slippage      Slippage tolerance in bps (default: 50)
+  --dry           Dry run - show DCA plan without executing
+
+Interval Format:
+  Xm = X minutes (e.g., 30m)
+  Xh = X hours (e.g., 4h, 24h)
+  Xd = X days (e.g., 1d, 7d)
+  Xw = X weeks (e.g., 1w)
+
+Examples:
+  # Buy $100 of ETH every hour for 24 purchases
+  npx tsx scripts/strategies/dca.ts --coin ETH --amount 100 --interval 1h --count 24
+
+  # Invest $5000 in BTC over 30 days with daily purchases
+  npx tsx scripts/strategies/dca.ts --coin BTC --total 5000 --interval 1d --count 30
+
+  # Preview DCA plan
+  npx tsx scripts/strategies/dca.ts --coin SOL --amount 50 --interval 4h --count 42 --dry
+
+DCA Benefits:
+  - Removes emotion from buying decisions
+  - Averages out entry price over time
+  - Reduces risk of buying at local tops
+  - Disciplined long-term accumulation strategy
+`);
+}
+
+interface DcaPurchase {
+  number: number;
+  timestamp: Date;
+  targetAmount: number;
+  actualAmount: number;
+  size: number;
+  price: number;
+  status: 'completed' | 'partial' | 'failed' | 'pending';
+  error?: string;
+}
+
+function parseInterval(interval: string): number {
+  const match = interval.match(/^(\d+)(m|h|d|w)$/i);
+  if (!match) {
+    throw new Error(`Invalid interval format: ${interval}. Use Xm, Xh, Xd, or Xw`);
+  }
+
+  const value = parseInt(match[1]);
+  const unit = match[2].toLowerCase();
+
+  switch (unit) {
+    case 'm':
+      return value * 60 * 1000;
+    case 'h':
+      return value * 60 * 60 * 1000;
+    case 'd':
+      return value * 24 * 60 * 60 * 1000;
+    case 'w':
+      return value * 7 * 24 * 60 * 60 * 1000;
+    default:
+      throw new Error(`Unknown interval unit: ${unit}`);
+  }
+}
+
+function formatInterval(ms: number): string {
+  const minutes = ms / 60000;
+  if (minutes < 60) return `${minutes}m`;
+  const hours = minutes / 60;
+  if (hours < 24) return `${hours}h`;
+  const days = hours / 24;
+  if (days < 7) return `${days}d`;
+  return `${days / 7}w`;
+}
+
+function formatDuration(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ${minutes % 60}m`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ${hours % 24}h`;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  const coin = args.coin as string;
+  const intervalStr = args.interval as string;
+  const count = args.count ? parseInt(args.count as string) : undefined;
+  const amountPerPurchase = args.amount ? parseFloat(args.amount as string) : undefined;
+  const totalAmount = args.total ? parseFloat(args.total as string) : undefined;
+  const slippage = args.slippage ? parseInt(args.slippage as string) : undefined;
+  const dryRun = args.dry as boolean;
+
+  if (!coin || !intervalStr || !count) {
+    printUsage();
+    process.exit(1);
+  }
+
+  if (!amountPerPurchase && !totalAmount) {
+    console.error('Error: Must specify either --amount or --total');
+    process.exit(1);
+  }
+
+  const amount = amountPerPurchase || (totalAmount! / count);
+  const total = totalAmount || (amountPerPurchase! * count);
+
+  let intervalMs: number;
+  try {
+    intervalMs = parseInterval(intervalStr);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+
+  const client = getClient();
+
+  if (args.verbose) {
+    client.verbose = true;
+  }
+
+  console.log('Open Broker - DCA Strategy');
+  console.log('==========================\n');
+
+  try {
+    const mids = await client.getAllMids();
+    const currentPrice = parseFloat(mids[coin]);
+    if (!currentPrice) {
+      console.error(`Error: No market data for ${coin}`);
+      process.exit(1);
+    }
+
+    const totalDuration = intervalMs * (count - 1);
+    const sizePerPurchase = amount / currentPrice;
+    const totalSize = sizePerPurchase * count;
+
+    console.log('DCA Plan');
+    console.log('--------');
+    console.log(`Coin:              ${coin}`);
+    console.log(`Current Price:     ${formatUsd(currentPrice)}`);
+    console.log(`Amount/Purchase:   ${formatUsd(amount)}`);
+    console.log(`Purchases:         ${count}`);
+    console.log(`Interval:          ${formatInterval(intervalMs)}`);
+    console.log(`Total Investment:  ${formatUsd(total)}`);
+    console.log(`Total Duration:    ${formatDuration(totalDuration)}`);
+    console.log(`\nAt Current Price:`);
+    console.log(`  Size/Purchase:   ${sizePerPurchase.toFixed(6)} ${coin}`);
+    console.log(`  Total Size:      ${totalSize.toFixed(6)} ${coin}`);
+
+    // Show schedule
+    console.log('\nSchedule Preview');
+    console.log('----------------');
+    const now = new Date();
+    const previewCount = Math.min(5, count);
+    for (let i = 0; i < previewCount; i++) {
+      const time = new Date(now.getTime() + intervalMs * i);
+      console.log(`  #${i + 1}: ${time.toLocaleString()} - ${formatUsd(amount)}`);
+    }
+    if (count > 5) {
+      console.log(`  ... ${count - 5} more purchases`);
+      const lastTime = new Date(now.getTime() + intervalMs * (count - 1));
+      console.log(`  #${count}: ${lastTime.toLocaleString()} - ${formatUsd(amount)}`);
+    }
+
+    if (dryRun) {
+      console.log('\n--- Dry run complete ---');
+      return;
+    }
+
+    console.log('\nStarting DCA execution...\n');
+
+    const purchases: DcaPurchase[] = [];
+    let totalSpent = 0;
+    let totalAcquired = 0;
+
+    for (let i = 0; i < count; i++) {
+      const purchaseNum = i + 1;
+      console.log(`[${purchaseNum}/${count}] Executing purchase of ${formatUsd(amount)} ${coin}...`);
+
+      const purchase: DcaPurchase = {
+        number: purchaseNum,
+        timestamp: new Date(),
+        targetAmount: amount,
+        actualAmount: 0,
+        size: 0,
+        price: 0,
+        status: 'pending',
+      };
+
+      try {
+        // Get current price and calculate size
+        const newMids = await client.getAllMids();
+        const newPrice = parseFloat(newMids[coin]);
+        const size = amount / newPrice;
+
+        const response = await client.marketOrder(coin, true, size, slippage);
+
+        if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+          const status = response.response.data.statuses[0];
+          if (status?.filled) {
+            purchase.size = parseFloat(status.filled.totalSz);
+            purchase.price = parseFloat(status.filled.avgPx);
+            purchase.actualAmount = purchase.size * purchase.price;
+            purchase.status = purchase.actualAmount >= amount * 0.95 ? 'completed' : 'partial';
+
+            totalSpent += purchase.actualAmount;
+            totalAcquired += purchase.size;
+
+            const avgPrice = totalSpent / totalAcquired;
+            console.log(`  Filled: ${purchase.size.toFixed(6)} ${coin} @ ${formatUsd(purchase.price)}`);
+            console.log(`  Running: ${totalAcquired.toFixed(6)} ${coin} | Avg: ${formatUsd(avgPrice)} | Spent: ${formatUsd(totalSpent)}`);
+          } else if (status?.error) {
+            purchase.status = 'failed';
+            purchase.error = status.error;
+            console.log(`  Failed: ${status.error}`);
+          }
+        } else {
+          purchase.status = 'failed';
+          purchase.error = typeof response.response === 'string' ? response.response : 'Unknown error';
+          console.log(`  Failed: ${purchase.error}`);
+        }
+      } catch (err) {
+        purchase.status = 'failed';
+        purchase.error = err instanceof Error ? err.message : String(err);
+        console.log(`  Error: ${purchase.error}`);
+      }
+
+      purchases.push(purchase);
+
+      // Wait for next interval (unless last purchase)
+      if (i < count - 1) {
+        const nextTime = new Date(Date.now() + intervalMs);
+        console.log(`  Next purchase: ${nextTime.toLocaleString()}\n`);
+        await sleep(intervalMs);
+      }
+    }
+
+    // Summary
+    const avgPrice = totalSpent / totalAcquired;
+    const currentMid = parseFloat((await client.getAllMids())[coin]);
+    const unrealizedPnl = (currentMid - avgPrice) * totalAcquired;
+    const successful = purchases.filter(p => p.status === 'completed' || p.status === 'partial').length;
+    const failed = purchases.filter(p => p.status === 'failed').length;
+
+    console.log('\n========== DCA Summary ==========');
+    console.log(`Purchases:       ${successful}/${count} successful${failed > 0 ? ` (${failed} failed)` : ''}`);
+    console.log(`Total Spent:     ${formatUsd(totalSpent)} / ${formatUsd(total)} target`);
+    console.log(`Total Acquired:  ${totalAcquired.toFixed(6)} ${coin}`);
+    console.log(`Average Price:   ${formatUsd(avgPrice)}`);
+    console.log(`Current Price:   ${formatUsd(currentMid)}`);
+    console.log(`Unrealized PnL:  ${formatUsd(unrealizedPnl)} (${((unrealizedPnl / totalSpent) * 100).toFixed(2)}%)`);
+
+    // Show price history
+    if (purchases.length > 1) {
+      const prices = purchases.filter(p => p.price > 0).map(p => p.price);
+      const minPrice = Math.min(...prices);
+      const maxPrice = Math.max(...prices);
+      console.log(`\nPrice Range:`);
+      console.log(`  Lowest:  ${formatUsd(minPrice)}`);
+      console.log(`  Highest: ${formatUsd(maxPrice)}`);
+      console.log(`  Your Avg: ${formatUsd(avgPrice)} (${((avgPrice - minPrice) / (maxPrice - minPrice) * 100).toFixed(0)}% of range)`);
+    }
+
+  } catch (error) {
+    console.error('Error:', error);
+    process.exit(1);
+  }
+}
+
+main();