async function verifyYaanToken(
  token,
  clientSecret,
  ipAddress,
  emailDomain = null,
) {
  try {
    const response = await fetch("https://api.yaan.com/sus", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        diamond: token,
        clientsecret: clientSecret,
        ip_addr: ipAddress,
        email_domain: emailDomain,
      }),
    });

    if (!response.ok) {
      throw new Error(`Yaan API error: ${response.status}`);
    }

    const result = await response.json();
    return !result.block;
  } catch (error) {
    console.error("Yaan verification error:", error);
    // Fail closed: if verification fails, block the request
    return false;
  }
}

import requests

def verify_yaan_token(token, client_secret, ip_address, email_domain=None):
    try:
        response = requests.post('https://api.yaan.com/sus', json={
            'diamond': token,
            'clientsecret': client_secret,
            'ip_addr': ip_address,
            'email_domain': email_domain
        }, timeout=5)

        response.raise_for_status()
        result = response.json()
        return not result['block']
    except Exception as e:
        print(f'Yaan verification error: {e}')
        # Fail closed: if verification fails, block the request
        return False

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

type YaanRequest struct {
    Diamond      string  `json:"diamond"`
    ClientSecret string  `json:"clientsecret"`
    IPAddr       string  `json:"ip_addr"`
    EmailDomain  *string `json:"email_domain,omitempty"`
}

type YaanResponse struct {
    Block bool `json:"block"`
}

func verifyYaanToken(token, clientSecret, ipAddr string, emailDomain *string) (bool, error) {
    reqBody := YaanRequest{
        Diamond:      token,
        ClientSecret: clientSecret,
        IPAddr:       ipAddr,
        EmailDomain:  emailDomain,
    }

    jsonData, err := json.Marshal(reqBody)
    if err != nil {
        return false, err
    }

    client := &http.Client{Timeout: 5 * time.Second}
    resp, err := client.Post(
        "https://api.yaan.com/sus",
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        return false, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return false, fmt.Errorf("API returned status %d", resp.StatusCode)
    }

    var result YaanResponse
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return false, err
    }

    return !result.Block, nil
}

require 'net/http'
require 'json'

def verify_yaan_token(token, client_secret, ip_address, email_domain = nil)
  uri = URI('https://api.yaan.com/sus')

  request_body = {
    diamond: token,
    clientsecret: client_secret,
    ip_addr: ip_address,
    email_domain: email_domain
  }.compact

  request = Net::HTTP::Post.new(uri)
  request['Content-Type'] = 'application/json'
  request.body = request_body.to_json

  response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
    http.request(request)
  end

  if response.code.to_i == 200
    result = JSON.parse(response.body)
    return !result['block']
  else
    # Fail closed
    return false
  end
rescue => e
  puts "Yaan verification error: #{e.message}"
  # Fail closed
  false
end