精确数量交换
JAMM DEX支持两种精确数量交换模式：精确输入（Exact Input）和精确输出（Exact Output）。这两种模式满足不同的交易需求，让用户能够精确控制交换的输入或输出数量。
精确输入交换 (Exact Input)
基本概念
精确输入交换允许用户指定确切的输入数量，系统计算并返回相应的输出数量。这是最常用的交换模式。
特点：
用户确切知道要支付多少代币
输出数量根据当前市场价格计算
需要设置最小输出数量作为滑点保护
实现方式
代币到代币的精确输入
async function swapExactTokensForTokens(
tokenIn,
tokenOut,
amountIn,
slippagePercent,
userAddress,
signer
) {
const router = new ethers.Contract(ROUTER_ADDRESS, routerABI, signer);
// 1. 查询预期输出
const path = [tokenIn, tokenOut];
const fees = [100]; // 1%费率
const amounts = await router.getAmountsOut(amountIn, path, fees);
const expectedOutput = amounts[1];
// 2. 计算最小输出（滑点保护）
const slippageBps = Math.floor(slippagePercent * 100); // 转换为基点
const amountOutMin = expectedOutput.mul(10000 - slippageBps).div(10000);
// 3. 设置截止时间
const deadline = Math.floor(Date.now() / 1000) + 60 * 20; // 20分钟
// 4. 执行交换
const tx = await router.swapExactTokensForTokens(
amountIn,
amountOutMin,
path,
fees,
userAddress,
ethers.constants.AddressZero, // 无推荐人
deadline
);
console.log("精确输入交换已提交:", tx.hash);
const receipt = await tx.wait();
return {
transactionHash: tx.hash,
blockNumber: receipt.blockNumber,
expectedOutput,
actualOutput: await getActualOutput(receipt) // 从事件中解析实际输出
};
}JU到代币的精确输入
async function swapExactJUForTokens(
tokenOut,
juAmount,
slippagePercent,
userAddress,
signer
) {
const router = new ethers.Contract(ROUTER_ADDRESS, routerABI, signer);
const path = [WJU_ADDRESS, tokenOut];
const fees = [100];
// 查询预期输出
const amounts = await router.getAmountsOut(juAmount, path, fees);
const expectedOutput = amounts[1];
// 计算最小输出
const slippageBps = Math.floor(slippagePercent * 100);
const amountOutMin = expectedOutput.mul(10000 - slippageBps).div(10000);
const deadline = Math.floor(Date.now() / 1000) + 60 * 20;
const tx = await router.swapExactETHForTokens(
amountOutMin,
path,
fees,
userAddress,
ethers.constants.AddressZero,
deadline,
{ value: juAmount } // 发送JU
);
return tx;
}
// 使用示例
await swapExactJUForTokens(
TOKEN_ADDRESS,
ethers.utils.parseEther("1.0"), // 精确输入1个JU
1, // 1%滑点
userAddress,
signer
);代币到JU的精确输入
async function swapExactTokensForJU(
tokenIn,
amountIn,
slippagePercent,
userAddress,
signer
) {
const router = new ethers.Contract(ROUTER_ADDRESS, routerABI, signer);
const path = [tokenIn, WJU_ADDRESS];
const fees = [100];
const amounts = await router.getAmountsOut(amountIn, path, fees);
const expectedOutput = amounts[1];
const slippageBps = Math.floor(slippagePercent * 100);
const amountOutMin = expectedOutput.mul(10000 - slippageBps).div(10000);
const deadline = Math.floor(Date.now() / 1000) + 60 * 20;
const tx = await router.swapExactTokensForETH(
amountIn,
amountOutMin,
path,
fees,
userAddress,
ethers.constants.AddressZero,
deadline
);
return tx;
}精确输出交换 (Exact Output)
基本概念
精确输出交换允许用户指定确切的输出数量，系统计算并要求相应的输入数量。这种模式适合需要获得精确数量代币的场景。
特点：
用户确切知道要获得多少代币
输入数量根据当前市场价格计算
需要设置最大输入数量作为滑点保护
实现方式
代币到代币的精确输出
async function swapTokensForExactTokens(
tokenIn,
tokenOut,
amountOut,
slippagePercent,
userAddress,
signer
) {
const router = new ethers.Contract(ROUTER_ADDRESS, routerABI, signer);
// 1. 查询所需输入
const path = [tokenIn, tokenOut];
const fees = [100];
const amounts = await router.getAmountsIn(amountOut, path, fees);
const requiredInput = amounts[0];
// 2. 计算最大输入（滑点保护）
const slippageBps = Math.floor(slippagePercent * 100);
const amountInMax = requiredInput.mul(10000 + slippageBps).div(10000);
// 3. 检查用户余额
const tokenContract = new ethers.Contract(tokenIn, erc20ABI, signer);
const userBalance = await tokenContract.balanceOf(userAddress);
if (userBalance.lt(amountInMax)) {
throw new Error(`余额不足。需要: ${ethers.utils.formatEther(amountInMax)}, 拥有: ${ethers.utils.formatEther(userBalance)}`);
}
// 4. 检查授权
const allowance = await tokenContract.allowance(userAddress, ROUTER_ADDRESS);
if (allowance.lt(amountInMax)) {
console.log("需要增加授权...");
const approveTx = await tokenContract.approve(ROUTER_ADDRESS, amountInMax);
await approveTx.wait();
}
const deadline = Math.floor(Date.now() / 1000) + 60 * 20;
// 5. 执行交换
const tx = await router.swapTokensForExactTokens(
amountOut,
amountInMax,
path,
fees,
userAddress,
ethers.constants.AddressZero,
deadline
);
console.log("精确输出交换已提交:", tx.hash);
const receipt = await tx.wait();
return {
transactionHash: tx.hash,
blockNumber: receipt.blockNumber,
requiredInput,
actualInput: await getActualInput(receipt) // 从事件中解析实际输入
};
}JU到代币的精确输出
async function swapJUForExactTokens(
tokenOut,
amountOut,
slippagePercent,
userAddress,
signer
) {
const router = new ethers.Contract(ROUTER_ADDRESS, routerABI, signer);
const path = [WJU_ADDRESS, tokenOut];
const fees = [100];
// 查询所需JU数量
const amounts = await router.getAmountsIn(amountOut, path, fees);
const requiredJU = amounts[0];
// 计算最大JU输入（包含滑点）
const slippageBps = Math.floor(slippagePercent * 100);
const maxJUInput = requiredJU.mul(10000 + slippageBps).div(10000);
// 检查JU余额
const juBalance = await signer.getBalance();
if (juBalance.lt(maxJUInput)) {
throw new Error(`JU余额不足。需要: ${ethers.utils.formatEther(maxJUInput)}, 拥有: ${ethers.utils.formatEther(juBalance)}`);
}
const deadline = Math.floor(Date.now() / 1000) + 60 * 20;
const tx = await router.swapETHForExactTokens(
amountOut,
path,
fees,
userAddress,
ethers.constants.AddressZero,
deadline,
{ value: maxJUInput } // 发送最大JU数量
);
return tx;
}
// 使用示例
await swapJUForExactTokens(
TOKEN_ADDRESS,
ethers.utils.parseEther("100"), // 精确获得100个代币
2, // 2%滑点
userAddress,
signer
);代币到JU的精确输出
async function swapTokensForExactJU(
tokenIn,
juAmountOut,
slippagePercent,
userAddress,
signer
) {
const router = new ethers.Contract(ROUTER_ADDRESS, routerABI, signer);
const path = [tokenIn, WJU_ADDRESS];
const fees = [100];
const amounts = await router.getAmountsIn(juAmountOut, path, fees);
const requiredInput = amounts[0];
const slippageBps = Math.floor(slippagePercent * 100);
const amountInMax = requiredInput.mul(10000 + slippageBps).div(10000);
const deadline = Math.floor(Date.now() / 1000) + 60 * 20;
const tx = await router.swapTokensForExactETH(
juAmountOut,
amountInMax,
path,
fees,
userAddress,
ethers.constants.AddressZero,
deadline
);
return tx;
}高级功能
多跳精确交换
async function multiHopExactInput(
path,
fees,
amountIn,
slippagePercent,
userAddress,
signer
) {
const router = new ethers.Contract(ROUTER_ADDRESS, routerABI, signer);
// 验证路径和费率数组
if (path.length - fees.length !== 1) {
throw new Error("路径和费率数组长度不匹配");
}
// 计算多跳输出
const amounts = await router.getAmountsOut(amountIn, path, fees);
const expectedOutput = amounts[amounts.length - 1];
const slippageBps = Math.floor(slippagePercent * 100);
const amountOutMin = expectedOutput.mul(10000 - slippageBps).div(10000);
const deadline = Math.floor(Date.now() / 1000) + 60 * 20;
const tx = await router.swapExactTokensForTokens(
amountIn,
amountOutMin,
path,
fees,
userAddress,
ethers.constants.AddressZero,
deadline
);
return tx;
}
async function multiHopExactOutput(
path,
fees,
amountOut,
slippagePercent,
userAddress,
signer
) {
const router = new ethers.Contract(ROUTER_ADDRESS, routerABI, signer);
// 计算多跳输入
const amounts = await router.getAmountsIn(amountOut, path, fees);
const requiredInput = amounts[0];
const slippageBps = Math.floor(slippagePercent * 100);
const amountInMax = requiredInput.mul(10000 + slippageBps).div(10000);
const deadline = Math.floor(Date.now() / 1000) + 60 * 20;
const tx = await router.swapTokensForExactTokens(
amountOut,
amountInMax,
path,
fees,
userAddress,
ethers.constants.AddressZero,
deadline
);
return tx;
}
// 使用示例：USDC → WJU → TokenX
const path = [USDC_ADDRESS, WJU_ADDRESS, TOKENX_ADDRESS];
const fees = [50, 100]; // 0.5%和1%费率
// 精确输入100 USDC
await multiHopExactInput(
path,
fees,
ethers.utils.parseUnits("100", 6), // 100 USDC
1, // 1%滑点
userAddress,
signer
);
// 精确输出100 TokenX
await multiHopExactOutput(
path,
fees,
ethers.utils.parseEther("100"), // 100 TokenX
2, // 2%滑点
userAddress,
signer
);批量精确交换
class BatchExactSwapper {
constructor(routerAddress, signer) {
this.router = new ethers.Contract(routerAddress, routerABI, signer);
this.signer = signer;
}
async batchExactInput(swaps) {
const results = [];
for (const swap of swaps) {
try {
const result = await this.executeExactInput(swap);
results.push({ success: true, ...result });
} catch (error) {
results.push({
success: false,
error: error.message,
swap: swap
});
}
}
return results;
}
async executeExactInput(swap) {
const { tokenIn, tokenOut, amountIn, slippage } = swap;
const path = [tokenIn, tokenOut];
const fees = [100];
const amounts = await this.router.getAmountsOut(amountIn, path, fees);
const expectedOutput = amounts[1];
const slippageBps = Math.floor(slippage * 100);
const amountOutMin = expectedOutput.mul(10000 - slippageBps).div(10000);
const deadline = Math.floor(Date.now() / 1000) + 60 * 20;
const tx = await this.router.swapExactTokensForTokens(
amountIn,
amountOutMin,
path,
fees,
await this.signer.getAddress(),
ethers.constants.AddressZero,
deadline
);
return {
transactionHash: tx.hash,
expectedOutput,
path,
fees
};
}
}
// 使用示例
const batchSwapper = new BatchExactSwapper(ROUTER_ADDRESS, signer);
const swaps = [
{
tokenIn: TOKEN_A_ADDRESS,
tokenOut: TOKEN_B_ADDRESS,
amountIn: ethers.utils.parseEther("10"),
slippage: 1
},
{
tokenIn: TOKEN_C_ADDRESS,
tokenOut: TOKEN_D_ADDRESS,
amountIn: ethers.utils.parseEther("5"),
slippage: 1.5
}
];
const results = await batchSwapper.batchExactInput(swaps);
console.log("批量交换结果:", results);价格计算和预览
精确输入价格预览
async function previewExactInput(tokenIn, tokenOut, amountIn) {
const router = new ethers.Contract(ROUTER_ADDRESS, routerABI, provider);
const path = [tokenIn, tokenOut];
const fees = [100];
try {
const amounts = await router.getAmountsOut(amountIn, path, fees);
const outputAmount = amounts[1];
// 计算价格
const price = outputAmount.mul(ethers.utils.parseEther("1")).div(amountIn);
// 计算价格影响
const pair = await getPairContract(tokenIn, tokenOut, fees[0]);
const reserves = await pair.getReserves();
const priceImpact = calculatePriceImpact(amountIn, reserves, tokenIn, tokenOut);
return {
inputAmount: amountIn,
outputAmount: outputAmount,
price: price,
priceImpact: priceImpact,
path: path,
fees: fees
};
} catch (error) {
throw new Error(`价格预览失败: ${error.message}`);
}
}精确输出价格预览
async function previewExactOutput(tokenIn, tokenOut, amountOut) {
const router = new ethers.Contract(ROUTER_ADDRESS, routerABI, provider);
const path = [tokenIn, tokenOut];
const fees = [100];
try {
const amounts = await router.getAmountsIn(amountOut, path, fees);
const inputAmount = amounts[0];
const price = amountOut.mul(ethers.utils.parseEther("1")).div(inputAmount);
const pair = await getPairContract(tokenIn, tokenOut, fees[0]);
const reserves = await pair.getReserves();
const priceImpact = calculatePriceImpact(inputAmount, reserves, tokenIn, tokenOut);
return {
inputAmount: inputAmount,
outputAmount: amountOut,
price: price,
priceImpact: priceImpact,
path: path,
fees: fees
};
} catch (error) {
throw new Error(`价格预览失败: ${error.message}`);
}
}价格影响计算
function calculatePriceImpact(amountIn, reserves, tokenIn, tokenOut) {
const [reserveIn, reserveOut] = tokenIn < tokenOut
? [reserves.reserve0, reserves.reserve1]
: [reserves.reserve1, reserves.reserve0];
// 交换前价格
const priceBefore = reserveOut.mul(ethers.utils.parseEther("1")).div(reserveIn);
// 模拟交换后的储备量
const amountInWithFee = amountIn.mul(9900); // 假设1%费率
const numerator = amountInWithFee.mul(reserveOut);
const denominator = reserveIn.mul(10000).add(amountInWithFee);
const amountOut = numerator.div(denominator);
const newReserveIn = reserveIn.add(amountIn);
const newReserveOut = reserveOut.sub(amountOut);
// 交换后价格
const priceAfter = newReserveOut.mul(ethers.utils.parseEther("1")).div(newReserveIn);
// 价格影响 = (交换前价格 - 交换后价格) / 交换前价格
const priceImpact = priceBefore.sub(priceAfter).mul(10000).div(priceBefore);
return priceImpact; // 返回基点
}实用工具函数
交换结果解析
async function parseSwapResult(transactionReceipt) {
const router = new ethers.Contract(ROUTER_ADDRESS, routerABI, provider);
const swapEvents = transactionReceipt.logs
.map(log => {
try {
return router.interface.parseLog(log);
} catch {
return null;
}
})
.filter(event => event && event.name === 'Swap');
if (swapEvents.length === 0) {
throw new Error("未找到交换事件");
}
// 解析第一个和最后一个交换事件
const firstSwap = swapEvents[0];
const lastSwap = swapEvents[swapEvents.length - 1];
return {
inputAmount: firstSwap.args.amount0In.gt(0) ? firstSwap.args.amount0In : firstSwap.args.amount1In,
outputAmount: lastSwap.args.amount0Out.gt(0) ? lastSwap.args.amount0Out : lastSwap.args.amount1Out,
swapCount: swapEvents.length,
gasUsed: transactionReceipt.gasUsed
};
}滑点计算器
class SlippageCalculator {
static calculateMinOutput(expectedOutput, slippagePercent) {
const slippageBps = Math.floor(slippagePercent * 100);
return expectedOutput.mul(10000 - slippageBps).div(10000);
}
static calculateMaxInput(requiredInput, slippagePercent) {
const slippageBps = Math.floor(slippagePercent * 100);
return requiredInput.mul(10000 + slippageBps).div(10000);
}
static calculateActualSlippage(expected, actual, isInput = false) {
if (isInput) {
// 对于输入，实际值应该小于等于预期值
if (actual.gt(expected)) {
return ethers.BigNumber.from(0); // 没有滑点，反而更好
}
return expected.sub(actual).mul(10000).div(expected);
} else {
// 对于输出，实际值应该大于等于预期值
if (actual.gt(expected)) {
return ethers.BigNumber.from(0); // 没有滑点，反而更好
}
return expected.sub(actual).mul(10000).div(expected);
}
}
}最佳实践
1. 交换模式选择
function chooseSwapMode(userIntent, marketConditions) {
if (userIntent.type === 'SPEND_EXACT') {
// 用户想花费确切数量的代币
return 'EXACT_INPUT';
} else if (userIntent.type === 'RECEIVE_EXACT') {
// 用户想获得确切数量的代币
return 'EXACT_OUTPUT';
} else if (marketConditions.volatility === 'HIGH') {
// 高波动市场，使用精确输入更安全
return 'EXACT_INPUT';
} else {
// 默认使用精确输入
return 'EXACT_INPUT';
}
}2. 动态滑点调整
function calculateDynamicSlippage(priceImpact, marketVolatility, tradeSize) {
let baseSlippage = 0.5; // 0.5%基础滑点
// 根据价格影响调整
if (priceImpact > 200) { // 大于2%
baseSlippage += 1.0;
} else if (priceImpact > 100) { // 大于1%
baseSlippage += 0.5;
}
// 根据市场波动调整
baseSlippage += marketVolatility * 0.5;
// 根据交易规模调整
if (tradeSize === 'LARGE') {
baseSlippage += 0.5;
}
return Math.min(baseSlippage, 5.0); // 最大5%滑点
}3. 交换前验证
async function validateSwap(swapParams) {
const validations = [];
// 验证代币地址
if (!ethers.utils.isAddress(swapParams.tokenIn) || !ethers.utils.isAddress(swapParams.tokenOut)) {
validations.push("无效的代币地址");
}
// 验证数量
if (swapParams.amount.lte(0)) {
validations.push("交换数量必须大于0");
}
// 验证滑点
if (swapParams.slippage < 0 || swapParams.slippage > 50) {
validations.push("滑点必须在0-50%之间");
}
// 验证截止时间
if (swapParams.deadline <= Math.floor(Date.now() / 1000)) {
validations.push("截止时间已过期");
}
// 验证交易对存在
const factory = new ethers.Contract(FACTORY_ADDRESS, factoryABI, provider);
const pairAddress = await factory.getPair(swapParams.tokenIn, swapParams.tokenOut, swapParams.fee);
if (pairAddress === ethers.constants.AddressZero) {
validations.push("交易对不存在");
}
return validations;
}Last updated