API Authentication

https://api.aries.com

https://app.tradearies.dev/oauth2/authorize?response_type=code&client_id=YOUR_CLIENT_ID&redirect_uri=YOUR_REDIRECT_URI&scope=account:information order:execution&state=RANDOM_STRING

const crypto = require('crypto');

// Generate state for CSRF protection
const state = crypto.randomBytes(32).toString('hex');
// Store state in session for verification later

// Build authorization URL
const params = new URLSearchParams({
  response_type: 'code',
  client_id: 'your_client_id',
  redirect_uri: 'https://yourapp.com/oauth/callback',
  scope: 'account:information order:execution market:information',
  state: state
});

const authUrl = `https://app.tradearies.dev/oauth2/authorize?${params}`;

// Redirect user to authUrl
res.redirect(authUrl);

https://yourapp.com/oauth/callback?code=AUTHORIZATION_CODE&state=RANDOM_STRING

https://yourapp.com/oauth/callback?error=access_denied&error_description=User+denied+access&state=RANDOM_STRING

app.get('/oauth/callback', async (req, res) => {
  // Verify state to prevent CSRF
  if (req.query.state !== req.session.oauth_state) {
    return res.status(400).send('Invalid state parameter');
  }

  // Check for errors
  if (req.query.error) {
    return res.status(400).send(`OAuth error: ${req.query.error}`);
  }

  // Get authorization code
  const authCode = req.query.code;
  if (!authCode) {
    return res.status(400).send('No authorization code received');
  }

  // Exchange code for tokens (next step)
  const tokens = await exchangeCodeForToken(authCode);
  // Store tokens and redirect to app
  res.redirect('/dashboard');
});

{
  "access_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
  "token_type": "Bearer",
  "expires_in": 3600,
  "refresh_token": "eyJjdHkiOiJKV1QiLCJlbmMiOiJBMjU2R0NNIiwiYWxnIjoiUlNBLU9BRVAifQ...",
  "scope": "account:information order:execution market:information"
}

curl -X GET 'https://api.aries.com/v1/users/me' \
  -H 'Authorization: Bearer YOUR_ACCESS_TOKEN'

async function getUserInfo(accessToken) {
  const response = await fetch('https://api.aries.com/v1/users/me', {
    headers: { 'Authorization': `Bearer ${accessToken}` }
  });

  if (!response.ok) throw new Error('Failed to fetch user info');

  return await response.json();
}

// Usage
const userInfo = await getUserInfo(tokens.access_token);
console.log('User:', userInfo.email);

{
  "access_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
  "token_type": "Bearer",
  "expires_in": 3600,
  "refresh_token": "eyJjdHkiOiJKV1QiLCJlbmMiOiJBMjU2R0NNIiwiYWxnIjoiUlNBLU9BRVAifQ...",
  "scope": "account:information order:execution market:information"
}

async function makeApiRequest(endpoint, accessToken, method = 'GET', data = null) {
  const url = `https://api.aries.com${endpoint}`;
  const options = {
    method,
    headers: { 'Authorization': `Bearer ${accessToken}` },
    signal: AbortSignal.timeout(10000) // 10 second timeout
  };

  if (data) {
    options.headers['Content-Type'] = 'application/json';
    options.body = JSON.stringify(data);
  }

  try {
    const response = await fetch(url, options);

    if (!response.ok) {
      const status = response.status;

      if (status === 401) {
        // Token expired or invalid
        console.log('Authentication failed. Refresh token or re-authenticate.');
        // Attempt token refresh
      } else if (status === 403) {
        // Insufficient permissions
        console.log('Insufficient permissions. Check granted scopes.');
      } else if (status === 429) {
        // Rate limit exceeded
        const retryAfter = response.headers.get('Retry-After') || 60;
        console.log(`Rate limit exceeded. Retry after ${retryAfter} seconds.`);
      } else {
        const errorText = await response.text();
        console.log(`HTTP error: ${status} - ${errorText}`);
      }

      throw new Error(`HTTP ${status}`);
    }

    return await response.json();
  } catch (error) {
    if (error.name === 'AbortError') {
      console.log('Request timed out. Check network connection.');
    } else {
      console.log(`Request failed: ${error.message}`);
    }
    throw error;
  }
}

// Usage
try {
  const userData = await makeApiRequest('/v1/users/me', accessToken);
  console.log('User:', userData.email);
} catch (error) {
  console.log('Failed to fetch user data:', error);
}

async function makeRequestWithRetry(endpoint, accessToken, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await makeApiRequest(endpoint, accessToken);
    } catch (error) {
      if (error.message.includes('429') && attempt < maxRetries - 1) {
        const waitTime = Math.pow(2, attempt) * 1000; // Exponential backoff: 1s, 2s, 4s
        console.log(`Rate limited. Retrying in ${waitTime/1000}s...`);
        await new Promise(resolve => setTimeout(resolve, waitTime));
        continue;
      }
      throw error;
    }
  }

  throw new Error('Max retries exceeded');
}

// Enable fetch debugging with a wrapper
const originalFetch = fetch;
global.fetch = async (...args) => {
  console.log('Request:', args[0], args[1]);
  const response = await originalFetch(...args);
  console.log('Response:', response.status, response.statusText);
  return response;
};

function decodeToken(accessToken) {
  // Decode JWT token (without verification for debugging)
  // Note: Don't use this for authentication, only debugging
  const parts = accessToken.split('.');
  const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
  console.log(JSON.stringify(payload, null, 2));
  return payload;
}

// Check token scopes
const decoded = decodeToken(accessToken);
console.log('Token scopes:', decoded.scope);
console.log('Expires at:', new Date(decoded.exp * 1000));

X-RateLimit-Limit: 100
X-RateLimit-Remaining: 95
X-RateLimit-Reset: 1640000000

{
  "error": "ERROR_CODE",
  "error_description": "Human-readable error description",
  "code": "SPECIFIC_ERROR_CODE"
}