Trade

// 11111111111111111111111111111111 is the SOL native mint
const { address: depositAddress } = await vanish(
  `/deposit_address?token_address=11111111111111111111111111111111`
);

// 11111111111111111111111111111111 is the SOL native mint
let res = vanish(
    client, api_key,
    "/deposit_address?token_address=11111111111111111111111111111111",
    None,
).await?;
let deposit_address = res["address"].as_str().unwrap();

import { PublicKey, SystemProgram, Transaction, sendAndConfirmTransaction } from '@solana/web3.js';

const tx = new Transaction().add(
  SystemProgram.transfer({
    fromPubkey: userKeypair.publicKey,
    toPubkey:   new PublicKey(depositAddress),
    lamports:   100_000_000, // 0.1 SOL
  })
);

const depositTxId = await sendAndConfirmTransaction(connection, tx, [userKeypair]);

use solana_sdk::{pubkey::Pubkey, system_instruction, transaction::Transaction};

let to        = deposit_address.parse::<Pubkey>().unwrap();
let ix        = system_instruction::transfer(&user_keypair.pubkey(), &to, 100_000_000); // 0.1 SOL
let blockhash = rpc.get_latest_blockhash()?;
let tx = Transaction::new_signed_with_payer(
    &[ix], Some(&user_keypair.pubkey()), &[&user_keypair], blockhash,
);

let deposit_tx_id = rpc.send_and_confirm_transaction(&tx)?.to_string();

const deposit = await commit('/commit', depositTxId);
console.log('Deposit status:', deposit.status);
// completed = balance updated, ready to trade
// rejected  = failed screening, funds will be refunded automatically

let deposit = commit(client, api_key, "/commit", &deposit_tx_id).await?;
println!("Deposit status: {}", deposit["status"]);
// completed = balance updated, ready to trade
// rejected  = failed screening, funds will be refunded automatically

const SOL_MINT    = '11111111111111111111111111111111';
const TARGET_MINT = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'; // USDC
const AMOUNT      = '100000000'; // 0.1 SOL in lamports

// never reuse a one-time wallet — fetch a fresh one for every trade
const { address: oneTimeWallet } = await vanish('/trade/one-time-wallet');

const quote = await (await fetch(
  `https://quote-api.jup.ag/v6/quote?inputMint=${SOL_MINT}` +
  `&outputMint=${TARGET_MINT}&amount=${AMOUNT}&slippageBps=50`
)).json();

const { swapTransaction } = await (await fetch('https://quote-api.jup.ag/v6/swap', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    quoteResponse:    quote,
    userPublicKey:    oneTimeWallet,   // must be the one-time wallet
    wrapAndUnwrapSol: true,
    dynamicComputeUnitLimit: true,
  }),
})).json();

const SOL_MINT: &str    = "11111111111111111111111111111111";
const TARGET_MINT: &str = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"; // USDC
const AMOUNT: &str      = "100000000"; // 0.1 SOL in lamports

// never reuse a one-time wallet — fetch a fresh one for every trade
let otw = vanish(client, api_key, "/trade/one-time-wallet", None).await?;
let one_time_wallet = otw["address"].as_str().unwrap();

let quote: Value = reqwest::get(&format!(
    "https://quote-api.jup.ag/v6/quote?inputMint={SOL_MINT}\
     &outputMint={TARGET_MINT}&amount={AMOUNT}&slippageBps=50"
)).await?.json().await?;

let swap_res: Value = client
    .post("https://quote-api.jup.ag/v6/swap")
    .json(&serde_json::json!({
        "quoteResponse":           quote,
        "userPublicKey":           one_time_wallet,  // must be the one-time wallet
        "wrapAndUnwrapSol":        true,
        "dynamicComputeUnitLimit": true,
    }))
    .send().await?.json().await?;

let swap_transaction = swap_res["swapTransaction"].as_str().unwrap();

const LOAN_SOL = '12000000'; // covers ATA creation — unused amount is refunded
const JITO_TIP = '1000000';  // 0.001 SOL — minimum recommended tip

const timestamp = Date.now().toString();

const trade = await vanish('/trade/create', {
  method: 'POST',
  body: JSON.stringify({
    user_address:         userKeypair.publicKey.toBase58(),
    source_token_address: SOL_MINT,
    target_token_address: TARGET_MINT,
    amount:               AMOUNT,
    swap_transaction:     swapTransaction,  // base64-encoded unsigned tx
    one_time_wallet:      oneTimeWallet,
    loan_additional_sol:  LOAN_SOL,
    jito_tip_amount:      JITO_TIP,
    split_repay:          1,
    timestamp,
    user_signature: signMessage(
      `trade:${SOL_MINT}:${TARGET_MINT}:${AMOUNT}:${LOAN_SOL}:${timestamp}:${JITO_TIP}`,
      userKeypair
    ),
    // omit prefer_non_jito to route via Jito (default)
  }),
});

// on the Jito route trade.transaction is null and broadcast() is a no-op
const txId = (await broadcast(trade)) ?? trade.tx_id;
const result = await commit('/commit', txId);

console.log('Status:', result.status, 'Changes:', result.balance_changes);

const LOAN_SOL: &str = "12000000"; // covers ATA creation — unused amount is refunded
const JITO_TIP: &str = "1000000";  // 0.001 SOL — minimum recommended tip

let timestamp = chrono::Utc::now().timestamp_millis().to_string();

let trade = vanish(client, api_key, "/trade/create", Some(&serde_json::json!({
    "user_address":         user_keypair.pubkey().to_string(),
    "source_token_address": SOL_MINT,
    "target_token_address": TARGET_MINT,
    "amount":               AMOUNT,
    "swap_transaction":     swap_transaction,  // base64-encoded unsigned tx
    "one_time_wallet":      one_time_wallet,
    "loan_additional_sol":  LOAN_SOL,
    "jito_tip_amount":      JITO_TIP,
    "split_repay":          1,
    "timestamp":            &timestamp,
    "user_signature": sign_message(
        &format!("trade:{SOL_MINT}:{TARGET_MINT}:{AMOUNT}:{LOAN_SOL}:{timestamp}:{JITO_TIP}"),
        &user_keypair,
    ),
    // omit prefer_non_jito to route via Jito (default)
}))).await?;

// on the Jito route trade["transaction"] is null and broadcast() is a no-op
let tx_id = broadcast(&rpc, &trade).await?
    .unwrap_or_else(|| trade["tx_id"].as_str().unwrap().to_string());
let result = commit(client, api_key, "/commit", &tx_id).await?;

println!("Status: {} Changes: {}", result["status"], result["balance_changes"]);