代币交换
代币交换是JAMM DEX的核心功能，允许用户在不同ERC-20代币之间进行无需许可的交易。本指南详细介绍如何使用JAMM DEX进行各种类型的代币交换，包括精确输入、精确输出以及涉及JU代币的交换。
交换类型
精确输入交换 (Exact Input)
用户指定确切的输入数量，系统计算输出数量。
// swapExactTokensForTokens
const amountIn = ethers.utils.parseEther("1.0"); // Exact input 1 TokenA
const amountOutMin = ethers.utils.parseEther("0.95"); // Minimum 0.95 TokenB
const path = [tokenA_address, tokenB_address];
const fees = [100]; // 1% fee rate
const to = userAddress;
const referrer = ethers.constants.AddressZero;
const deadline = Math.floor(Date.now() / 1000) + 60 * 20; // Expires in 20 minutes
const tx = await router.swapExactTokensForTokens(
amountIn,
amountOutMin,
path,
fees,
to,
referrer,
deadline
);精确输出交换 (Exact Output)
用户指定确切的输出数量，系统计算所需输入数量。
// swapTokensForExactTokens
const amountOut = ethers.utils.parseEther("1.0"); // Exact output 1 TokenB
const amountInMax = ethers.utils.parseEther("1.1"); // Maximum pay 1.1 TokenA
const path = [tokenA_address, tokenB_address];
const fees = [100]; // 1% fee rate
const tx = await router.swapTokensForExactTokens(
amountOut,
amountInMax,
path,
fees,
to,
referrer,
deadline
);JU代币交换
用JU购买代币
// swapExactETHForTokens - Use exact amount of JU to buy tokens
const amountOutMin = ethers.utils.parseEther("95"); // Minimum 95 tokens
const path = [WJU_address, token_address]; // Path must start with WJU
const fees = [100]; // 1% fee rate
const tx = await router.swapExactETHForTokens(
amountOutMin,
path,
fees,
to,
referrer,
deadline,
{ value: ethers.utils.parseEther("1.0") } // Send 1 JU
);用JU购买精确数量代币
// swapETHForExactTokens - Use JU to buy exact amount of tokens
const amountOut = ethers.utils.parseEther("100"); // Exact output 100 tokens
const path = [WJU_address, token_address];
const fees = [100];
// First calculate how much JU is needed
const amounts = await router.getAmountsIn(amountOut, path, fees);
const juNeeded = amounts[0];
const tx = await router.swapETHForExactTokens(
amountOut,
path,
fees,
to,
referrer,
deadline,
{ value: juNeeded.mul(110).div(100) } // Send 10% extra to prevent price changes
);卖出代币换JU
// swapExactTokensForETH - Sell exact amount of tokens for JU
const amountIn = ethers.utils.parseEther("100"); // Sell 100 tokens
const amountOutMin = ethers.utils.parseEther("0.9"); // Minimum 0.9 JU
const path = [token_address, WJU_address]; // Path must end with WJU
const fees = [100];
const tx = await router.swapExactTokensForETH(
amountIn,
amountOutMin,
path,
fees,
to,
referrer,
deadline
);卖出代币换精确数量JU
// swapTokensForExactETH - Sell tokens for exact amount of JU
const amountOut = ethers.utils.parseEther("1.0"); // Exact output 1 JU
const amountInMax = ethers.utils.parseEther("110"); // Maximum sell 110 tokens
const path = [token_address, WJU_address];
const fees = [100];
const tx = await router.swapTokensForExactETH(
amountOut,
amountInMax,
path,
fees,
to,
referrer,
deadline
);交换前准备
1. 代币授权
在进行代币交换前，需要授权Router合约使用您的代币：
const tokenContract = new ethers.Contract(tokenAddress, erc20ABI, signer);
// Check current allowance
const currentAllowance = await tokenContract.allowance(userAddress, routerAddress);
const requiredAmount = ethers.utils.parseEther("100");
if (currentAllowance.lt(requiredAmount)) {
// Approve Router to use tokens
const approveTx = await tokenContract.approve(routerAddress, requiredAmount);
await approveTx.wait();
console.log("Approval successful");
}2. 价格查询
在交换前查询预期的输出数量：
// 查询精确输入的输出数量
const amountIn = ethers.utils.parseEther("1");
const path = [tokenA, tokenB];
const fees = [100];
const amounts = await router.getAmountsOut(amountIn, path, fees);
const expectedOutput = amounts[amounts.length - 1];
console.log("预期输出:", ethers.utils.formatEther(expectedOutput));
// 查询精确输出需要的输入数量
const amountOut = ethers.utils.parseEther("1");
const amountsIn = await router.getAmountsIn(amountOut, path, fees);
const requiredInput = amountsIn[0];
console.log("需要输入:", ethers.utils.formatEther(requiredInput));3. 滑点设置
根据市场波动设置合理的滑点保护：
function calculateMinOutput(expectedOutput, slippagePercent) {
const slippage = ethers.BigNumber.from(slippagePercent * 100); // 转换为基点
const minOutput = expectedOutput.mul(10000 - slippage).div(10000);
return minOutput;
}
// 设置1%滑点
const expectedOutput = ethers.utils.parseEther("99");
const minOutput = calculateMinOutput(expectedOutput, 1); // 1%滑点
console.log("最小输出:", ethers.utils.formatEther(minOutput));完整交换示例
基础代币交换
async function swapTokens(
tokenIn,
tokenOut,
amountIn,
slippagePercent,
userAddress,
signer
) {
const router = new ethers.Contract(ROUTER_ADDRESS, routerABI, signer);
try {
// 1. 检查和授权
const tokenInContract = new ethers.Contract(tokenIn, erc20ABI, signer);
const allowance = await tokenInContract.allowance(userAddress, ROUTER_ADDRESS);
if (allowance.lt(amountIn)) {
console.log("授权代币...");
const approveTx = await tokenInContract.approve(ROUTER_ADDRESS, amountIn);
await approveTx.wait();
}
// 2. 查询价格
const path = [tokenIn, tokenOut];
const fees = [100]; // 假设使用1%费率
const amounts = await router.getAmountsOut(amountIn, path, fees);
const expectedOutput = amounts[1];
// 3. 计算最小输出（滑点保护）
const minOutput = expectedOutput.mul(10000 - slippagePercent * 100).div(10000);
// 4. 执行交换
const deadline = Math.floor(Date.now() / 1000) + 60 * 20;
const tx = await router.swapExactTokensForTokens(
amountIn,
minOutput,
path,
fees,
userAddress,
ethers.constants.AddressZero, // 无推荐人
deadline
);
console.log("交换交易已发送:", tx.hash);
const receipt = await tx.wait();
console.log("交换成功，区块:", receipt.blockNumber);
return receipt;
} catch (error) {
console.error("交换失败:", error.message);
throw error;
}
}
// 使用示例
await swapTokens(
"0xTokenA_Address",
"0xTokenB_Address",
ethers.utils.parseEther("10"), // 交换10个TokenA
1, // 1%滑点
await signer.getAddress(),
signer
);JU代币交换示例
async function swapJUForTokens(
tokenOut,
juAmount,
slippagePercent,
userAddress,
signer
) {
const router = new ethers.Contract(ROUTER_ADDRESS, routerABI, signer);
try {
// 1. 查询价格
const path = [WJU_ADDRESS, tokenOut];
const fees = [100];
const amounts = await router.getAmountsOut(juAmount, path, fees);
const expectedOutput = amounts[1];
// 2. 计算最小输出
const minOutput = expectedOutput.mul(10000 - slippagePercent * 100).div(10000);
// 3. 执行交换
const deadline = Math.floor(Date.now() / 1000) + 60 * 20;
const tx = await router.swapExactETHForTokens(
minOutput,
path,
fees,
userAddress,
ethers.constants.AddressZero,
deadline,
{ value: juAmount }
);
console.log("JU交换交易已发送:", tx.hash);
const receipt = await tx.wait();
console.log("交换成功");
return receipt;
} catch (error) {
console.error("JU交换失败:", error.message);
throw error;
}
}高级功能
推荐人系统
使用推荐人可以获得费用优惠：
// 设置推荐人
const factory = new ethers.Contract(FACTORY_ADDRESS, factoryABI, signer);
const referrerAddress = "0xReferrer_Address";
// 检查是否已有推荐人
const currentReferrer = await factory.referrer(userAddress);
if (currentReferrer === ethers.constants.AddressZero) {
const setReferrerTx = await factory.setReferrer(referrerAddress);
await setReferrerTx.wait();
}
// 在交换时使用推荐人
const tx = await router.swapExactTokensForTokens(
amountIn,
amountOutMin,
path,
fees,
to,
referrerAddress, // 使用推荐人
deadline
);批量交换
async function batchSwap(swapParams, signer) {
const results = [];
for (const params of swapParams) {
try {
const result = await swapTokens(
params.tokenIn,
params.tokenOut,
params.amountIn,
params.slippage,
params.userAddress,
signer
);
results.push({ success: true, result });
} catch (error) {
results.push({ success: false, error: error.message });
}
}
return results;
}错误处理
常见错误及解决方案
function handleSwapError(error) {
const errorMessage = error.message || error.toString();
if (errorMessage.includes("INSUFFICIENT_OUTPUT_AMOUNT")) {
return {
type: "SLIPPAGE_TOO_HIGH",
message: "滑点过大，请增加滑点容忍度或稍后重试",
solution: "增加滑点设置或等待市场稳定"
};
}
if (errorMessage.includes("EXPIRED")) {
return {
type: "TRANSACTION_EXPIRED",
message: "交易已过期",
solution: "重新发起交易"
};
}
if (errorMessage.includes("INSUFFICIENT_ALLOWANCE")) {
return {
type: "INSUFFICIENT_ALLOWANCE",
message: "代币授权不足",
solution: "增加代币授权额度"
};
}
if (errorMessage.includes("INSUFFICIENT_BALANCE")) {
return {
type: "INSUFFICIENT_BALANCE",
message: "余额不足",
solution: "检查账户余额"
};
}
return {
type: "UNKNOWN_ERROR",
message: "未知错误: " + errorMessage,
solution: "请联系技术支持"
};
}
// 使用示例
try {
await swapTokens(...);
} catch (error) {
const errorInfo = handleSwapError(error);
console.error("交换失败:", errorInfo.message);
console.log("解决方案:", errorInfo.solution);
}最佳实践
1. 交换前检查
async function preSwapChecks(tokenIn, tokenOut, amountIn, userAddress) {
const checks = {
tokenBalance: false,
tokenAllowance: false,
pairExists: false,
sufficientLiquidity: false
};
// 检查代币余额
const tokenContract = new ethers.Contract(tokenIn, erc20ABI, provider);
const balance = await tokenContract.balanceOf(userAddress);
checks.tokenBalance = balance.gte(amountIn);
// 检查授权额度
const allowance = await tokenContract.allowance(userAddress, ROUTER_ADDRESS);
checks.tokenAllowance = allowance.gte(amountIn);
// 检查交易对是否存在
const factory = new ethers.Contract(FACTORY_ADDRESS, factoryABI, provider);
const pairAddress = await factory.getPair(tokenIn, tokenOut, 100);
checks.pairExists = pairAddress !== ethers.constants.AddressZero;
if (checks.pairExists) {
// 检查流动性
const pair = new ethers.Contract(pairAddress, pairABI, provider);
const reserves = await pair.getReserves();
checks.sufficientLiquidity = reserves.reserve0.gt(0) && reserves.reserve1.gt(0);
}
return checks;
}2. 价格影响计算
function calculatePriceImpact(amountIn, reserveIn, reserveOut) {
// 理论价格（无价格影响）
const theoreticalPrice = reserveOut.mul(ethers.utils.parseEther("1")).div(reserveIn);
// 实际输出数量
const actualOutput = getAmountOut(amountIn, reserveIn, reserveOut, 100);
// 实际价格
const actualPrice = actualOutput.mul(ethers.utils.parseEther("1")).div(amountIn);
// 价格影响 = (理论价格 - 实际价格) / 理论价格
const priceImpact = theoreticalPrice.sub(actualPrice).mul(10000).div(theoreticalPrice);
return priceImpact; // 返回基点（100 = 1%）
}3. 动态滑点设置
function calculateDynamicSlippage(priceImpact, baseSlippage = 50) {
// 基础滑点50基点(0.5%)
// 根据价格影响动态调整
if (priceImpact.lt(100)) { // 小于1%
return baseSlippage;
} else if (priceImpact.lt(300)) { // 1-3%
return baseSlippage + 50; // 增加0.5%
} else { // 大于3%
return baseSlippage + 100; // 增加1%
}
}监控和分析
交换事件监听
// 监听交换事件
const pair = new ethers.Contract(pairAddress, pairABI, provider);
pair.on("Swap", (sender, amount0In, amount1In, amount0Out, amount1Out, to) => {
console.log("交换事件:", {
sender,
amount0In: ethers.utils.formatEther(amount0In),
amount1In: ethers.utils.formatEther(amount1In),
amount0Out: ethers.utils.formatEther(amount0Out),
amount1Out: ethers.utils.formatEther(amount1Out),
to
});
});交换历史查询
async function getSwapHistory(userAddress, fromBlock = 0) {
const router = new ethers.Contract(ROUTER_ADDRESS, routerABI, provider);
// 查询用户的交换历史
const filter = {
address: ROUTER_ADDRESS,
fromBlock: fromBlock,
toBlock: 'latest'
};
const logs = await provider.getLogs(filter);
const swapEvents = logs.filter(log =>
log.topics[0] === ethers.utils.id("Swap(address,uint256,uint256,uint256,uint256,address)")
);
return swapEvents.map(event => {
const decoded = router.interface.parseLog(event);
return {
blockNumber: event.blockNumber,
transactionHash: event.transactionHash,
...decoded.args
};
});
}Last updated