Integration Guide

Prepare your development environment and obtain API credentials

# Install the Bloklab SDK
npm install @bloklab/sdk

# Environment variables (.env)
BLOKLAB_API_KEY=your_api_key_here
BLOKLAB_API_SECRET=your_api_secret_here
BLOKLAB_ENVIRONMENT=sandbox  # or production
BLOKLAB_WEBHOOK_SECRET=your_webhook_secret

Implement secure authentication and token management

import { BloklabClient } from '@bloklab/sdk';

const client = new BloklabClient({
  apiKey: process.env.BLOKLAB_API_KEY,
  apiSecret: process.env.BLOKLAB_API_SECRET,
  environment: process.env.BLOKLAB_ENVIRONMENT
});

// Authenticate user
const authResult = await client.auth.login({
  email: '[email protected]',
  password: 'securepassword',
  mfaCode: '123456' // if MFA is enabled
});

// Store tokens securely
localStorage.setItem('bloklab_token', authResult.access_token);

Integrate core Bloklab functionalities into your application

// Initialize authenticated client
const authenticatedClient = new BloklabClient({
  accessToken: localStorage.getItem('bloklab_token')
});

// Create a new asset
const newAsset = await authenticatedClient.assets.create({
  name: 'Real Estate Investment Token',
  symbol: 'REIT',
  type: 'real_estate',
  totalSupply: '1000000',
  metadata: {
    propertyAddress: '123 Main St, City, Country',
    valuation: '5000000',
    currency: 'USD'
  }
});

// Execute a transaction
const transaction = await authenticatedClient.transactions.create({
  assetId: newAsset.id,
  fromAddress: '0x123...',
  toAddress: '0x456...',
  amount: '1000'
});

Set up real-time event notifications using webhooks

// Express.js webhook endpoint
app.post('/webhooks/bloklab', express.raw({type: 'application/json'}), (req, res) => {
  const signature = req.headers['x-bloklab-signature'];
  const payload = req.body;
  
  // Verify webhook signature
  const expectedSignature = crypto
    .createHmac('sha256', process.env.BLOKLAB_WEBHOOK_SECRET)
    .update(payload)
    .digest('hex');
  
  if (signature !== expectedSignature) {
    return res.status(401).send('Unauthorized');
  }
  
  const event = JSON.parse(payload);
  
  // Handle different event types
  switch (event.type) {
    case 'asset.created':
      handleAssetCreated(event.data);
      break;
    case 'transaction.completed':
      handleTransactionCompleted(event.data);
      break;
    case 'user.kyc_approved':
      handleKycApproved(event.data);
      break;
  }
  
  res.status(200).send('OK');
});

Implement security measures and compliance requirements

// Rate limiting implementation
const rateLimit = require('express-rate-limit');

const apiLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // limit each IP to 100 requests per windowMs
  message: 'Too many requests from this IP'
});

// Apply rate limiting to API routes
app.use('/api/', apiLimiter);

// Audit logging
function logApiCall(req, res, next) {
  console.log({
    timestamp: new Date().toISOString(),
    method: req.method,
    url: req.url,
    ip: req.ip,
    userAgent: req.get('User-Agent')
  });
  next();
}

app.use(logApiCall);

Test your integration and deploy to production

// Jest test example
describe('Bloklab Integration', () => {
  test('should create asset successfully', async () => {
    const asset = await client.assets.create({
      name: 'Test Asset',
      symbol: 'TST',
      type: 'test',
      totalSupply: '1000'
    });
    
    expect(asset.id).toBeDefined();
    expect(asset.name).toBe('Test Asset');
    expect(asset.status).toBe('pending_approval');
  });
  
  test('should handle authentication errors', async () => {
    const invalidClient = new BloklabClient({
      apiKey: 'invalid_key'
    });
    
    await expect(invalidClient.assets.list())
      .rejects.toThrow('Unauthorized');
  });
});