aprs

How it works — I want to start by laying out the engine before the metaphors, because if you’re anything like me you want to see the gears and then imagine the whole machine humming, and #Falcons engine is deceptively simple at a high level: you deposit custody-ready assets into a governed reserve, the protocol recognizes and values a wide spectrum of those assets, and then it mints USDf — an overcollateralized synthetic dollar — that you can use, stake, or move through $DEFI without forcing you to sell the underlying holdings, which is the whole point. #USDf is not an algorithmic peg that tries to “guess” a dollar by market forces; it’s backed by collateral that sits inside Falcon’s system and is subject to attestations and reserve breakdowns so the whole thing is meant to be both practical and observable in a way that makes people feel safer using it than some of the fragile experiments we’ve seen before.
Why they built it — I’m always struck by how often liquidity and ownership are treated as binary in crypto, as though you either keep an asset and never move it and watch it collect metaphorical dust, or you sell it and crystallize whatever gain or loss there is, and Falcon is trying to make the middle path real: keep ownership, access liquidity, and earn yield without the sharp edges of liquidation or the awkwardness of moving into an entirely different asset class. They’re solving a real, human problem that shows up in every wallet and treasury I’ve looked at — the feeling of being asset-rich but cash-poor when opportunities arise or when operational needs require dollars — and they designed a system that turns custody-ready assets into a dollar-equivalent that’s meant to be stable, spendable, and productive. That problem is practical, not theoretical, and the design choices reflect that.
Design and technical choices that matter — at the foundation, the project makes three big choices that shape everything above it: broad collateral eligibility, a conservative overcollateralization model, and active reserve management combined with transparency. Broad collateral eligibility means the system accepts many custody-ready assets including stablecoins, major cryptocurrencies, and tokenized real-world assets, and that decision widens the pool of capital that can be mobilized into USDf, which is a huge structural shift compared with systems that only accept a narrow list of assets. Overcollateralization is the conservative safety margin — minting less USDf than the nominal value of collateral — which reduces liquidation frequency and stress under normal market movements, and that’s crucial because it keeps users from being forced to sell in bad markets; it’s a human-centered design choice that values resilience over short-term leverage. Finally, the reserve and yield strategy choices — where some assets are routed into actively managed strategies, delta-neutral positions, or real-world yield opportunities — are what let USDf be both a stable unit and a productive asset when staked into sUSDf, which captures the returns; those are the levers that balance stability and utility. Each of these technical choices shapes user experience: wider collateral means more people can participate, overcollateralization means fewer surprises, and active reserve management means USDf holders and stakers can actually earn something while staying within the ecosystem.
Step-by-step user journey in practice — imagine I own tokenized gold or a diversified crypto basket and I’m eyeing an opportunity to rebalance a position or pay an invoice; I deposit that custody-ready asset into Falcon, the protocol recognizes the collateral type and the risk parameters that were pre-set for that asset class, the system issues me USDf up to a safe overcollateralized limit, and now I’ve unlocked dollar-equivalent liquidity without selling. If I’m patient and want to earn, I can stake that USDf to receive sUSDf and thereby participate in the protocol’s yield strategies, which means I’m effectively converting idle balance into productive capital. If I’m a project or treasury manager, I see obvious use-cases too: preserve the asset on the balance sheet, unlock liquidity for operations or yield, and maintain exposure to the original asset’s upside. That flow intentionally preserves ownership and optionality, which to me feels like treating assets with respect rather than forcing binary choices.
What metrics matter and what they actually mean — when you’re trying to read a system like this, there are a few numbers you should watch and not treat as mystic runes: total USDf supply and market cap show how much synthetic liquidity the protocol has created and how many economic actors rely on it; the collateralization ratio across the entire reserve and by collateral type shows how much buffer exists before stress events force action; reserve composition and weekly attestations tell you what’s actually sitting behind the peg and whether the collateral is diversified or concentrated; the yield sources and #APRs for sUSDf reflect how the protocol is monetizing reserves and whether returns are sustainable or one-off; and finally, on-chain activity like mint/redemption cadence and where USDf flows (#Dexes , lending markets, payments integrations) shows real utility versus speculative minting. Watching those numbers in practice is less about the absolute size and more about trends: are reserves growing more diversified, is collateralization weakening or strengthening, are yields coming from repeatable strategies or risky one-offs, and is USDf moving into real use cases or circulating mostly in speculative loops. Those signals together let you build a mental model of whether the system is maturing or simply expanding risk.
Structural risks and weaknesses — I’m honest about what can go wrong because ignoring weaknesses is how people get burned, and the big risks here are threefold: oracle and valuation risk, concentration risk, and governance or counterparty risk. Oracle and valuation risk matter because the protocol relies on accurate pricing to set collateral values and overcollateralization thresholds, and if price feeds fail or are manipulated the cushion can evaporate; that’s a technical and operational problem that needs careful multi-source feeds and fallback mechanisms. Concentration risk matters because if too much of the reserve is a single asset class or an off-chain tokenized instrument that becomes illiquid, the buffer can be insufficient at peak stress; diversification helps but it’s not a panacea if correlated assets drop together. Governance and counterparty risk matter because real-world assets often bring counterparties and custody layers that live off-chain, and those relationships create legal, operational, and regulatory dependencies that pure onchain tokens don’t. If it becomes convenient to ignore those links, that’s when surprises occur. Being aware of these risks helps you watch the right metrics and evaluate whether safeguards — like weekly attestations, conservative overcollateralization, and transparent reserve breakdowns — are working as intended.
How the future might unfold — pragmatically, there are two broad scenarios that feel realistic to me and both are worth holding in mind because they lead to different incentives and outcomes. In a slow-growth trajectory, adoption happens gradually: treasuries and institutional holders start using USDf for short-term liquidity and a trickle of real-world integrations appear, yields are modest but steady, and the protocol tightens risk controls as it learns, which makes the whole system resilient but not headline-dominant. That’s a healthy outcome for long-term credibility because the protocol builds tooling and trust before scale. In a fast-adoption trajectory, partnerships, exchange listings, and payment rails accelerate usage quickly, liquidity deepens, and USDf becomes a common onchain dollar for commerce and $DEFI ; this unlocks large utility and network effects but also stresses governance, oracles, and reserve diversification choices, meaning the protocol must respond quickly to scale operational controls and legal frameworks. We’re seeing both elements in the market: capital and partners are interested — with meaningful investments and integrations being announced — and that’s promising, but it also means the team needs to remain conservative in its risk assumptions because growth amplifies both benefits and failures.
Real human trade-offs — I’ve noticed that people using these systems are rarely motivated by the same thing: some want yield, some want working capital, some want a stable unit for onchain payments, and some are managing a treasury that cannot be sold off. Falcon’s model respects those differences and asks us to accept trade-offs: you get liquidity without selling, but you accept protocol-level custody and the need to trust reserve attestations and governance processes; you get yields through staking, but those returns are anchored to the protocol’s strategy and risk appetite rather than to zero-risk banking rates; you gain convenience and optionality, but you also accept that tokenized RWAs and offchain links require more operational transparency than purely native onchain assets. These are human trade-offs, not abstract ones, and being explicit about them helps teams choose the right tool for each job rather than treating USDf as a universal panacea.

Interoperability and real-world bridges — part of what could make a system like this matter to regular people is if the liquidity becomes useful in everyday contexts, and we’re already seeing early moves toward payments and merchant acceptance, which is the natural next step if you want USDf to be more than an onchain instrument and instead a functional medium of exchange. Integrations with payments frameworks and exchange campaigns help move USDf from a purely DeFi primitive into a medium that can settle purchases or payroll, but those integrations bring additional compliance and settlement considerations that the protocol and its partners will need to manage carefully. It’s one thing to have a stable synthetic dollar inside wallets; it’s another to have that dollar accepted at a neighborhood merchant, and both steps require different sets of engineering and policy work.
A human closing note — I’m often skeptical of grand pronouncements about “redefining finance” because the real work is mundane, iterative, and slow, but Falcon’s approach appeals to me because it’s fundamentally practical: give people ways to make assets useful without punishing them for holding what they believe in, insist on transparency where it matters, and design conservatively so the system can be lived in rather than merely admired from afar. If you work in a treasury, run a project, or just carry multiple assets and wish they could do more for you, the idea here is simple and human: convert idle ownership into usable capital without forcing a divorce from the asset itself, and do it in ways that respect safety, transparency, and utility. That balance is hard, and the outcome isn’t predetermined, but the choices the team has made so far put them on a path that could either become a steady, useful layer of modern finance or, if mismanaged, a lesson in the limits of synthetic credit; I’m watching the reserve attestations, the collateral diversification, and the real-world integrations because those will tell the story, and I’m cautiously optimistic. If you’ve read this far, know that I’m not selling you an idea; I’m describing a system I’d personally watch closely, because when infrastructure is built with the intention of making assets work for people rather than simply for speculation, that’s the kind of work that changes lives slowly and meaningfully, and that’s worth paying attention to as it unfolds.
$DEFI #USDF

Introduction why this matters to me and to you and why $KITE shows up now in the conversation about money and machines, and people living alongside them — I remember when payments were simply about moving money between people and businesses, and the idea that autonomous agents could one day act with their own verifiable identity and make real economic choices sounded like science fiction, yet here we’re at a point where that fiction is beginning to feel inevitable, and Kite’s design feels like a careful attempt to bridge two worlds that don’t always speak the same language: human social trust and machine-scale coordination. I’m drawn to projects that start from real human problems rather than clever code alone, and $KITE reads like that kind of effort because it asks a simple question first: what would it take for an AI agent to transact on behalf of a person or service in a way that everyone — the humans, the agents, and the institutions — can trust? The answer Kite gives is a layered, identity-aware blockchain where payments happen in real time, governance is programmable, and identity is separated into three distinct layers — user, agent, and session — so that control, privacy, and accountability can coexist without one overwhelming the other.
How it works from the foundation up: the chain, the identity, and the flow — if you want to understand Kite, start by picturing a foundation that is deliberately #evm -compatible because that choice widens the doorway into an existing developer ecosystem and avoids making everyone relearn the basics; being a Layer 1 designed for real-time transactions means the whole stack — consensus, mempool handling, transaction validation, and finality — is tuned toward low latency and predictable throughput so agents that need to negotiate and settle quickly can do so without long waits. On top of that base, Kite’s three-layer identity system is the conceptual heart: users are the human principals who own long-term credentials and legal claims, agents are software entities granted delegated authority to act within bounded scopes, and sessions are ephemeral contexts that record exactly what an agent is allowed to do at a particular time. I’ve noticed that this separation is more than academic: it’s a practical design that reduces blast radius, because a compromised session key is far less destructive than a compromised user key, and an agent’s power can be tightly constrained and auditable without disrupting the human owner’s wider hold on their assets. Transactions themselves are ordinary blockchain transfers in structure, but they carry metadata about agent identity, session parameters, and attestations that allow on-chain verification of who authorized what and when; that means a merchant can accept a payment and be confident it was properly delegated by a human, and a regulator or auditor can later trace authorization flows without necessarily exposing raw personal data.
Why it was built and what real problem it solves — we’re seeing the first real use cases where autonomous software needs to act with economic agency: subscription managers that autonomously top up services, supply chain bots that pay for freight dynamically, and multi-agent marketplaces where buyers and sellers use bots to negotiate complex contracts in real time. The problem up until now has been twofold: how to let machines act without turning every transaction into an opaque black box, and how to protect users when they want convenience and delegation without giving away permanent control. Kite answers both by making delegation explicit and auditable, by separating identities so you can revoke or rotate sessions quickly, and by designing a chain that can move money fast enough for micro-transactions and conditional flows. If it becomes a place where agents can reliably interact, we’ll see new classes of services that are impractical today because latency, cost, or trust overheads make them uneconomic.
The technical choices that truly matter and how they shape what you actually experience — choosing EVM compatibility matters because it lowers friction for developers and unlocks existing tooling, smart contracts, and audited libraries; choosing a Layer 1 rather than a sidechain or Layer 2 matters because it gives you the security model and finality guarantees of a native network while allowing the protocol to co-design identity and settlement without intermediary dependencies. On consensus, Kite’s focus on real-time means consensus must trade some raw decentralization incentives for faster finality and lower variance in confirmation times: that choice shapes the kinds of validators the network attracts — those willing to operate high-availability infrastructure and support low-latency networking — and it also changes the economics of transactions, because predictability tends to reduce friction. The three-layer identity model itself is a huge technical and $UXLINK statement: building protocol-level support for attestations, delegation, and session scoping forces smart contract patterns to anticipate identity metadata on transfers and calls; that affects gas usage, contract design, and off-chain tooling because developers will now code with a model where every call potentially carries authorization baggage. Practical choices like how long sessions last by default, how agent credentials are minted and revoked, how identity attestations are stored (on-chain vs off-chain), and how privacy-preserving mechanisms like selective disclosure or zero-knowledge proofs are integrated will all determine whether the platform feels convenient or cumbersome to everyday users. I’m also struck by the phased token utility: launching #KİTE as an ecosystem incentive first makes sense because a new L1 needs activity to prove the network, and then adding staking, governance, and fee functions later allows the token to accrue real protocol governance power only after the community forms and the security assumptions are clearer.
What important metrics to watch and what those numbers mean in practice — the first number to watch is throughput (transactions per second) and latency to finality because those determine whether agents can actually coordinate in real time; for example, an agent negotiating a micro-contract for compute resources can’t wait for minutes to know whether payment cleared, so you want low-latency finality measured in seconds or sub-seconds for many use cases. Second, watch active agents and session churn: the number of distinct agents and the average session duration tell you whether real-world automation patterns are emerging, because a platform with millions of sessions but few unique agents might be seeing noisy automated testing rather than meaningful agent economic activity. Third, fee predictability and fee levels are crucial — we need to measure median gas cost per common operation and the variance during peak times because agents need cost forecasts to run economically; if fees spike unpredictably, agent strategies become risky. Fourth, monitor on-chain identity attestation rates and revocation latencies: how quickly can a user revoke a compromised agent or session and how well does that action propagate to nodes and smart contracts? Fifth, security metrics like the frequency of smart contract audits, number of critical vulnerabilities found and fixed, and total value at risk (TVAR) in agent-controlled wallets provide a real sense of systemic risk. Finally, governance participation rates and token distribution metrics show whether the network’s future is likely to be shaped by a broad user base or a few concentrated holders; high staking participation with a diverse validator set is a good sign, while token concentration is a legitimate structural risk.
Real structural risks and weaknesses without exaggeration — no system is without weakness, and Kite’s strengths point to natural vulnerabilities that need sober attention. Identity complexity can be a double-edged sword: while separating user, agent, and session reduces blast radius, it also introduces more moving parts that can be misconfigured by developers or misunderstood by users, and human error remains a major attack vector. A compromised identity attestation or poorly written delegation logic in a smart contract could allow an agent to overstep its scope in ways that are subtle and hard to revert. On the economics side, token phasing implies an interim period where #KİTE has utility but lacks mature governance and staking mechanisms, and in that window incentives can skew toward opportunistic actors who are primarily chasing grants or early rewards rather than sustainable network participation. There’s also the reality that to achieve low-latency finality, networks often adopt consensus optimizations that reduce validator diversity or increase reliance on specialized infrastructure, which can raise concerns about censorship-resistance and decentralization in practice. Privacy is another hard trade-off: making authorization auditable for accountability can conflict with user privacy expectations, and the choices about how much data to store on-chain versus off-chain will determine whether the network can support both transparency and confidentiality. Finally, regulatory risk is non-trivial — a chain designed to enable autonomous economic actors changes how legal frameworks think about liability, and if regulators decide to treat agentic payments as creating novel financial instruments or require stricter #kyc around agent identities, the platform could face compliance burdens that shape its evolution.
How developers and operators will actually build on it in day-to-day terms — in practice, building for Kite means thinking in three layers at once: write smart contracts that expect identity attestation headers, design user experiences that make session delegation and revocation frictionless and obvious, and design agents with robust fallback behaviors when the network has congestion or temporary fee spikes. Developers will need libraries and #SDKs that make session creation, renewal, and revocation simple, because the human who authorizes an agent should not have to manually fiddle with cryptographic keys. Operators running validator nodes will need to optimize for low-latency networking and careful monitoring of mempool and finality times; they’ll also need good tooling for key management that respects the layered identity model, because validators may need to verify attestations or enforce slashing conditions tied to identity-based governance. For end-users, wallets must evolve to show not just balances but active sessions, granted permissions, and a clear path to revoke those permissions; I’m hoping wallets will make it as easy to cut off an agent as it is today to log out of a web app, because convenience without control is a recipe for regret.
A realistic view of adoption: slow growth and fast-adoption scenarios — if adoption is slow, Kite will likely grow through niche, high-value use cases where real-time agent coordination produces clear ROI: supply chains that pay carriers dynamically based on delivery performance, IoT ecosystems where devices autonomously purchase maintenance credits, or marketplaces for compute where latency-sensitive micro-payments matter. In that scenario we’re seeing measured, stable growth, grants used to bootstrap developer activity, and protocol upgrades rolled out conservatively. Token utility will mature gradually, governance will be concentrated at first and gradually decentralize as more stakeholders join, and the primary risks will be executional — making #SDKs robust, building partnerships, and keeping fees predictable as load increases. If adoption is fast, you’ll see an explosion of agents across consumer and enterprise verticals, sudden pressure on throughput and fee markets, and a rapid necessity to iterate on governance and economic parameters; that scenario brings its own hazards because fast growth magnifies design trade-offs and can expose unanticipated attack surfaces, but it also accelerates the network’s path to meaningful decentralization because more actors have skin in the game. Both paths demand strong observability: knowing not just how many transactions happen, but who the agents are, what session patterns look like, and how revocations and disputes are resolved in practice.
Economic mechanics and what #KİTE phased utility means for participants — the phased rollout of token functions is important, because tokens that confer governance and staking roles too early can centralize power before a proper distribution of stakeholders exists, and tokens that have no utility can fail to sustain network effects. In Kite’s two-phase approach, early KITE is used primarily for ecosystem participation and incentives, which means developers and early users are paid to build and prove use-cases, creating organic demand for the network’s native economic layer. Later, when staking and governance arrive, KITE holders will be able to lock tokens to secure the network and participate in protocol decisions, and fees may be partially consumed or burned, which ties tokenomics to network usage. In practice, this matters because participants need to know whether holding KITE today is a bet on future governance power, an immediate source of income through incentives, or both; token velocity, staking #aprs , and the fee model will determine whether KITE accrues value and whether that value is reflected in long-term stewardship or short-term speculation.

Security practices that should not be overlooked — I’ve noticed that the smartest teams invest heavily in incident response rehearsals and catastrophic revocation plans because the uniqueness of agentic identity systems raises new failure modes: a misbehaving agent can perform many small harmful actions that compound invisibly, so observability, rate limiting, and anomaly detection are essential. Formal verification for core identity and delegation contracts, layered audits for the runtime, and bounty programs targeted to the identity and session layers are sensible minimums. The governance model should include emergency procedures for urgent revocations or protocol pauses that are tightly specified and require multi-party checks to avoid misuse, because a system that can halt fast must be built with transparent guardrails. I’m also keen on seeing standard patterns for safe agent design, for example default-deny delegation templates and automatic session expiration policies that make safety the easy path for developers and users.

A human-centered perspective on permissions, autonomy, and trust — above all, the story of Kite is about trust between humans and machines. Agents can make life easier: they can manage subscriptions, negotiate micro-deals, and optimize small but frequent decisions so humans don’t have to think about them, and yet the moment we hand any degree of autonomy to software we ask society to accept a new model of responsibility. Who is accountable when an agent takes action? Kite’s three-layer identity model is a practical answer because it gives us a way to map actions to delegations and to contain the scope of that delegation, but accountability still requires human-facing UX, clear legal frameworks, and cultural adoption. I’m hopeful because the technology allows these conversations to be concrete: instead of abstract worries about rogue AI, we can talk about session tokens, revocation latencies, and audit logs that are visible to a user and to a third party when needed.

How the future might realistically unfold — in a slow-growth world, Kite becomes a trusted rails provider for enterprise and specialized consumer applications, carving out a stable niche and refining its governance and identity tooling over years, while interoperability bridges bring occasional bursts of activity when large dApps decide to use agentic features. In a fast-adoption world, Kite becomes a backbone for a new genre of commerce where software agents transact billions in micro-payments daily, user interfaces evolve to treat agent permissions like account permissions, and legal systems begin to codify responsibilities for delegated actions; this rapid path requires intense focus on privacy-preserving authorizations, dispute resolution infrastructures, and robust economic designs that align long-term incentives. Either way, success is unlikely to be a single viral moment and more likely a slow accretion of reliable patterns, developer tools, and clear signals that agents acting with verifiable identity reduce real human friction without creating unacceptable new risks.

A soft closing thought: I’m excited by the way Kite frames a future that is not just about faster settlement or clever cryptography but about making delegation, autonomy, and accountability feel natural for people who just want their digital helpers to be useful and safe. There’s a lot of careful engineering ahead — from identity attestation schemes to predictable fees, from session UX to governance maturity — and we shouldn’t pretend those are trivial problems, but the model Kite proposes feels honest about the trade-offs and rooted in real world needs rather than pure speculation. If we build these systems with humility, transparency, and a focus on human control, we stand a chance of making a world where agents genuinely extend human capability rather than complicate it, and that possibility is quietly hopeful in a way I find worth paying attention to.

2024 年迄今，高市值的新发币种着实不少，其中不乏加密游戏类项目。随着币价整体反弹和空投活动层出不穷，与加密游戏和各网络相关的代币已成为今年发行规模最大的赛道之一。
Notcoin、Portal、Pixels…本文将按照撰稿时的数据介绍市值 TOP10 的游戏代币。
1. Notcoin（NOT）
峰值价格：0.02896 美元
峰值市值：29.7 亿美元
一个新的卫冕冠军，而且甩出其他项目好几条街。Notcoin 于 5 月在 The Open Network (TON) 上推出了其 NOT 代币，在向约 3500 万玩家提供空投的刺激下，其市值迅速飙升至近 15 亿美元。

当然，与许多新发行的代币一样，早期的价格走势波动很大，不久后就下跌了……但随后在 6 月份飙升至新高，市值达到近 30 亿美元的峰值，2024 年没有其他新游戏代币能与其竞争。不过，随着大量基于 Telegram 的新游戏的涌现并覆盖更广泛的受众，热度将集中在那些还未发币的项目上。
2.PIXEL（PIXEL）
峰值价格：1.02 美元
峰值市值：7.31 亿美元

以太坊目前最热门的游戏也是今年最大的代币之一。PIXEL 代币于 2 月下旬推出，用于以太坊扩展器 Ronin 上的休闲农场游戏，并帮助将更多加密原生元素引入网络游戏。它还在不到一天的时间内产生了价值超过 10 亿美元的交易。
Pixels 拥有数十万的日常用户，吸引了加密社区的关注，也帮助 Ronin 建立了一些强大的势头。3 月中旬，PIXEL 的价格突破 1 美元，占据了榜首位置，直到被 Notcoin 赶超。自那时以来，更多代币被解锁，尽管截至撰写本文时，PIXEL 的价格也大幅下跌。
3. Saga（SAGA）
峰值价格：7.60 美元
峰值市值：6.84 亿美元
虽然并非专门的游戏链，但第一层 Saga 网络最初的大部分推广都围绕游戏展开，包括开展「玩转空投」活动，以及公布内部游戏发行部门 Saga Origins 的计划。据 Saga 称，大约 80% 的测试网项目都集中在游戏上。

SAGA 代币引起了巨大轰动，首先是创纪录的币安新币活动，客户押注了价值超过 134 亿美元的资金来获得 SAGA 奖励，然后价格达到峰值，使该代币在今年到目前为止在榜单上排名第二。未来还会有更多空投奖励。
4. Portal（PORTAL）
峰值价格：3.36 美元
峰值市值：5.616 亿美元
Portal 于 2 月 29 日刚刚推出，其热度之高在加密游戏领域已久未见。部分原因是空投挖矿活动推动用户在 Twitter 上发推文，而当时创纪录的币安活动也推动用户押注价值超过 90 亿美元的加密货币，希望获得受益。

然而，价格下跌得相当快，截至最新更新，还远未恢复到原来的水平。即将推出的跨链游戏平台的这款基于以太坊的代币能否重新获得热度？
5.Xai（XAI）
峰值价格：1.59 美元
峰值市值：4.406 亿美元

以太坊扩容器 Arbitrum 上的 Xai 第 3 层游戏网络进行了今年的首次大型空投，奖励了网络守护节点的所有者和运营商以及某些 NFT 持有者。到目前为止，XAI 开局不错，最高价格比下跌时高出一倍多。
游戏开始在网络上推出，这应该会引起人们对代币的更多关注和兴奋，此外 Xai 最近也推出了权益奖励。
6. Catizen（CATI）
峰值价格：1.11 美元
峰值市值：3.386 亿美元

最后，另一款重要的 Telegram 游戏注入了新鲜血液。虽然 Catizen 的代币尚未达到 Telegram 先驱 Notcoin 的高度，但此次发布确实表明，一旦其代币进入市场，此类游戏将具有巨大的吸引力——尽管 Catizen 代币的分发方式在玩家中引起不小争议。
Catizen 是继 Notcoin 之后第二波 Telegram 游戏中最热门的游戏之一，但它的价格是否会维持在这一水平——或者会进一步上涨仍需观察，当然，还有其他大型 Telegram 游戏，如 Hamster Kombat 和 X Empire，它们很快就会在这个名单上争夺一席之地。
7. Heroes of Mavia (MAVIA)
峰值价格：10.59 美元
峰值市值：3.177 亿美元
Heroes of Mavia 是今年最大的新加密游戏发布之一。《部落冲突》克隆版在 iOS 和 Android 上吸引了数百万次下载，Skrice Studios 通过向 100,000 名早期玩家空投代币来庆祝发布，同时还向之前质押了 NFT 的虚拟土地所有者空投代币。

MAVIA 在 2 月份发布后价格大幅上涨，突破 10 美元，比开盘价上涨了 5 倍多。但这只是昙花一现，此后其价值缩水了 80% 以上，游戏团队选择推迟并削减一些代币解锁，以减轻对市场的潜在影响。
8. Gaimin（GMRX）
峰值价格：0.03937 美元
峰值市值：2.612 亿美元

Gaimin 旨在通过去中心化的云计算平台为加密游戏提供支持，让用户贡献闲置的计算资源来获得奖励。该平台的 GMRX 代币于 3 月底刚刚推出。
虽然单个代币的价格很低，但流通量却相当可观，推动市值峰值达到 2.61 亿美元。不过，截至撰写本文时，价格已下跌超过 95%，因此我们拭目以待 Gaimin 能否在短期内回到这一水平附近。
9.Zentry（ZENT）
峰值价格：0.045 美元
峰值市值：2.487 亿美元

ZENT 于 4 月下旬推出，是 Zentry 的原生代币，Zentry 是一个由加密游戏公会转型而来的游戏奖励平台，之前称为 GuildFi。随着品牌重塑，该公司推出了一种新的以太坊代币，并为现有的 GF 持有者提供转换率以过渡到 ZENT。
Zentry 的新代币在一个月后价格达到顶峰，将其市值推高至历史最高点，略低于 2.5 亿美元——尽管像许多游戏代币（以及广泛的加密代币）一样，它自那以后急剧下跌。
10. Apeiron（APRS）
峰值价格：1.88 美元
峰值市值：1.936 亿美元

Apeiron 是一款热门的 Ronin 策略游戏，目前正在举办游戏空投活动，并且最近还在网络的首次代币销售中推出了其 APRS 生态系统代币。
在发布之日，该代币的市值接近 2 亿美元，尽管与上文提到的 Gaimin 一样，其价格自发布之日起有所下跌。不过，其涨幅足以让它跻身此榜单——而且该游戏尚未完全发布。

#NOT🔥🔥🔥 #PIXEL #SAGA新币 #aprs