Reading and Writing Data Using the Coinbase API

Hey there, fellow JavaScript devs! Ready to dive into the world of crypto data with Coinbase? Let's get our hands dirty with some code and explore how to sync data for a slick user-facing integration. Buckle up!

Setting Up the Coinbase API Client

First things first, let's get our environment ready. You'll need to install the Coinbase API client:

npm install coinbase-pro

Now, let's initialize our client:

const CoinbasePro = require('coinbase-pro');
const client = new CoinbasePro.AuthenticatedClient(
  'YOUR_API_KEY',
  'YOUR_API_SECRET',
  'YOUR_PASSPHRASE'
);

Authentication

Coinbase uses OAuth 2.0 for user authentication. Here's a quick snippet to get you started:

const express = require('express');
const app = express();

app.get('/auth', (req, res) => {
  const authUrl = client.getAuthUrl();
  res.redirect(authUrl);
});

app.get('/callback', async (req, res) => {
  const { code } = req.query;
  const { access_token, refresh_token } = await client.getToken(code);
  // Store these tokens securely
});

Remember to keep those tokens safe! You'll need them for subsequent requests.

Reading User Data

Now for the fun part - let's fetch some user data:

async function getUserAccounts() {
  const accounts = await client.getAccounts();
  return accounts;
}

async function getTransactionHistory(accountId) {
  const transactions = await client.getAccountHistory(accountId);
  return transactions;
}

async function getCurrentPrice(productId = 'BTC-USD') {
  const ticker = await client.getProductTicker(productId);
  return ticker.price;
}

Writing User Data

Want to make some moves? Here's how to create orders and manage addresses:

async function createBuyOrder(amount, currency = 'BTC') {
  const order = await client.buy({
    amount,
    currency,
    payment_method: 'bank_account'
  });
  return order;
}

async function createNewAddress(accountId) {
  const address = await client.createAddress(accountId);
  return address;
}

Syncing Data for User-Facing Integration

Real-time updates are crucial for a smooth user experience. Let's set up a webhook:

app.post('/webhook', express.json(), (req, res) => {
  const { type, data } = req.body;
  switch(type) {
    case 'transaction':
      updateUserBalance(data);
      break;
    case 'price_update':
      notifyUser(data);
      break;
  }
  res.sendStatus(200);
});

Pro tip: Implement caching to reduce API calls and improve performance:

const NodeCache = require('node-cache');
const cache = new NodeCache({ stdTTL: 60 });

async function getCachedPrice(productId) {
  let price = cache.get(productId);
  if (!price) {
    price = await getCurrentPrice(productId);
    cache.set(productId, price);
  }
  return price;
}

Error Handling and Edge Cases

Always be prepared for the unexpected:

async function safeApiCall(apiFunction) {
  try {
    return await apiFunction();
  } catch (error) {
    if (error.response && error.response.status === 429) {
      console.log('Rate limit hit, backing off...');
      await new Promise(resolve => setTimeout(resolve, 1000));
      return safeApiCall(apiFunction);
    }
    throw error;
  }
}

Security Considerations

Never, ever store API keys in your code. Use environment variables:

const client = new CoinbasePro.AuthenticatedClient(
  process.env.COINBASE_API_KEY,
  process.env.COINBASE_API_SECRET,
  process.env.COINBASE_PASSPHRASE
);

Performance Optimization

When possible, batch your requests to minimize API calls:

async function batchGetPrices(productIds) {
  const promises = productIds.map(id => getCurrentPrice(id));
  return Promise.all(promises);
}

And there you have it! You're now equipped to build some awesome Coinbase integrations. Remember, the crypto world moves fast, so always stay updated with the latest API changes. Happy coding, and may your trades always be in the green! 🚀💰