Cross-Chain Swaps

yarn ts-node examples/src/sendScripts/swap/swap.ts \
  --chain-id-from 97 \
  --chain-id-to 42 \
  --token-address-from 0x0000000000000000000000000000000000000000 \
  --token-address-to 0x0000000000000000000000000000000000000000 \
  --amount 0.1

DEBRIDGEGATE_ADDRESS=0x...        # DeBridgeGate contract
ROUTER_ADDRESS=0x...               # DEX router on destination (Uniswap V2, PancakeSwap, etc.)
SENDER_PRIVATE_KEY=0x...

import { ethers } from 'ethers';
import { DeBridgeGate__factory } from '../typechain-types';

async function crossChainSwap() {
    // Setup
    const provider = new ethers.providers.JsonRpcProvider(process.env.RPC_URL);
    const wallet = new ethers.Wallet(process.env.SENDER_PRIVATE_KEY!, provider);
    const debridgeGate = DeBridgeGate__factory.connect(
        process.env.DEBRIDGEGATE_ADDRESS!,
        wallet
    );
    
    // Swap parameters
    const amountIn = ethers.utils.parseEther('1');      // 1 BNB
    const chainIdTo = 1;                                  // Ethereum
    const tokenOut = '0xA0b86...';                       // USDC address on Ethereum
    const minAmountOut = ethers.utils.parseUnits('500', 6); // Minimum 500 USDC
    const deadline = Math.floor(Date.now() / 1000) + 1800;  // 30 minutes
    
    // Encode swap calldata for Uniswap V2
    const swapCalldata = new ethers.utils.Interface([
        'function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)'
    ]).encodeFunctionData('swapExactETHForTokens', [
        minAmountOut,
        [WETH_ADDRESS, tokenOut],                         // Swap path
        wallet.address,                                   // Receiver
        deadline
    ]);
    
    // Execution fee for automatic execution
    const executionFee = ethers.utils.parseEther('0.02');
    
    // Encode auto params for CallProxy
    const autoParams = ethers.utils.defaultAbiCoder.encode(
        ['tuple(uint256,uint256,bytes,bytes)'],
        [[
            executionFee,
            0,                                            // Flags
            ethers.utils.hexZeroPad(wallet.address, 32), // Fallback
            swapCalldata                                  // DEX swap calldata
        ]]
    );
    
    // Send with swap
    const protocolFee = await debridgeGate.globalFixedNativeFee();
    const totalValue = amountIn.add(protocolFee).add(executionFee);
    
    const tx = await debridgeGate.send(
        ethers.constants.AddressZero,                     // BNB (native)
        amountIn,
        chainIdTo,
        ethers.utils.hexZeroPad(process.env.ROUTER_ADDRESS!, 32), // Router as receiver
        '0x',
        false,
        0,
        autoParams,                                        // Swap on destination
        { value: totalValue }
    );
    
    console.log('Swap initiated:', tx.hash);
    const receipt = await tx.wait();
    
    const submissionId = receipt.events?.find(e => e.event === 'Sent')?.args?.submissionId;
    console.log('Track at:', `https://explorer.debridge.finance/tx/${submissionId}`);
}

crossChainSwap().catch(console.error);

// Calculate minimum output with 1% slippage
const expectedOutput = await getExpectedOutput(amountIn, path);
const slippageTolerance = 100; // 1% in basis points
const minAmountOut = expectedOutput.mul(10000 - slippageTolerance).div(10000);

// Use in swap
const swapCalldata = router.interface.encodeFunctionData('swapExactETHForTokens', [
    minAmountOut,  // Minimum tokens to receive
    path,
    receiver,
    deadline
]);

const path = [
    WBNB_ADDRESS,   // Start: BNB
    BUSD_ADDRESS,   // Intermediate: BUSD
    USDC_ADDRESS    // End: USDC
];

const swapCalldata = router.interface.encodeFunctionData(
    'swapExactETHForTokens',
    [minAmountOut, path, receiver, deadline]
);