auramaxx 1.0.0-alpha.4

package/server/lib/solana/jupiter.ts

@@ -0,0 +1,128 @@
+import { Connection, VersionedTransaction, PublicKey } from '@solana/web3.js';
+
+const JUPITER_API = 'https://quote-api.jup.ag/v6';
+
+export interface JupiterQuote {
+  inputMint: string;
+  outputMint: string;
+  inAmount: string;
+  outAmount: string;
+  otherAmountThreshold: string;
+  swapMode: string;
+  slippageBps: number;
+  priceImpactPct: string;
+  routePlan: Array<{
+    swapInfo: {
+      ammKey: string;
+      label: string;
+      inputMint: string;
+      outputMint: string;
+      inAmount: string;
+      outAmount: string;
+      feeAmount: string;
+      feeMint: string;
+    };
+    percent: number;
+  }>;
+}
+
+export interface JupiterSwapResult {
+  swapTransaction: string; // base64-encoded VersionedTransaction
+  lastValidBlockHeight: number;
+}
+
+/**
+ * Get a swap quote from Jupiter.
+ */
+export async function getJupiterQuote(
+  inputMint: string,
+  outputMint: string,
+  amount: string,
+  slippageBps: number
+): Promise<JupiterQuote> {
+  const params = new URLSearchParams({
+    inputMint,
+    outputMint,
+    amount,
+    slippageBps: slippageBps.toString(),
+  });
+
+  const response = await fetch(`${JUPITER_API}/quote?${params}`);
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Jupiter quote failed: ${response.status} ${text}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Get a swap transaction from Jupiter.
+ * Returns a serialized VersionedTransaction ready to sign.
+ */
+export async function getJupiterSwapTransaction(
+  quote: JupiterQuote,
+  userPublicKey: string
+): Promise<JupiterSwapResult> {
+  const response = await fetch(`${JUPITER_API}/swap`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      quoteResponse: quote,
+      userPublicKey,
+      wrapAndUnwrapSol: true,
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Jupiter swap failed: ${response.status} ${text}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Deserialize a Jupiter swap transaction.
+ */
+export function deserializeJupiterTransaction(swapTransaction: string): VersionedTransaction {
+  const txBuf = Buffer.from(swapTransaction, 'base64');
+  return VersionedTransaction.deserialize(txBuf);
+}
+
+/**
+ * Execute a full Jupiter swap: quote → swap tx → sign → send.
+ */
+export async function executeJupiterSwap(
+  connection: Connection,
+  inputMint: string,
+  outputMint: string,
+  amount: string,
+  slippageBps: number,
+  userPublicKey: PublicKey,
+  signTransaction: (tx: VersionedTransaction) => Promise<VersionedTransaction>
+): Promise<{ signature: string; quote: JupiterQuote }> {
+  // Get quote
+  const quote = await getJupiterQuote(inputMint, outputMint, amount, slippageBps);
+
+  // Get swap transaction
+  const { swapTransaction } = await getJupiterSwapTransaction(
+    quote,
+    userPublicKey.toBase58()
+  );
+
+  // Deserialize and sign
+  const tx = deserializeJupiterTransaction(swapTransaction);
+  const signedTx = await signTransaction(tx);
+
+  // Send
+  const signature = await connection.sendRawTransaction(signedTx.serialize(), {
+    skipPreflight: false,
+    maxRetries: 2,
+  });
+
+  // Confirm
+  await connection.confirmTransaction(signature, 'confirmed');
+
+  return { signature, quote };
+}

package/server/lib/solana/transfer.ts

@@ -0,0 +1,108 @@
+import {
+  Connection,
+  Keypair,
+  PublicKey,
+  SystemProgram,
+  Transaction,
+} from '@solana/web3.js';
+import {
+  createTransferInstruction,
+  getAssociatedTokenAddress,
+  createAssociatedTokenAccountInstruction,
+  getAccount,
+  TokenAccountNotFoundError,
+} from '@solana/spl-token';
+
+/**
+ * Build a native SOL transfer transaction.
+ * @param amountLamports - Amount in lamports (1 SOL = 1e9 lamports)
+ */
+export async function buildSolTransfer(
+  connection: Connection,
+  from: PublicKey,
+  to: PublicKey,
+  amountLamports: number | bigint
+): Promise<Transaction> {
+  const lamports = Number(amountLamports);
+
+  const tx = new Transaction().add(
+    SystemProgram.transfer({
+      fromPubkey: from,
+      toPubkey: to,
+      lamports,
+    })
+  );
+
+  tx.feePayer = from;
+  const { blockhash } = await connection.getLatestBlockhash();
+  tx.recentBlockhash = blockhash;
+
+  return tx;
+}
+
+/**
+ * Build an SPL token transfer transaction.
+ * Creates the recipient's associated token account if it doesn't exist.
+ */
+export async function buildSplTransfer(
+  connection: Connection,
+  from: PublicKey,
+  to: PublicKey,
+  mint: PublicKey,
+  amount: bigint,
+  decimals: number
+): Promise<Transaction> {
+  const tx = new Transaction();
+
+  // Get associated token accounts
+  const fromAta = await getAssociatedTokenAddress(mint, from);
+  const toAta = await getAssociatedTokenAddress(mint, to);
+
+  // Check if recipient's ATA exists, create if not
+  try {
+    await getAccount(connection, toAta);
+  } catch (err) {
+    if (err instanceof TokenAccountNotFoundError) {
+      tx.add(
+        createAssociatedTokenAccountInstruction(
+          from, // payer
+          toAta,
+          to,
+          mint
+        )
+      );
+    } else {
+      throw err;
+    }
+  }
+
+  tx.add(
+    createTransferInstruction(
+      fromAta,
+      toAta,
+      from,
+      amount
+    )
+  );
+
+  tx.feePayer = from;
+  const { blockhash } = await connection.getLatestBlockhash();
+  tx.recentBlockhash = blockhash;
+
+  return tx;
+}
+
+/**
+ * Sign and send a Solana transaction.
+ * Returns the transaction signature.
+ */
+export async function sendSolanaTransaction(
+  connection: Connection,
+  tx: Transaction,
+  signer: Keypair
+): Promise<string> {
+  tx.sign(signer);
+  const signature = await connection.sendRawTransaction(tx.serialize());
+  await connection.confirmTransaction(signature, 'confirmed');
+  return signature;
+}

package/server/lib/solana/wallet.ts

@@ -0,0 +1,136 @@
+import { Keypair, Transaction, VersionedTransaction } from '@solana/web3.js';
+import { derivePath } from 'ed25519-hd-key';
+import * as bip39 from 'bip39';
+import { EncryptedData } from '../../types';
+import { encryptWithSeed, decryptWithSeed } from '../encrypt';
+import { getMnemonic, getVaultMnemonic } from '../cold';
+import { prisma } from '../db';
+
+/**
+ * Derive a Solana keypair from a mnemonic using SLIP-0010.
+ * Path: m/44'/501'/{index}'/0'
+ */
+export function deriveSolanaKeypair(mnemonic: string, index: number = 0): Keypair {
+  const seed = bip39.mnemonicToSeedSync(mnemonic);
+  const path = `m/44'/501'/${index}'/0'`;
+  const derived = derivePath(path, seed.toString('hex'));
+  return Keypair.fromSeed(derived.key);
+}
+
+/**
+ * Derive the cold (master) Solana keypair.
+ * Path: m/44'/501'/0'/0'
+ */
+export function deriveSolanaColdKeypair(mnemonic: string): Keypair {
+  return deriveSolanaKeypair(mnemonic, 0);
+}
+
+export interface CreateSolanaHotWalletOptions {
+  tokenHash: string;
+  chain?: string;
+  name?: string;
+  color?: string;
+  description?: string;
+  emoji?: string;
+  hidden?: boolean;
+  coldWalletId?: string;  // Which vault to encrypt with (null = primary)
+}
+
+/**
+ * Create a new Solana hot wallet with a random keypair.
+ * The secret key is encrypted with the cold wallet mnemonic.
+ */
+export async function createSolanaHotWallet(options: CreateSolanaHotWalletOptions) {
+  const { coldWalletId } = options;
+  const mnemonic = coldWalletId ? getVaultMnemonic(coldWalletId) : getMnemonic();
+  if (!mnemonic) {
+    const target = coldWalletId ? `Vault ${coldWalletId}` : 'Cold wallet';
+    throw new Error(`${target} must be unlocked to create Solana hot wallets`);
+  }
+
+  const { tokenHash, chain = 'solana', name, color, description, emoji, hidden = false } = options;
+
+  // Generate random Solana keypair
+  const keypair = Keypair.generate();
+  const address = keypair.publicKey.toBase58();
+
+  // Encrypt secret key with mnemonic
+  const secretKeyHex = Buffer.from(keypair.secretKey).toString('hex');
+  const encrypted = encryptWithSeed(secretKeyHex, mnemonic);
+
+  // Store in DB (with coldWalletId reference)
+  const hotWallet = await prisma.hotWallet.create({
+    data: {
+      address, // Solana addresses are case-sensitive, no toLowerCase
+      encryptedPrivateKey: JSON.stringify(encrypted),
+      tokenHash,
+      coldWalletId: coldWalletId || null,
+      name,
+      color,
+      description,
+      emoji,
+      hidden,
+      chain,
+    },
+  });
+
+  return {
+    address: hotWallet.address,
+    tier: 'hot' as const,
+    chain: hotWallet.chain,
+    createdAt: hotWallet.createdAt.toISOString(),
+    name: hotWallet.name || undefined,
+    color: hotWallet.color || undefined,
+    description: hotWallet.description || undefined,
+    emoji: hotWallet.emoji || undefined,
+    hidden: hotWallet.hidden,
+    tokenHash: hotWallet.tokenHash,
+  };
+}
+
+/**
+ * Get a Solana keypair from a stored hot wallet.
+ * Requires cold wallet to be unlocked for decryption.
+ */
+export async function getSolanaKeypair(address: string): Promise<Keypair> {
+  const wallet = await prisma.hotWallet.findUnique({
+    where: { address },
+  });
+
+  if (!wallet) {
+    throw new Error(`Solana hot wallet not found: ${address}`);
+  }
+
+  // Get mnemonic from the vault this hot wallet belongs to
+  const mnemonic = wallet.coldWalletId
+    ? getVaultMnemonic(wallet.coldWalletId)
+    : getMnemonic();
+  if (!mnemonic) {
+    const target = wallet.coldWalletId ? `Vault ${wallet.coldWalletId}` : 'Cold wallet';
+    throw new Error(`${target} must be unlocked to access Solana hot wallet`);
+  }
+
+  const encrypted: EncryptedData = JSON.parse(wallet.encryptedPrivateKey);
+  const secretKeyHex = decryptWithSeed(encrypted, mnemonic);
+  const secretKey = Uint8Array.from(Buffer.from(secretKeyHex, 'hex'));
+  return Keypair.fromSecretKey(secretKey);
+}
+
+/**
+ * Sign a Solana transaction with a hot wallet keypair.
+ * Returns the transaction signature (base58).
+ */
+export async function signSolanaTransaction(
+  address: string,
+  tx: Transaction | VersionedTransaction
+): Promise<Uint8Array> {
+  const keypair = await getSolanaKeypair(address);
+
+  if (tx instanceof VersionedTransaction) {
+    tx.sign([keypair]);
+  } else {
+    tx.partialSign(keypair);
+  }
+
+  return tx.serialize();
+}

package/server/lib/strategy/emits.ts

@@ -0,0 +1,21 @@
+/**
+ * Hook Emit Processor
+ * ===================
+ * Broadcasts hook emit events as app:emit WS events so the dashboard
+ * can forward them to the correct app iframe via postMessage.
+ */
+
+import { HookResult, HookEmit } from './types';
+import { emitWalletEvent } from '../events';
+
+/**
+ * Broadcast hook emit(s) as app:emit events.
+ * Called after tick, result, and message hooks.
+ */
+export function processEmits(strategyId: string, hookResult: HookResult): void {
+  if (!hookResult.emit) return;
+  const emits: HookEmit[] = Array.isArray(hookResult.emit) ? hookResult.emit : [hookResult.emit];
+  for (const e of emits) {
+    emitWalletEvent('app:emit', { strategyId, channel: e.channel, data: e.data });
+  }
+}