找回密码
立即注册
搜索
发回帖 发新帖

5783

积分

0

好友

742

主题
发表于 7 小时前 | 查看: 1| 回复: 0

概述

本文以 ACME/USDC 池为例,讲解如何在 Solana 上使用 Anchor 构建恒定乘积 AMM。内容覆盖:

  • 首次存款与初始价格设定
  • LP Token 份额计算
  • Swap 定价与手续费拆分
  • 管理员费用领取
  • LP 提现与无常损失
  • 有效储备、舍入规则和 K 值不变量
  • 空储备、通胀攻击、抢跑与滑点防护
  • 使用 LiteSVM 运行测试
  • 通过 Quicknode 部署到 Solana devnet

自动做市商(automated market maker,AMM)用数学公式取代传统做市商。

  • 流动性提供者(Liquidity Providers,LP)向池子存入两种 Token,并获得代表池中份额的 LP Token。
  • 任何人都可以用一种 Token 兑换另一种 Token,价格由池中两种 Token 的余额决定。
  • 每笔交易都会支付费用。大部分费用留在池中归 LP,剩余部分归 AMM 管理员。
  • 这些费用用于补偿 LP 承担的无常损失,也就是价格变化后,提供流动性所得价值相对于单纯持有两种 Token 的差额。

Orca 和 Raydium 是 Solana 上常见的 AMM。构建一个 AMM,可以清晰展示链上程序如何为交易定价、跟踪池中份额、拆分费用,并在整数舍入时保护池子。

本文跟随 Quicknode solana-program-examples 仓库中 finance/token-swap/anchor-v1 目录的 Anchor 1 版本。同一目录还包含 Anchor 2(anchor)和 Quasar(quasar)版本。

TL;DR

  • AMM 允许用户随时交易两种 Token,价格由池中余额决定,而不是由做市商报价。
  • LP 存入两种 Token,并获得每笔交易费用的大部分。
  • 程序会保护小型池和空池,防止已知攻击。
  • 只要价格发生变化,LP 通常会落后于单纯持有 Token;只有当费用收入超过这部分差额时,提供流动性才更有利。
  • 本文使用 Anchor 构建程序,使用 LiteSVM 测试,并通过 Quicknode endpoint 部署到 Solana devnet。

你将完成什么

本文会跟随一次 Token 发行穿过恒定乘积池:

  • 从创建池子开始,到最后一次流动性提取结束;
  • 分析程序如何为 swap 定价;
  • 了解费用如何在 LP 和管理员之间拆分;
  • 观察每次交易后如何检查池子状态;
  • 计算无常损失,并与 LP 获得的费用比较;
  • 了解程序如何防御空储备耗尽、通胀攻击以及池创建时的抢跑;
  • 构建程序、运行 LiteSVM 测试,并将程序部署到 Solana devnet。

环境准备

开始前需要准备:

  • Rust
  • Solana CLI 3.1.8。该版本固定在程序的 Anchor.toml 中。
  • Anchor 1.2.1,以及用于安装指定版本的 Anchor Version Manager(AVM)
  • Surfpool。执行 anchor test 时,它会在测试前启动本地验证器。
  • 位于 ~/.config/solana/id.json 的 Solana 文件系统钱包。该钱包用于支付 devnet 部署费用,可以通过 solana-keygen new 创建。
  • 一个 Quicknode Solana devnet endpoint。
  • Solana accounts 和 PDA 的基础知识。PDA 是 Solana 程序中组织配置账户、池配置和金库权限的重要机制,相关内容也可参考 PDA。

本文使用的版本必须与项目配置保持一致,否则可能出现编译、测试或部署问题。

用 ACME/USDC 池观察一次 Token 发行

本文中的池子使用 ACME 和 USDC 交易。示例中有四个角色:

  • Maria:运行 AMM 并发行 ACME。她有 1 SOL、1,000 USDC 和 400 ACME。
  • Alice:添加流动性赚取费用。她有 1 SOL、1,000 USDC 和 100 ACME。
  • Bob:买入 ACME,随后卖出一部分。他有 1 SOL 和 1,000 USDC。
  • Carol:在 Bob 之后买入 ACME。她有 1 SOL 和 1,000 USDC。

Maria 会领取属于管理员的费用,Alice 最后提取流动性。

Constant-product AMM 如何为 Swap 定价

池子持有两种 Token,它们的余额称为储备。设:

  • $x$:Token A 储备,这里是 ACME;
  • $y$:Token B 储备,这里是 USDC;
  • $k$:两种储备的乘积。

恒定乘积 AMM 的核心关系是:

x * y = k

程序为交易定价时,会尽量保持有效储备的乘积不下降。

如果交易者向池子加入 Token B,并取出 Token A,程序会先从输入金额中扣除交易费用,再根据公式计算输出金额。输入 Token 越多,另一侧储备就越少,价格也会随之移动。

现货价格可以理解为两种储备的比值。买入 ACME 时,池子减少 ACME、增加 USDC,下一位买家就必须支付更高的价格。一次交易对价格造成的影响称为 price impact。相对于池子规模越大的交易,价格影响越明显。

有效储备会通过两种方式变化:

  • 流动性存入:按相同比例增加两种 Token。
  • LP 费用:交易费用中属于 LP 的部分留在金库中,增加有效储备。

管理员费用虽然也暂时留在金库中,但会通过计数器单独记录,并从 LP 数学中排除。流动性提取时,储备会按提取者在 LP 供应量中的份额缩小。

恒定乘积曲线上的三次买入:池中 USDC 增加,ACME 减少

创建 AMM 池并设定初始价格

Maria 运行 initialize_config(),设置:

  • fee:30 个基点;
  • admin_share_bps:1,667 个基点,约占每笔交易费用的六分之一。

随后,她为 ACME/USDC 运行 initialize_pool()。该指令会创建:

  • pool config;
  • LP mint;
  • 两个 Token vault;
  • 池子的首次存款。

Maria 认为初始价格应为每个 ACME 2.25 美元,因此存入:

  • 400 ACME;
  • 900 USDC。

全局 Config PDA

config account 位于以 "config" 为 seed 的 PDA。每个已部署程序只有一个 config,用于保存所有池共享的设置。

字段 用途
admin 收取管理员费用的地址,也是唯一可以领取费用的地址
fee 每次 swap 的交易费率,以基点计
admin_share_bps 每笔费用中归管理员的部分,以基点计
bump 推导 config 地址时使用的 bump seed

initialize_config() 会执行参数检查:

  • fee >= 10,000 时返回 InvalidFee;
  • admin_share_bps >= 10,000 时返回 AdminShareTooHigh。

Pool Config PDA

每个交易对有一个 pool config。它使用 config 和两个 mint 作为 seed,因此必须固定 Token 排序:

#[account(
    init,
    payer = payer,
    space = PoolConfig::DISCRIMINATOR.len() + PoolConfig::INIT_SPACE,
    seeds = [
        config.key().as_ref(),
        mint_a.key().as_ref(),
        mint_b.key().as_ref(),
    ],
    bump,
    constraint = mint_a.key() < mint_b.key() @ AmmError::InvalidMintOrder,
)]
pub pool_config: Box<Account<'info, PoolConfig>>,

要求 mint_a < mint_b,可以避免同时存在 (ACME, USDC) 和 (USDC, ACME) 两个池子,从而避免流动性被拆分。

在本文的池子中:

  • ACME 是 Token A;
  • USDC 是 Token B;
  • pool_a 和 pool_b 是两个 Token vault;
  • vault authority 是 pool config PDA;
  • LP mint 的 mint authority 也是同一个 PDA。

只有程序能够以该 PDA 签名,因此其他账户不能直接移动 vault 中的 Token,也不能任意铸造 LP Token。

有效储备

Pool config 还保存两个管理员费用计数器:

  • admin_fees_owed_a
  • admin_fees_owed_b

Swap 不会把管理员费用立即转出金库。费用仍然留在 vault 中,但计数器记录管理员的应得金额。

因此,LP 相关数学使用的是有效储备:

effective reserve = vault balance - admin fees owed

Pool config 的核心结构如下:

#[account]
#[derive(Default, InitSpace)]
pub struct PoolConfig {
    /// 此池所属父级 Config account 的地址。
    pub config: Pubkey,

    /// token A 的 Mint。
    pub mint_a: Pubkey,

    /// token B 的 Mint。
    pub mint_b: Pubkey,

    /// Admin 对 token A 累积的费用索取权。
    /// 这些 Token 实际位于 pool_a,但不参与 LP 曲线和 LP 可提取金额的计算。
    pub admin_fees_owed_a: u64,

    /// Admin 对 token B 累积的费用索取权。
    /// 这些 Token 实际位于 pool_b,但不参与 LP 曲线和 LP 可提取金额的计算。
    pub admin_fees_owed_b: u64,

    /// 此 PDA 的规范 bump。
    pub bump: u8,
}

首次存款如何设定价格

initialize_pool() 在创建池子的同一条 instruction 中接受首次存款,因此没有人可以先向空池存入 Token,再通过存款比例设定价格。

任意一侧为零都会返回 EmptyInitialDeposit,因此不会创建带有空 vault 的池子。

首次 LP Token 数量等于两种存款数量乘积的整数平方根,再减去 MINIMUM_LIQUIDITY:

initial LP amount = floor(sqrt(amount_a * amount_b)) - MINIMUM_LIQUIDITY

示例中:

sqrt(400 * 900) = 600

因此 Maria 获得 600 个 LP Token 减去 MINIMUM_LIQUIDITY。

initial_lp_amount() 使用 u128 执行乘法,并通过 integer_sqrt() 计算整数平方根:

pub fn initial_lp_amount(amount_a: u64, amount_b: u64) -> Result<u64> {
    let product = (amount_a as u128)
        .checked_mul(amount_b as u128)
        .ok_or(AmmError::MathOverflow)?;

    let sqrt_product = u64::try_from(integer_sqrt(product))
        .map_err(|_| AmmError::MathOverflow)?;

    if sqrt_product <= MINIMUM_LIQUIDITY {
        return err!(AmmError::DepositTooSmall);
    }

    sqrt_product
        .checked_sub(MINIMUM_LIQUIDITY)
        .ok_or_else(|| error!(AmmError::MathOverflow))
}

MINIMUM_LIQUIDITY 是 100 个最小单位的 LP 供应量,这些单位永远不会铸造给任何人。LP mint 有六位小数,因此这相当于 0.0001 个 LP Token,但对应的储备份额会永久留在池中。

该设计可以提高通胀攻击的成本。deposit_and_mint_lp_tokens() 会把 Token 转入 vault,并为 Maria 铸造 LP Token。后续存款也会使用相同的份额计算逻辑。

为什么添加流动性不会移动价格

Alice 想用手中的 ACME 赚取费用,因此成为第二个 LP。添加流动性不能改变池子的 Token 比例,所以她的 100 ACME 必须搭配 225 USDC。

deposit_liquidity() 会使用 clamp 保持比例。这里的 clamp 会根据当前有效储备,计算一组不超过 Alice 最大存款数量的 Token 金额。

如果 clamp 将某一侧向下舍入为零,存款会返回 DepositAmountTooSmall。如果请求存入的 Token 超过账户余额,则返回 InsufficientBalance。

LP Token 数量分别根据 Token A 和 Token B 的存款比例计算,取两者较小值并向下舍入,然后与 minimum_lp_tokens_out 比较:

let total_supply = (context.accounts.liquidity_provider_mint.supply as u128)
    .checked_add(MINIMUM_LIQUIDITY as u128)
    .ok_or(AmmError::MathOverflow)?;

let liquidity_from_a = (amount_a as u128)
    .checked_mul(total_supply)
    .ok_or(AmmError::MathOverflow)?
    .checked_div(effective_pool_a as u128)
    .ok_or(AmmError::MathOverflow)?;

let liquidity_from_b = (amount_b as u128)
    .checked_mul(total_supply)
    .ok_or(AmmError::MathOverflow)?
    .checked_div(effective_pool_b as u128)
    .ok_or(AmmError::MathOverflow)?;

let liquidity: u64 = u64::try_from(liquidity_from_a.min(liquidity_from_b))
    .map_err(|_| AmmError::MathOverflow)?;

Alice 的 100 ACME 是池中 400 ACME 的四分之一,因此她获得约四分之一的 LP 供应量,即 150 LP Token。

存款后:

  • ACME 储备为 500;
  • USDC 储备为 1,125;
  • 有效乘积为 562,500;
  • 价格仍然保持不变。

Swap 如何沿曲线移动价格

Bob 使用 100 USDC 购买 ACME。他调用 swap_tokens(),将 input_is_token_a 设为 false,并传入 min_output_amount 作为滑点保护。

一次 swap 主要经过三个阶段:

  1. 扣除费用;
  2. 根据有效储备计算输出;
  3. 转账后重新检查 K 值不变量。

先扣除交易费用

100 USDC 的 30 个基点费用为 0.30 USDC。

其中:

  • 约 0.05 USDC 计入管理员费用;
  • 约 0.25 USDC 留在池中,归 LP;
  • Bob 的计税输入金额为 99.70 USDC。

费用计算使用向上舍入:

let fee_amount = (input_amount as u128)
    .checked_mul(config.fee as u128)
    .ok_or(AmmError::MathOverflow)?
    .div_ceil(BASIS_POINTS_DIVISOR as u128);

let admin_portion = fee_amount
    .checked_mul(config.admin_share_bps as u128)
    .ok_or(AmmError::MathOverflow)?
    .div_ceil(BASIS_POINTS_DIVISOR as u128);

管理员部分会增加 admin_fees_owed_b,LP 部分则留在池中并增加有效储备。

根据曲线计算输出

程序先确定输入侧储备和输出侧储备:

let (this_reserve, other_reserve) = if input_is_token_a {
    (effective_pool_a, effective_pool_b)
} else {
    (effective_pool_b, effective_pool_a)
};

let numerator = (taxed_input as u128)
    .checked_mul(other_reserve as u128)
    .ok_or(AmmError::MathOverflow)?;

let denominator = (this_reserve as u128)
    .checked_add(taxed_input as u128)
    .ok_or(AmmError::MathOverflow)?;

let output_u128 = numerator
    .checked_div(denominator)
    .ok_or(AmmError::MathOverflow)?;

let output: u64 = u64::try_from(output_u128)
    .map_err(|_| AmmError::MathOverflow)?;

require!(
    output >= min_output_amount,
    AmmError::SlippageExceeded
);

Bob 的 100 USDC 中,只有扣除费用后的 99.70 USDC 用于曲线定价。vault 会收到完整的 100 USDC,Bob 得到约 40.7 ACME。

由于 Bob 自己的交易改变了池子比例,他实际支付的平均价格会高于交易前现货价格。

转账后再次检查 K 值

转账完成后,handler 会重新加载两个 vault 的余额,并计算新的有效乘积:

let new_invariant = (effective_pool_a_after as u128)
    .checked_mul(effective_pool_b_after as u128)
    .ok_or(AmmError::MathOverflow)?;

require!(
    new_invariant >= invariant,
    AmmError::InvariantViolated
);

这项检查是重要的防御措施。如果代码中的其他逻辑出现错误,导致程序向交易者多支付 Token,新的有效乘积可能下降,此时整个 swap 会失败。

有效乘积允许增长,因为:

  • LP 费用会增加储备;
  • 舍入产生的剩余最小单位会留在池中。

Bob 交易后,LP 费用中的 0.25 USDC 留在池内,使有效乘积略有增加。

为什么下一个买家支付更高价格

Carol 在 Bob 交易后用 50 USDC 买入 ACME。

她的交易费用为 0.15 USDC:

  • 约 0.025 USDC 归管理员;
  • 约 0.125 USDC 归 LP;
  • 计税输入约为 49.85 USDC。

Bob 的买入已经减少了池中的 ACME 储备,因此 Carol 使用同一公式时,只能获得约 18 个 ACME,平均成交价格也更高。

这就是恒定乘积 AMM 的价格影响:交易本身会改变下一笔交易的价格。

卖出时哪种 Token 支付费用

Bob 卖出持有的 40.7 ACME 中的 20 个。

卖出仍然调用 swap_tokens(),只是将 input_is_token_a 设为 true。此时费用从 ACME 输入中扣除:

  • 总费用约为 0.06 ACME;
  • 其中约 0.01 ACME 计入 admin_fees_owed_a;
  • 剩余部分归 LP。

曲线使用扣除费用后的约 19.94 ACME 计算输出,vault 收到完整的 20 ACME,另一侧 USDC 储备减少。

管理员的两个费用计数器现在都可能有余额。

AMM Admin 如何领取费用

Maria 可以随时调用:

claim_admin_fees()

该指令会:

  1. 将两个 admin_fees_owed_* 计数器清零;
  2. 由 pool config PDA 签名;
  3. 将管理员应得的两种 Token 从 vault 转入 Maria 的 Token account。

config account 上的 has_one = admin 约束会拒绝其他账户。测试 test_claim_admin_fees_rejects_non_admin 会验证这一点。

如果没有可领取费用,程序返回 NothingToClaim。无论积累了多少笔 swap,领取时每种 Token 最多执行一次转账。

提取流动性与无常损失

Alice 调用 withdraw_liquidity() 销毁自己的 LP Token,并按她所销毁 LP Token 占总供应量的比例,领取两种有效储备中的份额。

提取除数为:

LP mint supply + MINIMUM_LIQUIDITY

程序分别使用 minimum_token_a_out 和 minimum_token_b_out 检查两侧输出:

let divisor = (context.accounts.liquidity_provider_mint.supply as u128)
    .checked_add(MINIMUM_LIQUIDITY as u128)
    .ok_or(AmmError::MathOverflow)?;

let amount_a_u128 = (amount as u128)
    .checked_mul(effective_pool_a as u128)
    .ok_or(AmmError::MathOverflow)?
    .checked_div(divisor)
    .ok_or(AmmError::MathOverflow)?;

由于池中包含支撑 100 个未铸造 LP 单位的储备,但 LP mint 的供应量不包含这些单位,存款和提取都必须使用一致的除数。否则,提取者会被多付,或者存款者会被少付。

Alice 最初存入:

  • 100 ACME;
  • 225 USDC。

她持有 150 LP Token,约占 750 个有效供应单位的五分之一。由于 Bob 和 Carol 的交易改变了池子组成,她最终提取的可能是:

  • 约 92.3 ACME;
  • 约 244 USDC。

按当前价格计算,这比她直接把原始 Token 留在钱包中少约 1.50 美元。

无常损失为何随价格变化

当 ACME 价格上涨时,交易者会从池中买走 ACME,并用 USDC 支付。恒定乘积池因此会:

  • 卖出上涨的 Token;
  • 收取相对下跌的 Token。

LP 仍然获得交易费用,但池中 Token 的比例会不断调整。如果价格发生变化,LP 头寸可能落后于单纯持有两种 Token。

这部分差额就是无常损失。

如果费用收入大于差额,提供流动性仍然有利;如果交易量很小但价格大幅变化,单纯持有可能更有利。之所以称为“无常”,是因为只有在提取时,这部分差额才最终确定。如果 ACME 价格在 Alice 提取前回到原来的水平,损失也可能消失。

手续费收入决定 LP 是否跑赢单纯持有

无常损失通常随价格偏离程度的平方增长。小幅价格变化造成的差额可能较小,但价格翻倍或变为四倍时,差额会明显扩大。

为什么除法要向有利于池子的方向舍入

池子与交易者或 LP 之间的每次除法,都按有利于池子的方向舍入:

  • swap 输出向下舍入;
  • LP mint 数量向下舍入;
  • 提取金额向下舍入;
  • 交易费用向上舍入;
  • 管理员费用份额向上舍入。

例如,交易费用向上舍入,可以避免交易者因为舍入而少支付一个最小单位。费用中管理员的部分也向上舍入,因此不会由 LP 承担舍入损失。

剩余的最小单位留在储备中。如果反过来对交易者有利地舍入,攻击者可以拆分大量小额交易,每次从池中拿走一个最小单位。

数学计算使用 u128,可能溢出的步骤都使用 checked_* 方法,并在失败时返回 MathOverflow。

每个 AMM Handler 维护的四个不变量

这些条件应当在每个 instruction handler 执行前后成立:

  1. 每次 swap 后,两个有效储备的乘积至少不低于交易前的值。程序会在转账后检查这一点。
  2. 管理员应得费用不参与 LP 数学,所有 LP 计算使用有效储备。
  3. LP Token 代表固定份额的索取权,按照存款比例铸造,按照提取比例销毁。
  4. 从池子创建开始,两种有效储备都必须大于零。initialize_pool() 会提供初始资金,提取会保留支撑 MINIMUM_LIQUIDITY 的份额,swap 输出始终小于输入侧储备。

AMM 程序如何拒绝常见攻击

Empty-Reserve Drain

如果某一侧储备为零,swap 公式可能尝试支付出另一侧的全部储备。仅检查交易前后的乘积不下降,无法覆盖这种情况,因为交易前乘积本身可能就是零。

因此,在执行任何定价逻辑之前,swap_tokens() 和 deposit_liquidity() 都会检查两个有效储备是否为正。如果任一侧为零,就返回:

EmptyPoolReserve

没有任何正常 instruction 可以让池子进入这种状态。测试 test_pool_creation_cannot_be_front_run 会手动将一个 vault 的余额设为零,并验证后续存款被拒绝。

Inflation Attack

通胀攻击通常包括以下步骤:

  1. 攻击者创建一个极小的池子;
  2. 直接向 vault 发送额外 Token;
  3. 每个 LP 单位因此代表大量 Token;
  4. 受害者随后存款时,获得的 LP Token 数量被向下舍入为零;
  5. 攻击者利用自己的 LP 份额赎回受害者存入的 Token。

MINIMUM_LIQUIDITY 会提高攻击成本。攻击者能够创建的最小池子只会在 101 个供应单位中给攻击者留下 1 个最小单位。若想让后续存款向下舍入为零,攻击者需要向 vault 发送约为受害者存款 101 倍的 Token,而其中大部分会对应无法赎回的 LP 份额。

测试 test_donation_cannot_round_a_later_deposit_to_zero 会向每个 vault 发送 1,000,000 个最小单位。受害者等额存款仍能获得 100 个最小单位的 LP,攻击者的单个单位只能赎回约 9,950 个最小单位的 Token A,收益低于发送量的 1%。

创建者设定首次价格

initialize_pool() 在创建池子的同一条 instruction 中接受首次存款,因此其他人无法抢先向空池存款并设定初始比例。

之后的存款会通过比例约束进行 clamp,不能随意改变价格。测试 test_pool_creation_cannot_be_front_run 会让第二个钱包尝试以 400 ACME 对 100 USDC 存款。由于 100 USDC 是限制侧,程序只接受约 44.44 ACME,池子的价格比例不会被改变。

Slippage 与 Sandwich 攻击

每笔交易、存款和提取都应带有调用者提供的最小输出值:

  • min_output_amount
  • minimum_lp_tokens_out
  • minimum_token_a_out
  • minimum_token_b_out

当实际结果低于这些阈值时,程序会失败:

  • swap 返回 SlippageExceeded;
  • 存款返回 DepositBelowMinimum;
  • 提取返回 WithdrawalBelowMinimum。

如果调用者把最小值设为零,就会给 sandwich 攻击留下空间。攻击者可以:

  1. 在目标交易之前买入;
  2. 让目标交易以更差价格成交;
  3. 在目标交易之后卖出。

调用方应根据最新报价计算最小输出,并减去自己能够接受的滑点。

其他人先创建了池子

每个交易对只有一个池子,任何人都可以创建它。创建者无法永久选择费用或管理员,因为这些参数来自全局配置;套利交易也可能修正首次价格。

如果 launchpad 为已有池子的交易对调用 initialize_pool(),指令会失败。因此,launchpad 应先检查池子是否存在:

  • 池子不存在时调用 initialize_pool();
  • 池子已存在时调用 deposit_liquidity()。

测试覆盖双向流程

programs/token-swap/tests/test_swap.rs 覆盖了:

  • 池子创建;
  • 流动性存入;
  • 双向兑换;
  • 流动性提取;
  • 管理员费用领取;
  • 失败路径与安全检查。

其中:

  • test_invariant_holds_after_normal_swap 和 test_invariant_holds_after_b_to_a_swap 检查有效乘积不会下降;
  • test_lp_mint_after_swap_uses_effective_reserves 检查管理员应付费用不会进入 LP 数学;
  • test_claim_admin_fees_rejects_non_admin 检查非管理员不能领取费用;
  • test_swap_fee_rounds_up 检查交易费用向上舍入;
  • test_pool_creation_cannot_be_front_run 检查首次价格和空储备防护;
  • test_donation_cannot_round_a_later_deposit_to_zero 检查通胀攻击防护。

构建程序并运行测试

克隆示例仓库并进入 Anchor 1 版本:

git clone https://github.com/quicknode/solana-program-examples
cd solana-program-examples/finance/token-swap/anchor-v1

安装并选择 Anchor 1.2.1:

avm install 1.2.1 && avm use 1.2.1

同步程序 ID 并构建:

anchor keys sync
anchor build --arch v1

为什么需要 --arch v1

Anchor 1.2.1 默认将程序构建为 SBPF v3,但当前 devnet 和 Surfpool 无法部署 SBPF v3 程序。因此需要使用:

anchor build --arch v1

测试位于:

programs/token-swap/tests/test_swap.rs

测试使用 LiteSVM,在测试进程内运行 Solana 虚拟机,并从以下路径加载已经构建的程序:

target/deploy/swap_example.so

项目的 Anchor.toml 将集群设置为 localnet,测试脚本设置为 cargo test。因此,anchor test 会启动 Surfpool 本地验证器,然后运行测试。

由于 anchor test 没有 --arch 参数,需要跳过重新构建:

anchor test --skip-build

测试通过时,本文提到的各个测试都会在输出中显示 ok。

将程序部署到 Solana Devnet

首先将 Solana CLI 指向 Quicknode devnet endpoint:

solana config set --url <your Quicknode devnet URL>

Anchor.toml 中的钱包默认是:

~/.config/solana/id.json

该钱包用于支付部署费用。部署程序需要支付程序账户租金,因此需要先为钱包充值 devnet SOL。

完成充值后执行:

anchor program deploy --provider.cluster <your Quicknode devnet URL>

该命令会使用:

target/deploy/swap_example-keypair.json

中的密钥对部署工作区内的 swap_example 程序,并上传对应 IDL。

如何将 Token Swap AMM 接入应用

只需要兑换时,优先路由现有流动性

如果应用只让用户用一种代币交易另一种代币,通常不需要自己创建池子。可以通过现有 Solana DEX 路由交易,并根据报价结果构造交易。

只有在以下场景中,才更适合运行自己的池子:

  • 某个 Token 还没有市场;
  • 应用本身就是交易场所;
  • 应用希望获得每笔交易的管理员分成;
  • 应用需要控制池子的定价和流动性逻辑。

通过 gRPC 读取池子状态

可以订阅以下账户:

  • pool_a
  • pool_b
  • pool config

读取 vault 余额后,分别减去:

  • admin_fees_owed_a
  • admin_fees_owed_b

就能得到有效储备。随后可以计算现货价格、显示 LP 费用,并在管理员费用达到阈值时调用 claim_admin_fees()。

Solana gRPC 适合持续监控池子状态和交易后的余额变化,也可用于构建价格与费用仪表板。相关技术可以参考 gRPC。

在报价仍然有效时提交交易

交易者的 min_output_amount 来自报价时的池子储备。如果交易延迟多个 slot 才上链,池子可能已经发生变化,最终因 SlippageExceeded 失败。

网络繁忙时,可以根据当前网络状态估算优先费用,提升交易及时被包含的概率。

后续学习方向

可以继续比较 finance/token-swap 中的三个实现:

  • Anchor 1:本文使用的版本;
  • Anchor 2:anchor 目录;
  • Quasar:quasar 目录。

比较时重点观察:

  • 账户结构;
  • PDA seeds;
  • vault 权限;
  • 有效储备计算;
  • K 值检查;
  • 费用拆分;
  • 测试组织方式。

虽然框架版本不同,但池子账户、LP 份额、滑点保护和不变量检查等核心逻辑仍然保持一致。

总结

本文跟随了一次完整的 Token 发行流程:

  1. Maria 通过首次存款设定池子初始价格;
  2. Alice 添加流动性并获得 LP Token;
  3. Bob 和 Carol 通过 swap 改变池子价格;
  4. 管理员费用通过计数器记录,并由 Maria 单独领取;
  5. Alice 提取流动性,同时承担价格变化带来的无常损失。

swap_tokens() 会先扣除费用,再根据有效储备定价,并在 Token 转账后重新检查 K 值不变量。

MINIMUM_LIQUIDITY 用于提高通胀攻击成本,EmptyPoolReserve 检查用于阻止空储备耗尽。滑点阈值则为交易、存款和提取提供用户侧保护。

最后,程序使用 LiteSVM 完成测试,并通过 Quicknode endpoint 部署到了 Solana devnet。

常见问题

恒定乘积 AMM 如何在 Solana 上为兑换定价?

程序在定价时维护两个有效储备的乘积。输出金额由以下因素决定:

  • 输入 Token 数量;
  • 扣除交易费用后的实际输入;
  • 输出侧有效储备;
  • 输入侧有效储备加上计税输入。

计算结果向下取整。

首次向池子存款会获得多少 LP Token?

LP Token 数量是两种存款金额乘积的整数平方根,再减去 100 个最小单位:

floor(sqrt(amount_a * amount_b)) - MINIMUM_LIQUIDITY

例如存入 400 ACME 和 900 USDC,整数平方根为 600,因此初始 LP 数量为 600 减去永久保留的 100 个最小单位。

什么是流动性提供者的无常损失?

无常损失是指价格发生变化后,LP 在池中的份额价值低于单纯持有原始 Token 的差额。

它通常随价格偏离程度的平方增长,并且只有在 LP 提取时才最终确定。交易费用收入可能抵消这部分损失。

AMM 程序如何阻止通胀攻击?

程序在铸造和销毁 LP Token 时都将 100 个未铸造的最小单位计入供应量计算,但没有任何人能够获得这些单位。

因此,攻击者必须投入远高于受害者存款的额外 Token,才能让后续存款向下舍入为零,而攻击者投入的大部分价值会留在无人可赎回的份额中。

管理员的交易费用去了哪里?

管理员费用暂时留在池子的 vault 中,由以下两个计数器记录:

  • admin_fees_owed_a
  • admin_fees_owed_b

管理员通过 claim_admin_fees() 领取。LP 计算使用有效储备,因此会将这些管理员应得金额排除在外。

应该构建自己的 AMM,还是通过聚合器路由兑换?

如果应用只需要让用户交易已有市场中的 Token,应优先通过聚合器路由兑换。

如果应用本身是交易场所、Token 尚未形成市场,或者应用需要获得管理员费用分成,则可以考虑构建自己的 AMM 池。

来源

  • 原文链接:Quicknode Solana AMM Program
  • 示例代码:Quicknode solana-program-examples 仓库中的 finance/token-swap
  • 参考实现:Anchor 1、Anchor 2 和 Quasar 版本



上一篇:MCU 加 NPU 还是加缓存?六家厂商的三种方案与选型思路
下一篇:Magpie 本地网关实测:和 CC Switch 的区别与路由组用法
您需要登录后才可以回帖 登录 | 立即注册

关闭

站长推荐上一条 /1 下一条

手机版|小黑屋|网站地图|云栈社区 ( 苏ICP备2022046150号-2 )

GMT+8, 2026-11-21 15:31 , Processed in 0.133619 second(s), 41 queries , Gzip On.

Powered by Discuz! X3.5

© 2025-2026 云栈社区.

快速回复 返回顶部 返回列表