wuaoxiang (吴翱翔)

lifinity 项目投研——为何交易量反超 orca

wuaoxiang — Mon, 16 Dec 2024 16:40:58 +0800

原文首发于吴翱翔的博客：https://pymongo.github.io/#/2024/12/lifinity

经常用 solscan 的我发现最近 dex 交易量中有个不熟悉的 LFNTY 反超了 orca 排在 raydium 后

看了下文档说是自称自动调整价格区间的 CLMM 池子只有主流币我尝试给池子加流动性也没法加

有点像公募基金/ETF 这样的产品只能通过购买 LFNTY 代币并锁仓成 veLFNTY 间接获得池子的手续费收益

还有一种 LST 的四年锁仓版本的 xLFNTY 可交易

随着 12 月 meme 热度下降 ray/orca 交易量也降低很多，LFNTY 的 TVL 不高是怎样骗聚合器更多路由过来的

可能 CLMM 很多小白用户超区间或者区间挂的不好，没有 LFNTY 这样算法自动调仓资金利用率高

我买了 1SOL(220$) 的 LFNTY 锁仓 9 天到时候再看看收益如何

此外 LFNTY 也开发了类似 ratex 的 yield-trading 平台 sandglass

参考文章：https://solanafloor.com/news/lifinity-flips-orca-24-hr-dex-volume-lfnty-undervalued

solana 节点初始化耗时和追块/落后块的优化技巧

wuaoxiang — Tue, 03 Dec 2024 21:43:29 +0800

solana 节点初始化过程

13:00:31 准备读 ledger snapshot
13:03:00 (3 分钟)snapshot 读取完毕
13:06:00 (6 分钟)incremental snapshot 读取完毕且 solana_accounts_db 索引建立完毕
13:19:02 (13 分钟) 从账本 bank(状态快照) 中重建出所有账户 [耗时非常久]

重建账户数据完成之后基本上 rpc 服务完成初始化完成了可以 getSlot rpc 方法调用了

这时候可以用 grpc 客户端查询 slot 了

root@solana:~# ./client-ubuntu-22.04 -e http://127.0.0.1:60003 get-slot
[2024-12-03T13:32:47Z INFO  client] Connected
[2024-12-03T13:32:47Z INFO  client] response: GetSlotResponse { slot: 305155526 }

追踪追块进度

# solana catchup --our-localhost 60001
⠙ 3188 slot(s) behind (us:305154679 them:305157867), our node is gaining at 0.2 slots/second (AVG: 0.3 slots/second, ETA: slot 305183903 in 2h 57m 7s)

初始化完成后落后了 3200 个区块 (slot)，按照 0.4 个 slot 计算大约是 21 分钟，跟之前统计的各个阶段初始化耗时约 20 分钟接近

追不上块的解决方案

我 12*32=384G 内存 AMD EPYC 9254 机器开启两个索引之后追不上块，每秒落后 0.2 个区块，后来禁用掉黄石 grpc 和索引花了 5-6 小时完成区块同数据步

禁用黄石 grpc
禁用账户数据索引
CPU 超频，linux 内核 ACPI 电源模块调参
检查下 systemd 配置有没有放开 fd 限制
禁用 swap 网络，内存，硬盘一些调优参数有没有开

如何调优先费让交易快速上链——从 agave 源码剖析为什么 jito 适合套利？什么时候用优先费什么时候用 jito?

wuaoxiang — Wed, 20 Nov 2024 01:04:28 +0800

可否量化 SOL 网络拥堵的指标区调整优先费提高上链速度呢？判断 SOL 网络拥堵的指标，SOL 域名解析商 sns.id 网页上右上角显示 Congested network, 从区块浏览器上看 TPS 普遍都有 4000+ 但 true TPS 真正属于用户交易的其实就只有几百 TPS，其余的 TPS 都是网络共识层投票等。

网络拥堵时，交易员/开发者/套利者等发出去的交易常常等很久都不上链，也听 space 上开发者抱怨交易很难上链或者优先费用卷的很高，如何利用优先费用 (priority fee)或者jito 小费 (jito tips)机制提高交易成功率和上链速度呢？

优先费用机制

交易带 SetComputeUnitPrice 指令才启用优先费机制
交易带 SetComputeUnitPrice 但没 SetComputeUnitLimit 指令默认按 20 万 ComputeUnitLimit/每条指令
交易同时带 CU price/limit 两个指令 (不管指令顺序)，不管交易成功或失败都收取 price*limit 的优先费用

ComputeUnit 往后简称为 CU, sol 官方文档 how-to-use-priority-fees 中有个规则 2 的示例交易 (solscan)

文档说 set the Compute Unit Limit to 300 CUs while also adding a priority fee of 20000 micro-lamports

应该是这篇文章里面的 tx 太旧了，是以前验证者节点代码，最新的 agave 源码中如果是内置指令没有加 CUlimit 也会自动设置成 150, 第三方指令就 20 万

实际上这个交易忘了设置 CU limit 变成默认的 20 万 CU limit 每条指令 (最新验证者节点这个交易 CU limit 应该自动是 300 可能过于古老了) 所以收取了每笔交易基本费用，注意 CU price 单位是 micro lamports 要乘以 1e-6 转换成 SOL_lamports per CU 的量纲

5000 + (20000*1e-6 * 200000) = 9000 lamports SOL = 0.000009SOL

交易费用=5000lamports 基础费 + 账户租金费/开户费 + 优先费用，优先费用总值的竞价排名决定了交易在验证者出块的优先级

源码在 agave(solana 2.0 之后改名成 agave 项目继续维护了，原 github 地址不更新) 的 cost-model crate 中可以看到常量 DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT 就是 20 万

fn get_transaction_cost(
    transaction: &impl TransactionWithMeta,
    feature_set: &FeatureSet,
) -> (u64, u64, u64) {
    let mut programs_execution_costs = 0u64;
    let mut compute_unit_limit_is_set = false;
    let mut has_user_space_instructions = false;
    for (program_id, instruction) in transaction.program_instructions_iter() {
        let ix_execution_cost =
            if let Some(builtin_cost) = BUILTIN_INSTRUCTION_COSTS.get(program_id) {
                *builtin_cost
            } else {
                has_user_space_instructions = true;
                u64::from(DEFAULT_INSTRUCTION_COMPUTE_UNIT_LIMIT)
            };
        programs_execution_costs = programs_execution_costs
            .saturating_add(ix_execution_cost)
            .min(u64::from(MAX_COMPUTE_UNIT_LIMIT));
        if compute_budget::check_id(program_id) {
            if let Ok(ComputeBudgetInstruction::SetComputeUnitLimit(_)) =
                try_from_slice_unchecked(instruction.data)

再看一个同时设置了 CU price 和 limit 的例子：https://solscan.io/tx/BcBCS61y3GpYCHVzUZ3KK7v1M7PgYqNM8oyqx3oLq7XcxaYDW5SH1GQqvL5pkR91jypxh9sPDpztMby32oxEnre

agave 源码中 solana_compute_budget_program DEFAULT_COMPUTE_UNITS 是 150, 设置 CU limit/price和转账都是150

上述交易 CU limit 设置了 3000，交易有 2 个设置 CU 的指令和 18 次 SOL 转账的指令，加起来刚好是 (2+18)*150=3000 CU

10000*1e-6 * 3000 = 300 lamports

CU limit 如何设置

即便交易只用了 300CU 但设置了 20 万的 CU limit(如上述例子 1 的 tx), 也是按照 CU limit 20 万收取优先费用

所以交易中尽可能设置更低的 CU Limit，而且根据helius 文档 CULimit 越低的交易上链的优先级更大

常见的交易指令中消耗的 CU

transfer/SetCU: 150
智能合约部署：约 2500-3000
token transfer: 5000(不需要开户时)
create ATA account(token 开户): 约 30000
raydium AMM swap: 约 33000-40000
jupiter swap: 约 100000-400000

像 jup swap 这样不确定的 CU 消耗推荐用 simulate rpc 模拟执行获取 CU 消耗

优先费用价格 CU price 设置算法

交易预期利润的 60% 除以 CU limit 得到单价的套利贿赂矿工算法
Helius Priority Fee API 的推荐
rpc getRecentPrioritizationFees
triton Improved Priority Fees API
jupiter,raydium,metaora 这样的产品也内置了优先费用的计算，无需开发者处理

原版 rpc 优先费 API 返回的是某个智能合约地址最近 150 区块交易中的最小值 (at least one successfully landed)

其实更推荐用 triton 增强型优先费 API 能查询到某智能合约最近大伙给的优先费的中位数

一般网络拥堵的时候我个人经验是 jupiter TURBO 等级的优先费用都要给到 0.2u~0.4u 不等

SOL 跟 EVM 不同的是，EVM 如果交易失败了收取的是 gasPrice * gasUsed(实际消耗的 CU)

那么问题来了，对于一个预期利润是 10SOL 的套利交易，拿出了 80% 预期利润 8SOL 的优先费用贿赂矿工

但是交易因为滑点过大没抢单成功，交易失败了也要支付 8SOL 的优先费用，是非常昂贵的成本了

为套利者而生的 jito

jito 的出现就解决了这个问题，jito 的交易不需要设置优先费用 CU price 的指令 (CU limit 还是建议要)

而是让交易最后加一个给 jito 8 个小费地址随机选一个转账的指令，为什么要随机选一个呢

如果大伙都往第一个小费地址打钱，8 个地址随机选一个可以提高吞吐量同时有 8 个 jito 小费指令可并行执行

所以发送给 jito 的交易失败发生回滚的话，最后一条小费指令不会执行，也就损失 5000lamports 的基础交易费用

bloXroute加速上链服务

很多 bot 的交易不直接发给 jito，而是通过 bloXroute 转发给 jito。因为 bloXroute 有一个 super bundle 的功能，能打包不冲突的交易，bundle 的 tip 也给的高，所以比直接发 jito 速度更快。

bloXroute 也是 jito 最大的合作伙伴之一，在 jito 那里有很高的账户等级；tip 给的高，只是快速上链的条件之一。其实还有其他一些基础设施上的配置，包括全球的节点布置，合作节点，网络拓扑优化等等

据说主要是交易机器人和一些 dex，做市商等采购 bloXroute 服务，我没用过就不评价了

什么时候用 jito 什么时候用优先费

§ 适用于 jito 加速交易的业务

套利交易
狙击 pump/raydium 等开盘
防夹
价格波动大的 LP 建仓
失败率高允许重试有希望快点上链的业务

笔者有次 LP 建仓发交易就说价格波动导致 tick 滑点变动交易失败，连续失败 4-5 次每次亏损 0.4$的优先费用如果用 jito 不断重试交易就不必亏这么多了

§ 适用于优先费用加速交易的业务

memecoin swap 交易
快点转账

§ 既不要 jito 也不要优先费的业务

转账 (钱包软件基本不给优先费)
智能合约部署
LP 超出区间了移除流动性等不是很急的业务

智能合约部署我的经验是推荐用 aws 免费节点+helius 免费 rpc 上传/部署智能合约

项目不急着上线失败就重试几次 (急的话 deploy 可加优先费用的命令行参数)，失败的话会出现一些 program buffer 占用资金，稍后 solana program close 关掉后就能回收 SOL 了

谁当 leader 就给谁发

由于 SOL 网络中当前 epoch POS 的 leader 顺序是确定的，也可以预测下个 leader 是 jito 的节点就给 jito 发交易，如果是 helius/triton 节点就用优先费给他们发

~~还有一种思路 nonceAccount 同时签名两个交易一个发 jito 一个发 helius，一个成功另一个自然因为 nonce 无效而失败~~

swqos 机制加速上链

swqos 简单说就是质押量越大的验证者节点，在下个区块出块中能提交给 leader 节点的交易数更多，所以走质押量更大的节点 rpc 上链更快

听 solayer 在 space 说要把 swqos 加速上链的机制做成 restaking 奖励，用户质押给项目方更多 SOL，项目的上链速度更快体验更好，项目方应该奖励给质押用户额外奖励这样的经济模型

swqos 节点基本是被 triton,helius 这样的大户厂商垄断了，quicknode 这样的知名厂商也没有，~~所以 solayer 能否打破这种垄断呢 (支持华语区项目打破垄断)~~

由于 triton 服务不对外公开销售了，所以也就只能用 helius 付费的 staked connection rpc 消耗的额度是普通 rpc 的 50 倍

如何确认交易成功/交易重试

由于 solana 网络拥堵时，发出去的交易可能被 rpc 节点丢弃没有发成功给 leader 节点了，或者等很久很久才上链，因此重试策略推荐阅读 triton 这篇文章 https://docs.triton.one/chains/solana/sending-txs

计算下签名交易用的 blockhash 还有多久过期
ws 订阅交易的 signature
发送交易
每隔一段时间获取交易状态，定时重发交易

直到 http 轮询交易成功或者 ws 推送交易成功

triton 2000 美元一个月的 jupiter 私享 api 体验 (套利用途)

wuaoxiang — Tue, 22 Oct 2024 22:27:05 +0800

苦于 jupiter 询价 API 太慢了难以捕获市场机会，斥资购买了号称 solana 最贵最快的 rpc 提供商 triton

笔者也订阅了 ankr/alchemy 的套餐但 rpc 请求速度依然不如付费的 helius, helius 的测试结果也不如 triton/rpcpool

毕竟一分钱一分货，50 美元的还是没法跟 2000 美元的比...

triton 形成了产业生态联盟，首先跟 jupiter 深度合作，提供加速 dex 行情的 validator yellowstone 插件服务，还有跟 jupiter 合作共建的 solana.fm 区块浏览器，同步 jupiter 交易数据特别快

triton 2000 美元的套餐除了 rpc 服务还有私享的 jupiter 快速 api 服务，以下是我的 benchmark 对比结果

	jupiter public api	triton private api
GET /quote	838ms	24ms
POST /swap	1280ms	256ms

根据 jupyer 文档

Price data from both buy side and sell side is cached for up to 15 seconds - it is not meaningful to spam this endpoint

无论是 price/quote/swap API 在 jupiter 的公共 API 上都会缓存一段时间，意味着询价得到的价格数据很可能是旧的行情存在很大延迟

如果想要更低延迟拿行情，可以试试自建 jupiter api server 进行剪枝去掉些不关心的 token 降低服务器配置要求和数据带宽要求或者购买 triton 服务

最终上套利效果图，从询价到套利交易上链的区块延迟可优化到 10 个 slot(约 4s) 以内，比起 jupiter 免费的公共 API 那可快得多

rpc 批量请求某地址所有 token 价格和钱包余额

wuaoxiang — Tue, 08 Oct 2024 15:31:55 +0800

只需要 2 次 HTTP 请求就实现批量查余额和批量询价类似幻影钱包的功能

RAY 1.7363*25.3996=44.101$
MEW 0.0068*870.0655=5.907$
USDC 0.9997*779.6599=779.393$
SLERF 0.1427*28.4659=4.061$
POPCAT 1.1863*0.6269=0.744$
USDT 1.0000*198.3104=198.314$
SOL 142.6512*0.0085=1.213$
walletEquity = 1033.733

solana go 客户端的例子不是很全，我自己摸索了下给出完整实例分享给大家

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "math"
    "net/http"
    "strconv"
    "strings"

    bin "github.com/gagliardetto/binary"
    token_metadata "github.com/gagliardetto/metaplex-go/clients/token-metadata"
    "github.com/gagliardetto/solana-go"
    "github.com/gagliardetto/solana-go/programs/token"
    "github.com/gagliardetto/solana-go/rpc"
)

type soltokenctx struct {
    mint      token.Mint
    metadata  token_metadata.Metadata
    myaccount token.Account
    price     float64
    uiamount  float64
}

type jupprice struct {
    Data map[string]struct {
        Id    solana.PublicKey
        Price string
    }
}

func main() {
    walletEquity := 0.
    ctx := context.Background()
    solClient := rpc.New("https://api.mainnet-beta.solana.com")
    addr := solana.MustPublicKeyFromBase58("GhyfPX5JMfb2HjvbvfRihm9hoPZP8e3VZ8fGfu2fFafK")
    accounts, err := solClient.GetTokenAccountsByOwner(ctx, addr, &rpc.GetTokenAccountsConfig{
        ProgramId: &solana.TokenProgramID,
    }, nil)
    if err != nil {
        log.Fatalln(err)
    }
    mints := make([]solana.PublicKey, 0)
    metadatas := make([]solana.PublicKey, 0)
    myaccounts := make([]*soltokenctx, 0)
    for _, each := range accounts.Value {
        var myaccount token.Account
        err := myaccount.UnmarshalWithDecoder(bin.NewBinDecoder(each.Account.Data.GetBinary()))
        if err != nil {
            log.Fatalln(err)
        }
        if myaccount.Amount == 0 {
            continue
        }
        metadata, _, err := solana.FindTokenMetadataAddress(myaccount.Mint)
        if err != nil {
            log.Fatalln(err)
        }
        mints = append(mints, myaccount.Mint)
        metadatas = append(metadatas, metadata)
        myaccounts = append(myaccounts, &soltokenctx{
            myaccount: myaccount,
        })
    }
    tokenmints, err := solClient.GetMultipleAccounts(ctx, append(mints, metadatas...)...)
    if err != nil {
        log.Fatalln(err)
    }
    length := len(mints)
    for i := 0; i < length; i++ {
        mintbytes := tokenmints.Value[i].Data.GetBinary()
        var mint token.Mint
        err := mint.UnmarshalWithDecoder(bin.NewBinDecoder(mintbytes))
        if err != nil {
            log.Fatalln(err)
        }
        myaccounts[i].mint = mint

        metadatabytes := tokenmints.Value[i+length].Data.GetBinary()
        // log.Println(len(metadatabytes), unsafe.Sizeof(token_metadata.Metadata{}))
        var metadata token_metadata.Metadata
        metadata.UnmarshalWithDecoder(bin.NewBorshDecoder(metadatabytes))
        myaccounts[i].metadata = metadata
    }
    jupapi := "https://api.jup.ag/price/v2?ids="
    for i, each := range mints {
        if i > 0 {
            jupapi += ","
        }
        jupapi += each.String()
    }
    resp, err := http.Get(jupapi)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()
    respBody, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }
    var r jupprice
    err = json.Unmarshal(respBody, &r)
    if err != nil {
        log.Fatalln(err)
    }
    for _, each := range r.Data {
        for _, acc := range myaccounts {
            if acc.myaccount.Mint == each.Id {
                price, err := strconv.ParseFloat(each.Price, 64)
                if err != nil {
                    log.Fatalln(err)
                }
                acc.price = price
                acc.uiamount = float64(acc.myaccount.Amount) / math.Pow10(int(acc.mint.Decimals))
                namewithnul := acc.metadata.Data.Symbol
                name := namewithnul[:strings.IndexByte(namewithnul, '\x00')]
                // Symbol: (string) (len=10) "POPCAT\x00\x00\x00\x00",
                // 有没有必要隐藏小额资产...
                value := price * acc.uiamount
                walletEquity += value
                fmt.Printf("%s %.4f*%.4f=%.3f$\n", name, price, acc.uiamount, value)
                break
            }
        }
    }
    fmt.Printf("walletEquity = %.3f\n", walletEquity)
}

智能合约中 SOL 与 wSOL 如何互相转换？

wuaoxiang — Mon, 19 Aug 2024 18:47:20 +0800

WETH 智能合约就比 ERC20 多了 deposit/withdraw 进行转换

要获得 wSOL 需要了解一个指令叫 spl_token::instruction::sync_native

transfer 指令给 wSOL 的 associated_token_addr 转 SOL + sync_native 指令够了

fn main() {
    // ...
    let token_account = spl_associated_token_account::get_associated_token_address(&payer.pubkey(), &WSOL);
    let latest_block = client.get_latest_blockhash().unwrap();
    get_wsol_balance(&client, &token_account, &payer, latest_block);

    let amount = 1_000_000;
    let instruction = solana_sdk::system_instruction::transfer(&payer.pubkey(), &token_account, amount);
    let transaction = Transaction::new_signed_with_payer(
        &[instruction],
        Some(&payer.pubkey()),
        &[&payer],
        latest_block,
    );
    client.send_and_confirm_transaction(&transaction).unwrap();
    println!("after transfer {amount}");
    get_wsol_balance(&client, &token_account, &payer, latest_block);

    let ix = spl_token::instruction::sync_native(&spl_token::ID, &token_account).unwrap();
    let transaction = Transaction::new_signed_with_payer(
        &[ix],
        Some(&payer.pubkey()),
        &[&payer],
        latest_block,
    );
    client.send_and_confirm_transaction(&transaction).unwrap();
    println!("after sync_native {amount}");
    get_wsol_balance(&client, &token_account, &payer, latest_block);
}
fn get_wsol_balance(client: &RpcClient, token_account: &Pubkey, payer: &Keypair, latest_block: Hash)  {
    let account = match client.get_account(&token_account) {
        Ok(acc) => acc,
        Err(err) => match err.kind {
            solana_client::client_error::ClientErrorKind::RpcError(
                solana_client::rpc_request::RpcError::ForUser(err),
            ) => {
                println!("{}: {err}", line!());
                let create_account_instr = spl_associated_token_account::instruction::create_associated_token_account(
                    &payer.pubkey(),
                    &token_account,
                    &WSOL,
                    &spl_token::ID,
                );
                let mut transaction =
                    Transaction::new_with_payer(&[create_account_instr], Some(&payer.pubkey()));
                transaction.sign(&[&payer], latest_block);
                client.send_and_confirm_transaction(&transaction).unwrap();
                client.get_account(&token_account).unwrap()
            }
            _ => {
                panic!("{err}");
            }
        }  
    };
    let account_state = spl_token::state::Account::unpack(&account.data).unwrap();
    let sol = account_state.amount as f64 / 1e9;
    println!("wsol = {sol}, {} lamports", account_state.amount);
}

代码的输出如下，如果转账给 wSOL 不进行 sync_native 的话，wSOL 余额是没有更新的

wsol = 0.004, 4000000 lamports
after transfer 1000000
wsol = 0.004, 4000000 lamports
after sync_native 1000000
wsol = 0.005, 5000000 lamports

我们再看看 solana 源码中怎样进行 SOl->wSOL 的

https://github.com/solana-labs/solana-program-library/blob/master/token/cli/src/command.rs#L1886

spl-token cli 源码中，创建 spl-token 并没有用 sync_native 原因是先 transfer 再 init 账户的话，init 的时候相当于执行了类似 sync_native 的效果了

所以 spl-token wrap 命令在 wSOL 账户存在的时候转入 wSOL 会报错 Error: Account already exists

只能用 transfer+sync_native 的方式

solana 源码中提到：

Burns tokens by removing them from an account. Burn does not support accounts associated with the native mint, use CloseAccount instead.

不能使用 burn 去销毁 wSOL 余额换回原生 SOL, 只能用 close 把 wSOL 账户全部退回成 SOL，不同于 WETH 合约可以部分提现 WETH 成 ETH

spl-token unwrap实际上调用的是 close account

Rust 代码质押 solana 委托投票权给验证者

wuaoxiang — Mon, 12 Aug 2024 14:51:13 +0800

首先要创建一个质押账户，并转入要质押的 SOL，对标 solana create-stake-account cli 的功能

let staker = Keypair::new();
let authorized = stake::state::Authorized {
    staker: staker.pubkey(),
    withdrawer: staker.pubkey(),
};
let lockup = stake::state::Lockup {
    unix_timestamp: unsafe { libc::time(std::ptr::null_mut()) },
    epoch: 0,
    custodian: staker.pubkey(),
};
let lamports = 10u64.pow(9);
let ixs = stake::instruction::create_account( // stake::program::id();
    &payer.pubkey(),
    &staker.pubkey(),
    &authorized,
    &lockup,
    lamports,
);
let transaction = Transaction::new_signed_with_payer(&ixs, Some(&payer.pubkey()), &[&staker], blockhash);
let txhash = client.send_and_confirm_transaction(&transaction).unwrap();

注意创建完质押账户并不能获得奖励，就像我以前以为质押 JUP 获得 JUP 打新奖励，结果 JUP 要求行使了投票权的质押者才能获得奖励。

所以我们的质押账户必须要行使投票权，例如投票/验证 solana 网络最新区块的某个交易是否正确，给网络做出贡献才能获得质押奖励

当然我不是验证者，或者懒得投票，这时候可以将质押账户的 SOL 对应的投票权益，委托给验证者节点进行投票以此获得奖励

通过 solana validators 查询当前所有验证者节点然后选其中一个 vote addr 投票地址即可

为了网络稳定，质押/解除质押 1 个 SOL 不会立即获得 1SOL 同等的投票权力，质押后会随着时间增加投票权力直到 1 个 SOL 的完整投票权力，解除质押也是慢慢解除，这样避免大户突然质押或者取消质押大量资金造成 solana 网络投票权力的不稳定

质押账户创建完之后，对标 solana delate-stake cli 的功能进行质押委托

let ix = stake::instruction::delegate_stake(
    &staker.pubkey(),
    &staker.pubkey(),
    &solana_sdk::pubkey!("F2UsSsRHezY1U4h8FWMmWHkgyVd8r5hVVPNXViod9ZnJ"),
);
let transaction = Transaction::new_signed_with_payer(
    &vec![ix],
    Some(&payer.pubkey()),
    &[&payer, &staker],
    blockhash,
);
let txhash = client.send_and_confirm_transaction(&transaction).unwrap();
println!("{txhash}");

质押的 tx 成功后，可以命令行查询当前质押账户的状态，如果想要赎回质押的钱，可以 solana deactivate-stake

w@w:~$ p solana stake-account BYMscUVgenNz6kaRsBuyG2WroXtkE8LyX2yZoq9uvX4W
ProxyChains-3.1 (http://proxychains.sf.net)
Balance: 1 SOL
Rent Exempt Reserve: 0.00228288 SOL
Delegated Stake: 0.99771712 SOL
Active Stake: 0 SOL
Activating Stake: 0.99771712 SOL
Stake activates starting from epoch: 736
Delegated Vote Account Address: F2UsSsRHezY1U4h8FWMmWHkgyVd8r5hVVPNXViod9ZnJ
Stake Authority: BYMscUVgenNz6kaRsBuyG2WroXtkE8LyX2yZoq9uvX4W
Withdraw Authority: BYMscUVgenNz6kaRsBuyG2WroXtkE8LyX2yZoq9uvX4W

或者在 solflare 之类的钱包就看到质押记录了