# Communication Protocols

authenticate(valuToken, apiKey) {
  this.authInterceptor = this.service.interceptors.request.use(
    (config) => {
      // Add timestamp to prevent replay attacks
      config.url = config.url.includes("timestamp")
        ? config.url
        : config.url + `?timestamp=${Date.now()}`;

      // Sign based on HTTP method
      if (config.method === "get") {
        config.headers["x-api-signature"] = ValuService.signUrlString(
          axios.getUri(config),
          valuToken
        );
      } else {
        let uri = axios.getUri(config);
        if (uri.substr(0, 4) !== "http") {
          uri = config.baseURL.replace(/\/+$/, "") + uri;
        }
        
        // Sign URL + JSON body for POST/PUT requests
        config.headers["x-api-signature"] = ValuService.signUrlString(
          config.data == null ? uri : uri + JSON.stringify(config.data),
          valuToken
        );
      }
      
      config.headers["x-payload-digest-alg"] = "sha256";
      config.headers["x-api-key"] = apiKey;
      return config;
    }
  );
}

static bearerFromSeed = async (seed) => {
  var ripemd160 = crypto.createHash("ripemd160");
  var sha256 = crypto.createHash("sha256");

  const VALU_SERVICE_CANONICAL = Buffer.from(VALU_SERVICE_ID, "utf8");

  const sha256Hash = sha256
    .update(await mnemonicToSeed(seed))
    .update(VALU_SERVICE_CANONICAL)
    .digest();

  return ripemd160.update(sha256Hash).digest().toString("hex");
};

const getSigBuilder = (apiToken, secretKey) => config => {
  const timestamp = Math.floor(Date.now() / 1000)
  const signature = crypto.createHmac('sha256', secretKey)

  // Build signature payload
  signature.update(`${timestamp}${_.toUpper(config.method)}${config.url}`)
  
  if (config.data instanceof FormData) {
    signature.update(config.data.getBuffer())
  } else if (config.data) {
    signature.update(JSON.stringify(config.data))
  }

  // Set authentication headers
  config.headers['X-App-Token'] = apiToken
  config.headers['X-App-Access-Sig'] = signature.digest('hex')
  config.headers['X-App-Access-Ts'] = timestamp

  return config
}

const getSigBuilder = (privateKey) => config => {
  if (!config.data) return config
  
  // Hash the request body
  const hash = crypto.createHash('sha512');
  const hashedData = hash.update(JSON.stringify(config.data), 'utf-8').digest('hex');
  
  // Create RSA-PSS signature
  const signature = crypto.sign("sha512", Buffer.from(hashedData), {
    key: privateKey,
    padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
    saltLength: crypto.constants.RSA_PSS_SALTLEN_DIGEST,
  })
  
  config.headers['X-Request-Signature'] = signature.toString('base64')
  return config
}

const getStripeQuote = async (countryCode) => {
  const convertedCountryCode = getCountryCodeAndCurrency(countryCode);
  const url = new URL('https://api.stripe.com/v1/crypto/onramp_quotes');
  
  url.searchParams.append('source_amount', 1000);
  url.searchParams.append('destination_currencies[]', "usdc");
  url.searchParams.append('destination_networks[]', 'ethereum');
  url.searchParams.append('source_currency', convertedCountryCode.currency.toLowerCase());

  const response = await fetch(url, {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${process.env.STRIPE_SK}`,
      'Content-Type': 'application/json'
    }
  });
  
  return response.json();
}

// Environment configuration
const VERUS_CONFIG = {
  protocol: process.env.REMOTE_PROTOCOL || "http",
  host: process.env.REMOTE_HOST,
  port: process.env.REMOTE_PORT,
  username: process.env.REMOTE_USER,
  password: process.env.REMOTE_PASS
};

const rpcCall = async (method, params = []) => {
  const request = {
    jsonrpc: "2.0",
    method: method,
    params: params,
    id: Math.floor(Math.random() * 1000000)
  };
  
  const response = await axios.post(
    `${VERUS_CONFIG.protocol}://${VERUS_CONFIG.host}:${VERUS_CONFIG.port}`,
    request,
    {
      auth: {
        username: VERUS_CONFIG.username,
        password: VERUS_CONFIG.password
      }
    }
  );
  
  return response.data.result;
};

const { JsonRpcProvider, Wallet, parseUnits, Contract } = require("ethers");

// Initialize provider and wallet
const provider = new JsonRpcProvider("https://rpc-amoy.polygon.technology/");
const wallet = new Wallet(process.env.POLYGON_AMOY_PRIVATE_KEY, provider);

async function payUSDC(toAddress, amount) {
  try {
    // Validate recipient address
    if (!isAddress(toAddress)) {
      throw new Error("Invalid recipient address");
    }
    
    // Setup USDC contract
    const usdcContractAddress = process.env.USDC_AMOY_CONTRACT_ADDRESS;
    const usdcAbi = ["function transfer(address to, uint256 amount) public returns (bool)"];
    const usdcContract = new Contract(usdcContractAddress, usdcAbi, wallet);
    
    // Convert amount to proper decimals (USDC uses 6 decimals)
    const amountInSmallestUnit = parseUnits(amount, 6);
    
    // Execute transaction
    const transactionResponse = await usdcContract.transfer(toAddress, amountInSmallestUnit);
    console.log("Transaction sent:", transactionResponse.hash);
    
    // Wait for confirmation
    await transactionResponse.wait();
    console.log("Transaction confirmed:", transactionResponse.hash);
    
    return transactionResponse.hash;
  } catch (error) {
    console.error("Error sending USDC payment:", error);
    throw error;
  }
}

const mysql = require('mysql2/promise');

const pool = mysql.createPool({
  host: process.env.DB_HOST,
  port: process.env.DB_PORT,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME,
  waitForConnections: true,
  connectionLimit: 100,
  queueLimit: 0,
  ssl: {
    rejectUnauthorized: false // Configure based on SSL setup
  },
  acquireTimeout: 60000,
  timeout: 60000
});

// User creation with parameterized queries
exports.setNewUserforPOL = async (api_key, password, status, network) => {
  const userId = uuidv4();
  
  // Insert new user
  const result = await pool.query(
    'INSERT INTO users (id, status, password, api_key, network) VALUES (?, ?, ?, ?, ?)',
    [userId, status, password, api_key, network]
  );

  // Retrieve created user
  const userResult = await pool.query(
    'SELECT * FROM users WHERE id = ?',
    [userId]
  );

  return userResult[0];
};

const retryWithBackoff = async (fn, maxRetries = 3, baseDelay = 1000) => {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (attempt === maxRetries) {
        throw error;
      }
      
      // Check if error is retryable
      if (error.response && error.response.status < 500) {
        throw error; // Don't retry client errors
      }
      
      // Exponential backoff with jitter
      const delay = baseDelay * Math.pow(2, attempt - 1) + Math.random() * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
};

// Client specifies API version
config.headers['API-Version'] = '2.0';

// Server handles version routing
app.use('/api/v1', v1Router);
app.use('/api/v2', v2Router);
app.use('/api/v3', v3Router);

// Default to latest stable version
app.use('/api', v2Router);