통합 가이드

import { ethers } from 'ethers';

// 컨트랙트 주소 (예시 - contract-addresses 페이지에서 확인)
const DIAMOND_ADDRESS = "0x...";  // 네트워크별

// 통합 ABI (모든 facet 포함)
const TED_ABI = [
    // IFXSwap
    "function swap(address tokenIn, address tokenOut, uint256 amountIn, uint256 minAmountOut, uint256 deadline) returns (uint256)",
    "function getQuote(address tokenIn, address tokenOut, uint256 amountIn) view returns (tuple(uint256 amountOut, uint256 priceImpact, address[] route, uint256 gasEstimate))",

    // ICrossChainSwap
    "function crossChainSwap(tuple(address tokenIn, address tokenOut, uint256 amountIn, uint256 minAmountOut, uint32 srcChainId, uint32 dstChainId, address recipient, uint256 deadline, bytes bridgeOptions)) payable returns (bytes32)",
    "function estimateFees(tuple(address tokenIn, address tokenOut, uint256 amountIn, uint256 minAmountOut, uint32 srcChainId, uint32 dstChainId, address recipient, uint256 deadline, bytes bridgeOptions)) view returns (uint256, uint256)",

    // Events
    "event Swap(address indexed sender, address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOut, address dex)",
    "event CrossChainSwapInitiated(bytes32 indexed messageId, address indexed sender, uint32 srcChainId, uint32 dstChainId, address tokenIn, address tokenOut, uint256 amountIn)"
];

// 초기화
const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();
const tedProtocol = new ethers.Contract(DIAMOND_ADDRESS, TED_ABI, signer);

async function executeSwap(tokenIn, tokenOut, amountIn, slippageBps = 50) {
    // 1. 토큰 승인 (아직 승인되지 않은 경우)
    const tokenContract = new ethers.Contract(tokenIn, ERC20_ABI, signer);
    const allowance = await tokenContract.allowance(userAddress, DIAMOND_ADDRESS);

    if (allowance < amountIn) {
        const approveTx = await tokenContract.approve(DIAMOND_ADDRESS, amountIn);
        await approveTx.wait();
    }

    // 2. 견적 조회
    const quote = await tedProtocol.getQuote(tokenIn, tokenOut, amountIn);

    // 3. 슬리피지 적용 최소 출력 계산
    const minAmountOut = quote.amountOut * (10000n - BigInt(slippageBps)) / 10000n;

    // 4. 스왑 실행
    const deadline = Math.floor(Date.now() / 1000) + 600; // 10분

    const tx = await tedProtocol.swap(
        tokenIn,
        tokenOut,
        amountIn,
        minAmountOut,
        deadline
    );

    const receipt = await tx.wait();

    // 5. 확인을 위한 이벤트 파싱
    const swapEvent = receipt.logs.find(log => {
        try {
            return tedProtocol.interface.parseLog(log)?.name === 'Swap';
        } catch { return false; }
    });

    if (swapEvent) {
        const parsed = tedProtocol.interface.parseLog(swapEvent);
        return {
            amountIn: parsed.args.amountIn,
            amountOut: parsed.args.amountOut,
            txHash: receipt.hash
        };
    }
}

async function executeCrossChainSwap(params) {
    const {
        tokenIn,
        tokenOut,
        amountIn,
        srcChainId,
        dstChainId,
        recipient,
        slippageBps = 100
    } = params;

    // 1. 토큰 승인
    const tokenContract = new ethers.Contract(tokenIn, ERC20_ABI, signer);
    const approveTx = await tokenContract.approve(DIAMOND_ADDRESS, amountIn);
    await approveTx.wait();

    // 2. 수수료 추정
    const crossChainParams = {
        tokenIn,
        tokenOut,
        amountIn,
        minAmountOut: 0n,  // 견적 후 계산
        srcChainId,
        dstChainId,
        recipient,
        deadline: Math.floor(Date.now() / 1000) + 3600,
        bridgeOptions: "0x"
    };

    const [nativeFee, bridgeFee] = await tedProtocol.estimateFees(crossChainParams);

    // 3. 예상 출력 조회 및 최소값 설정
    const quote = await tedProtocol.getQuote(tokenIn, tokenOut, amountIn);
    crossChainParams.minAmountOut = quote.amountOut * (10000n - BigInt(slippageBps)) / 10000n;

    // 4. 크로스체인 스왑 실행
    const tx = await tedProtocol.crossChainSwap(crossChainParams, {
        value: nativeFee
    });

    const receipt = await tx.wait();

    // 5. 추적을 위한 메시지 ID 조회
    const event = receipt.logs.find(log => {
        try {
            return tedProtocol.interface.parseLog(log)?.name === 'CrossChainSwapInitiated';
        } catch { return false; }
    });

    if (event) {
        const parsed = tedProtocol.interface.parseLog(event);
        return {
            messageId: parsed.args.messageId,
            txHash: receipt.hash
        };
    }
}

async function trackTransfer(messageId) {
    const response = await fetch(
        `https://api.layerzeroscan.com/tx/${messageId}`
    );
    const data = await response.json();

    return {
        status: data.status,  // 'INFLIGHT', 'DELIVERED', 'FAILED'
        srcTxHash: data.srcTxHash,
        dstTxHash: data.dstTxHash
    };
}

async function approveToken(tokenAddress, amount) {
    const token = new ethers.Contract(tokenAddress, ERC20_ABI, signer);
    const tx = await token.approve(DIAMOND_ADDRESS, amount);
    await tx.wait();
}

async function safeSwap(tokenIn, tokenOut, amountIn) {
    try {
        // 먼저 시뮬레이션
        await tedProtocol.swap.staticCall(
            tokenIn,
            tokenOut,
            amountIn,
            0n,  // 문제가 있으면 실패
            Math.floor(Date.now() / 1000) + 600
        );

        // 시뮬레이션 통과하면 실행
        return await executeSwap(tokenIn, tokenOut, amountIn);

    } catch (error) {
        // 커스텀 에러 파싱
        if (error.data) {
            const iface = new ethers.Interface([
                "error InsufficientOutput(uint256 expected, uint256 actual)",
                "error DeadlineExpired(uint256 deadline, uint256 timestamp)",
                "error UnsupportedToken(address token)",
                "error ProtocolPaused()"
            ]);

            try {
                const decoded = iface.parseError(error.data);
                console.error(`Error: ${decoded.name}`, decoded.args);
            } catch {
                console.error("Unknown error:", error);
            }
        }
        throw error;
    }
}

async function ensureCorrectNetwork(requiredChainId) {
    const currentChainId = await provider.getNetwork().then(n => n.chainId);

    if (currentChainId !== requiredChainId) {
        await window.ethereum.request({
            method: 'wallet_switchEthereumChain',
            params: [{ chainId: ethers.toQuantity(requiredChainId) }]
        });
    }
}