Integration Examples

import { 
  getQuote, 
  signOrder, 
  submitSwap, 
  pollOrderStatus 
} from '@aori/aori-ts';

async function executeSwap() {
  try {
    // 1. Request a quote
    const quote = await getQuote({
      offerer: '0xYourAddress',
      recipient: '0xYourAddress',
      inputToken: '0x4200000000000000000000000000000000000006',
      outputToken: '0xaf88d065e77c8cc2239327c5edb3a432268e5831',
      inputAmount: '1000000000000000000',
      inputChain: 'base',
      outputChain: 'arbitrum'
    });

    console.log(`Quote received: ${quote.outputAmount} output tokens`);

    // 2. Sign the order
    const signature = await signOrder(quote, {
      privateKey: process.env.PRIVATE_KEY
    });

    // 3. Submit the swap
    const swap = await submitSwap({
      orderHash: quote.orderHash,
      signature: signature
    });

    console.log(`Swap submitted: ${swap.orderHash}`);

    // 4. Poll for completion
    const finalStatus = await pollOrderStatus(swap.orderHash, 'https://api.aori.io', {
      onStatusChange: (status) => {
        console.log(`Status update: ${status.type}`);
      },
      interval: 1000,
      timeout: 60000
    });

    console.log('Swap completed:', finalStatus);
  } catch (error) {
    console.error('Swap failed:', error);
  }
}

import { useAccount, useWalletClient } from 'wagmi';
import { 
  getQuote, 
  signReadableOrder, 
  submitSwap 
} from '@aori/aori-ts';

function SwapComponent() {
  const { address } = useAccount();
  const { data: walletClient } = useWalletClient();

  const handleSwap = async () => {
    // 1. Get quote
    const quote = await getQuote({
      offerer: address,
      recipient: address,
      inputToken: '0x...',
      outputToken: '0x...',
      inputAmount: '1000000000000000000',
      inputChain: 'base',
      outputChain: 'arbitrum'
    });

    // 2. Create wallet wrapper for signing
    const walletWrapper = {
      signTypedData: async (params) => {
        return walletClient.signTypedData({
          account: params.account,
          domain: params.domain,
          types: params.types,
          primaryType: params.primaryType,
          message: params.message
        });
      }
    };

    // 3. Sign with EIP-712
    const { orderHash, signature } = await signReadableOrder(
      quote,
      walletWrapper,
      address
    );

    // 4. Submit swap
    const swap = await submitSwap({
      orderHash,
      signature
    });

    console.log('Swap submitted:', swap.orderHash);
  };

  return (
    <button onClick={handleSwap}>
      Execute Cross-Chain Swap
    </button>
  );
}

import { getQuote, submitSwap } from '@aori/aori-ts';

async function safeSwap(quoteRequest) {
  try {
    const quote = await getQuote(quoteRequest);
    
    // Validate quote parameters
    if (BigInt(quote.outputAmount) === 0n) {
      throw new Error('Invalid quote: zero output amount');
    }
    
    // Check slippage tolerance
    const expectedOutput = calculateExpectedOutput(quoteRequest);
    const actualOutput = BigInt(quote.outputAmount);
    const slippage = ((expectedOutput - actualOutput) * 10000n) / expectedOutput;
    
    if (slippage > 100n) { // 1% slippage
      throw new Error('Slippage too high');
    }
    
    // Proceed with swap...
    
  } catch (error) {
    if (error.message.includes('Quote request failed')) {
      // Handle quote errors
      console.error('Unable to get quote:', error);
    } else if (error.message.includes('Swap request failed')) {
      // Handle swap submission errors
      console.error('Failed to submit swap:', error);
    } else {
      // Handle other errors
      console.error('Unexpected error:', error);
    }
    throw error;
  }
}

import { getQuote, signOrder, submitSwap } from '@aori/aori-ts';

async function batchSwaps(swapRequests) {
  const results = [];
  
  // Get all quotes in parallel
  const quotes = await Promise.all(
    swapRequests.map(request => getQuote(request))
  );
  
  // Process each quote
  for (const [index, quote] of quotes.entries()) {
    try {
      const signature = await signOrder(quote, {
        privateKey: process.env.PRIVATE_KEY
      });
      
      const swap = await submitSwap({
        orderHash: quote.orderHash,
        signature
      });
      
      results.push({
        success: true,
        orderHash: swap.orderHash,
        request: swapRequests[index]
      });
      
    } catch (error) {
      results.push({
        success: false,
        error: error.message,
        request: swapRequests[index]
      });
    }
  }
  
  return results;
}

import { AoriWebSocket } from '@aori/aori-ts';

const ws = new AoriWebSocket('wss://api.aori.io', {
  onMessage: (event) => {
    console.log(`Order ${event.order.orderHash}: ${event.eventType}`);
    
    // Handle different event types
    switch (event.eventType) {
      case 'created':
        console.log('New order created');
        break;
      case 'received':
        console.log('Order received on source chain');
        break;
      case 'completed':
        console.log('Order completed on destination chain');
        break;
      case 'failed':
        console.log('Order failed');
        break;
    }
  },
  onConnect: () => {
    console.log('Connected to Aori WebSocket');
  },
  onDisconnect: (event) => {
    console.log('Disconnected:', event.reason);
  },
  onError: (error) => {
    console.error('WebSocket error:', error);
  }
});

// Connect and handle lifecycle
await ws.connect();

// Disconnect when done
ws.disconnect();