Error Handling

const commit = await vanish('/commit', {
  method: 'POST',
  body: JSON.stringify({ tx_id }),
});

if (commit.already_processed) {
  // Already committed - use commit.status to determine what happened
  console.log('Previously resolved:', commit.status);
} else {
  console.log('Freshly committed:', commit.status, commit.balance_changes);
}

let commit: CommitResponse = client
    .post(format!("{}/commit", VANISH_URL))
    .header("x-api-key", &api_key)
    .json(&json!({ "tx_id": tx_id }))
    .send()
    .await?
    .json()
    .await?;

if commit.already_processed {
    println!("Previously resolved: {}", commit.status);
} else {
    println!("Freshly committed: {} {:?}", commit.status, commit.balance_changes);
}

async function recoverPendingCommits(userKeypair: Keypair) {
  const timestamp = Date.now().toString();
  const signature = readSignature(timestamp, userKeypair);

  const pending = await vanish('/account/pending', {
    method: 'POST',
    body: JSON.stringify({
      user_address: userKeypair.publicKey.toBase58(),
      timestamp,
      signature,
    }),
  });

  for (const action of pending) {
    const commit = await vanish('/commit', {
      method: 'POST',
      body: JSON.stringify({ tx_id: action.tx_id }),
    });
    // already_processed: true means it was already committed - safe to skip
    if (!commit.already_processed) {
      console.log(`Resolved ${action.action_type}:`, commit.status);
    }
  }
}

async fn recover_pending_commits(
    client: &Client,
    api_key: &str,
    user_keypair: &Keypair,
) -> Result<(), reqwest::Error> {
    let timestamp = chrono::Utc::now().timestamp_millis().to_string();
    let signature = read_signature(&timestamp, user_keypair);

    let body = serde_json::json!({
        "user_address": user_keypair.pubkey().to_string(),
        "timestamp":    &timestamp,
        "signature":    signature,
    });

    let pending = vanish(client, api_key, "/account/pending", Some(&body)).await?;

    for action in pending.as_array().unwrap_or(&vec![]) {
        let commit_body = serde_json::json!({ "tx_id": action["tx_id"] });
        let commit = vanish(client, api_key, "/commit", Some(&commit_body)).await?;

        if !commit["already_processed"].as_bool().unwrap_or(false) {
            println!("Resolved {}: {}", action["action_type"], commit["status"]);
        }
    }

    Ok(())
}

import * as nacl from 'tweetnacl';
import { Keypair } from '@solana/web3.js';

// Correct signing pattern
const timestamp = Date.now().toString(); // milliseconds

const message = [
  "By signing, I hereby agree to Vanish's Terms of Service and agree to be bound by them (docs.vanish.trade/legal/TOS)",
  "",
  `Details: read:${timestamp}`,
].join('\n');

const sig       = nacl.sign.detached(new TextEncoder().encode(message), keypair.secretKey);
const signature = Buffer.from(sig).toString('base64');

use solana_sdk::signature::{Keypair, Signer};
use base64::{engine::general_purpose, Engine as _};

// Correct signing pattern
let timestamp = chrono::Utc::now().timestamp_millis().to_string(); // milliseconds

let message = format!(
    "By signing, I hereby agree to Vanish's Terms of Service and agree to be bound by them (docs.vanish.trade/legal/TOS)\n\nDetails: read:{timestamp}"
);

let sig       = keypair.sign_message(message.as_bytes());
let signature = general_purpose::STANDARD.encode(sig.as_ref());

async function checkHealth(): Promise<boolean> {
  const res = await fetch('https://core-api.vanish.trade/health', {
    headers: { 'x-api-key': process.env.VANISH_API_KEY! },
  });
  return res.ok; // true if 200 "healthy"
}

async fn check_health(client: &Client, api_key: &str) -> bool {
    client
        .get(format!("{}/health", VANISH_URL))
        .header("x-api-key", api_key)
        .send()
        .await
        .map(|r| r.status().is_success())
        .unwrap_or(false)
}