矿工如何参与:从注册、证明到 60 天释放 How to mine on Falari: registration, proofs, and 60-day vesting
矿工不是把硬盘接上链就会收到奖励。链先确认你锁定了多少质押、endpoint 能否被派单,然后按分片分配工作;你签名回执、在每个 epoch 回答存储挑战,质量乘数把这些表现折算成权重,epoch 预算再按权重分配。早期奖励就是这套协议发行,没有额外的活动补贴,也没有固定年化。 Plugging in a disk does not earn rewards. The chain first checks how much stake you locked and whether your endpoint can be assigned work, then hands out shards. You sign receipts, answer storage challenges every epoch, and a quality multiplier turns that record into weight; the epoch budget is split by weight. Early rewards are this protocol issuance — there is no separate campaign bonus and no fixed yield.
On this page
矿工的收益来自两条独立的流:协议每个区块发行的存储预算,以及用户为存储支付的费用。前者按有效存储权重分配,后者按回执持有量分配,两者都要经过同一个 60 天释放队列。理解这条结构,比记住任何一个 APY 数字都重要。
01先决条件:一台能被派单的矿机
注册矿工是一笔链上交易 MsgRegisterMiner。矿工用自己的账户签名,声明一个 endpoint、一个自报容量和一笔质押;质押会从账户转入模块账户锁定,注册本身收取 0.1 FAR 的服务费。注册成功后状态为 active,链上开始把它视为可派单的候选。
质押不能低于链上参数 min_miner_stake。代码默认值与当前测试网创世参数都是 1,000 FAR,实际值以 /rpc/status 返回的 params.min_miner_stake 为准。低于门槛的交易会被直接拒绝,不存在「先注册后补质押」的路径。
endpoint 必须是公网可达的地址。派单时会经过 EndpointUsable 过滤,回环、私网和链路本地地址都会被排除。一个把 endpoint 写成 localhost 的矿工可以在链上显示 active,但不会收到任何新分片——这是测试环境里最常见的「矿工在线却没收益」原因。
容量是自报的,链上不验证磁盘。容量下限由 min_miner_capacity_bytes 控制:代码默认 300 GB,当前测试网创世覆盖为 50 GB,低于下限的注册会被拒绝。容量只影响派单时的选择权重,不会提高奖励上限;真正决定你能计多少有效存储的是质押。空闲磁盘检查发生在客户端:falari-miner 启动时要求数据目录所在卷达到 -min-free-disk 指定的空闲量(示例传 100 GiB),这是运维保护,不是共识规则。
cd evm
CGO_ENABLED=0 go build -o build/falari-miner ./cmd/falari-miner
export MINER_PRIVATE_KEY=<0x private key>
./build/falari-miner \
-gateway https://trpc.falari.xyz/rpc \
-data ./data/miner -addr :9090 \
-endpoint http://<public ip>:9090 \
-capacity 1099511627776 \
-stake 1000000000000000000000 \
-min-free-disk 107374182400
启动时客户端会先查一次链上记录。若同一地址已经是 active,它不会重复注册:链上会拒绝 active 矿工的再次注册。endpoint 不一致时,矿工仍会继续证明,但只会服务本地端口;要换 endpoint,需要走 provider 公告路径,或先退出再重新注册。
02接单:分片、回执与结算
矿工不能挑文件。每个 intent 的每个(段,分片)对,由链上按 active 矿工的容量加权、确定性选出承接者;同一个 intent 在所有节点上得到相同的分配结果,没有中心调度器。客户端随后把 6 个分片分别上传给被选中的矿工。
矿工收到分片后先重算分片哈希,确认字节与分配一致,再用账户密钥签名一条回执。回执里带着 intent、段号、分片号、分片哈希、segment_root 和 Merkle 路径。客户端收集回执并提交 MsgBatchCommit;每段至少 4 份来自不同分片的有效回执,MsgFinalizeDeal 才会通过。
结算之后,矿工才真正开始「持有有效存储」。计权时链按 (miner, shard_hash) 去重:同一份物理分片被多个 intent 引用只算一次。容量检查和退出检查则使用全部回执字节,不去重。前者防止自买自卖刷权重,后者防止矿工在仍持有数据时退出。
03每个 epoch 的三十次证明
链按 60 秒一个 epoch 推进。每个 epoch 产生 30 条存储挑战,每条从矿工持有的回执里选一条,再随机选一个 4 KiB 叶子。矿工返回该叶子的原始字节、哈希,以及从叶子到 shard_hash 的 Merkle 路径。截止时间是 300 秒,超时即记一次失败。
falari-miner 默认每 15 秒轮询一次 /challenges?pending=true&miner=…,把一轮里所有未过期的挑战合并进一笔交易,单笔最多带 8 条证明。合并不是优化选项:同一账户的交易只能一笔一笔上链,逐条提交时后面的挑战往往在落块前就过期了。
在 mining v2 里,答对证明不再按次发币,proof_reward 为 0。证明只做两件事:维护质量乘数里的成功率,以及维持「未被降级」的状态。把证明从收入来源改回完整性检查,是这一版经济模型最重要的变化。
新矿工有一条窄门:奖励资格要求至少答对过一次证明,但在前 6 次被分配挑战之前不强制。之后如果仍未答对,就会暂时退出奖励分配,但仍留在审计池里——审计资格和奖励资格是分开的,避免新矿工因为从未被抽中而永远无法证明自己。
检索探针是另一条路径:每个 epoch 全网最多 1,800 条、单个矿工最多 3 条,随机向矿工索取指定分片,30 秒内应答。错过探针不会增加存储证明的失败计数,也不会直接触发降级;探针本身不再发放任何链上奖励,只记入探针账本,作为线下评估检索奖励的依据。只要历史上成功过一次,检索维度在质量乘数里就记为满分。
04质量乘数:0.5× 到 1.5×
质量乘数把三类记录折算成一个分数,再把分数映射到 0.5×–1.5×:
- 证明成功率 60%。
ProofSuccess / (ProofSuccess + ProofFailure),从矿工记录创建起终身累计,不按 epoch 衰减。 - 可用性 25%。链上存在一条未过期的 provider 公告记录(
MsgAnnounceProvider,默认有效期 1,200 秒)时记满分。 - 检索 15%。只要
RetrievalProbeSuccess > 0就记满分,同样终身累计。
公式是 multiplier = 0.5 + score,其中 score 是上面三项的加权和,取值 0–1。三项全满时是 1.5×;证明满分但没有公告、也没有检索成功时是 1.1×。这是一条缓慢移动的曲线:早期的失败会一直留在分母里,直到矿工记录被重建。
当前 falari-miner 不会自动发送 MsgAnnounceProvider,网关也没有对应的写入路由。默认部署下,可用性维度是 0,质量乘数最多只能到 1.25×(证明与检索都满分)。要让这 25% 生效,需要由运营工具直接构造公告交易,并保持记录不过期。
05有效存储:质押给权重设上限
每个 epoch 分配预算时,矿工的权重是:
stake_far = floor(stake_wei / 1e18)
capped_bytes = min(stored_bytes, stake_far × 1 GB)
weight = capped_bytes × quality_multiplier
这条上限是反女巫设计的核心:每 1 FAR 质押最多让 1 GB 的存储计入权重。50 FAR 最多计 50 GB;1,000 FAR 最多计 1 TB。少于 1 FAR 的质押会得到 0 上限,也就没有权重。自买自卖可以把 stored_bytes 做大,但无法越过这条线。
容量与质押是两件事:容量决定派单概率,质押决定计权上限。一台申报了 100 TiB、只质押 50 FAR 的矿机可以接到很多分片,但只有前 50 GB 会计入奖励权重。低于 1 FAR 的尾数会被整数除法截断,不产生上限。
只有 active 且 stored_bytes > 0 的矿工进入分配。degraded 矿工被排除;如果一个 epoch 里没有任何合格候选,整笔预算退回存储池,不会凭空消失。
06一个 epoch 的预算从哪里来
存储流按余额驱动衰减:每个池每年支付剩余余额的 25%,区块发行量由当年预算和逐块上限共同决定。首年满档、5 秒出块时,存储流每块最多 118.91 FAR:其中 2%(2.38 FAR)注入永久存储基金,剩余 98%(116.53 FAR)被预留给当前打开的 epoch。60 秒的 epoch 在 5 秒出块下大约包含 12 个区块,因此一个完整 epoch 的预算上限约为 1,398.38 FAR。容量档位尚未爬满或存储池余额偏低时,每块实际发行会更少——空网地板档约 23.78 FAR。
epoch 关闭时,预算按权重比例分给候选矿工:share = budget × weight / total_weight。地址排序后,舍入余数给最后一个候选,保证每个节点算出相同结果。没有分完的部分退回存储池。
| 项目 | 数值 | 说明 |
|---|---|---|
| 存储流发行(首年满档) | 118.91 FAR / 块 | 按 5 秒出块估算;空网地板档约 23.78 |
| 永久基金 | 2.38 FAR / 块 | 2%,注入上限受基金余额约束 |
| epoch 预算 | 116.53 FAR / 块 | 98%,预留给打开的 epoch |
| 每日毛发行(首年满档) | 2,054,765 FAR | 17,280 块 × 118.91 FAR |
| 每日 epoch 预算上限 | 2,013,670 FAR | 17,280 块 × 116.53 FAR |
这是发行上限,不是收益率。实际分配到每个矿工的金额取决于全网总权重、池子余额和 epoch 内是否有人缺席;存储池余额不足时,每块只发行剩余的部分,发完即止。也不能用 2,013,670 FAR 除以全网质押去推一个年化——权重里还有质量乘数和 1 GB/FAR 的封顶。
代码里没有独立的早期挖矿活动、空投合约或额外补贴。早期参与者拿到的就是上面这套协议发行。早期唯一的优势是竞争权重较小、相对份额较高;没有任何保本、固定年化或最低收益承诺。
07用户付的存储费如何到矿工手里
用户 finalize 一笔存储订单时支付的费用,按 0% 基金会、3% 验证者、3% 检索、94% 矿工拆分。矿工的 94% 不会当场支付,而是进入 pending_miner_release,在用户购买的那个存储窗口内按 epoch 线性释放。每次释放前要过三道闸:订单仍然存活、矿工不是 degraded、且没有未清零的连续证明失败。
续约会产生一个新的 tranche,起点是上一段窗口的到期时间,因此续约的钱不会在用户已经付过的窗口里提前释放。用户提前终止订单时,尚未释放的部分退回用户,而不是矿工。
释放出来的那一刀,不会直接进矿工余额,而是先进入同一个 60 天释放队列。换句话说,存储费要经过「按窗口释放 + 60 天线性释放」两层延迟;这既防止 escrow 在第一天被抽干,也让矿工有理由持续证明、持续服务。
0860 天释放与领取
每一笔入账(epoch 分配、修复奖励、释放的存储费)都记进矿工当天的 UTC 日桶。每个桶从次日开始,按 60 个完整 UTC 日线性释放:第 n 天可领 total × n / 60。当天入账当天不可领,因为 elapsed = 0。
例如某矿工在 D 日入账 900 FAR:D 日可领 0;D+1 日可领 15 FAR;D+2 日可领 30 FAR;到 D+60 日全部可领。整数除法产生的余数留在桶里,最终由最后一段释放。不同日期的桶各自计算,互不影响。
领取要发一笔 MsgClaimMiningRewards,签名者就是矿工账户。它会把所有桶里已释放但未领取的部分一次性付出,返回 claimed 和领取后仍可领的 claimable。没有自动领取,也没有后台代付;不主动发交易,钱就留在链上。
查询入口是 GET /miners/{address}/rewards,返回 total_earned、total_released、claimable 和逐日桶。金额统一是 wei 十进制字符串,18 位小数等于 1 FAR。
09罚没、降级与退出
一条挑战过期就记一次 ProofFailure,连续失败数加一,并按该分片的大小扣押路由容量,答对后返还。连续失败持续满一个窗口(degrade_after_failed_epochs × epoch_interval_seconds,默认 720 × 60 秒 ≈ 12 小时)后,矿工转为 degraded 并触发一次罚没:目标是当前质押的 1%,直接从质押扣除,硬上限是质押的 100%(最多扣光),冷却时段内最多执行一次。扣走的资产进入用户补偿池,而不是销毁。
degraded 不参与 epoch 分配,存储费也不会释放给它,但它仍留在审计池里。答对一条存储证明即可恢复 active;如果罚没后质押低于服务下限,则必须先补足质押。失败期间每再跨过一个窗口都会重复罚没,所以长期离线不会只损失 10%。
主动退出用 MsgDeregisterMiner,前提是 used_bytes == 0:仍持有数据时不允许退出。退出会把剩余质押退回账户,状态置为 exited。重注册会创建一条新的矿工记录,旧的证明计数不会继承。
10上线前检查
- 确认
min_miner_stake、epoch_challenges、proof_deadline_seconds与当前链上参数一致,不要照抄旧文档。 - endpoint 从公网可访问,且没有落在私网或回环地址;注册后确认
GET /miners/{address}返回 active。 - 数据目录所在卷满足空闲磁盘门槛;
-data指向持久卷,不要放在临时目录。 - 证明轮询和交易广播正常:日志里应持续出现 proof submitted,而不是 challenge expired。
- 若要让可用性维度生效,另发
MsgAnnounceProvider并保持有效期;当前 CLI 不会代劳。 - 定期查看
GET /miners/{address}/rewards的 claimable,临近 60 天的部分及时领取。
把整套机制压缩成一句话:质押决定你能计多少存储,证明和可用性决定这些存储打几折,epoch 预算按折后权重分配,所有入账再放进 60 个 UTC 日桶里逐日释放。
A miner earns from two separate streams: the protocol's per-block storage emission and the fees users pay for storage. The first is split by effective storage weight, the second by receipt share, and both pass through the same 60-day release queue. Understanding that structure matters more than memorising any APY number.
01Prerequisites: a machine that can be assigned work
Registering a miner is an on-chain transaction, MsgRegisterMiner. The miner signs with its own account and declares an endpoint, a self-reported capacity, and a stake. The stake moves from the account into the module account; registration itself costs a 0.1 FAR service fee. Once registered, the record is active and the chain starts treating it as an assignment candidate.
Stake cannot be below the on-chain min_miner_stake. Both the code default and the current testnet genesis value are 1,000 FAR; the live value in params.min_miner_stake from /rpc/status is authoritative. A transaction below the floor is rejected outright — there is no “register now, top up later” path.
The endpoint must be publicly reachable. Assignment filters candidates through EndpointUsable, which rejects loopback, private, and link-local hosts. A miner advertising localhost can look active on chain and still receive no shards. This is the most common “online but earning nothing” failure in test environments.
Capacity is self-reported and the chain does not verify disk. The capacity floor is set by min_miner_capacity_bytes: the code default is 300 GB and the current testnet genesis override is 50 GB; registrations below the floor are rejected. Capacity only affects assignment probability; it does not raise the reward cap. What actually limits how much storage counts is stake. The free-space check lives in the client: falari-miner requires the data volume to meet the free space given by -min-free-disk (the example passes 100 GiB). That check is an operator safeguard, not consensus.
cd evm
CGO_ENABLED=0 go build -o build/falari-miner ./cmd/falari-miner
export MINER_PRIVATE_KEY=<0x private key>
./build/falari-miner \
-gateway https://trpc.falari.xyz/rpc \
-data ./data/miner -addr :9090 \
-endpoint http://<public ip>:9090 \
-capacity 1099511627776 \
-stake 1000000000000000000000 \
-min-free-disk 107374182400
On startup the client checks the chain first. If the address is already active, it does not register again — the chain rejects re-registration of an active miner. If the endpoint differs, the miner keeps proving but serves only on its local port; changing the endpoint requires the provider announcement path, or exiting and registering again.
02Work: shards, receipts, and settlement
A miner does not choose files. The chain deterministically assigns every (segment, shard) pair of an intent to an active miner, weighted by capacity. Every node derives the same assignment for the same intent; there is no central scheduler. The client then uploads the six shards to their assigned miners.
On receipt, the miner recomputes the shard hash, confirms the bytes match the assignment, and signs a receipt with its account key. The receipt carries the intent, segment index, shard index, shard hash, segment_root, and a Merkle path. The client collects receipts and submits MsgBatchCommit; MsgFinalizeDeal succeeds only when each segment has at least four valid receipts from distinct shards.
Only after settlement does the miner hold effective storage. Weight accounting deduplicates by (miner, shard_hash): the same physical shard referenced by several intents counts once. Capacity checks and exit checks use all receipt bytes without deduplication. The first rule stops self-dealing from inflating weight; the second stops a miner from exiting while it still holds data.
03Thirty proofs per epoch
The chain advances in 60-second epochs. Each epoch produces 30 storage challenges. A challenge picks one of the miner's receipts and one random 4 KiB leaf; the miner returns that leaf's bytes, its hash, and the Merkle path from the leaf to shard_hash. The deadline is 300 seconds; a timeout counts as a failure.
falari-miner polls /challenges?pending=true&miner=… every 15 seconds by default and batches every unexpired challenge in a round into one transaction, up to eight proofs per transaction. Batching is not optional polish: one account's transactions land one at a time, so submitting proofs individually means later challenges often expire before inclusion.
Under mining v2, answering a proof no longer pays per proof — proof_reward is zero. Proofs do two things: maintain the success ratio inside the quality multiplier and keep the miner from being degraded. Turning proofs from an income stream back into an integrity check is the most important change in this economic model.
New miners have a narrow grace path. Reward eligibility requires at least one successful proof, but the first six assigned challenges do not enforce it. After that, a miner with no proof drops out of the reward split while staying in the audit pool. Audit eligibility and reward eligibility are deliberately separate, so a new miner cannot be excluded forever by never being drawn.
Retrieval probes are a separate path: up to 1,800 per epoch network-wide and 3 per miner, asking a miner for a specific shard within 30 seconds. A missed probe does not increment storage-proof failures or directly trigger degradation; probes no longer pay any on-chain reward at all — they are written to the probe ledger, which is the basis for assessing retrieval rewards off chain. A single lifetime success sets the retrieval dimension to full marks.
04The quality multiplier: 0.5× to 1.5×
The multiplier folds three records into one score and maps that score to 0.5×–1.5×:
- Proof success, 60%.
ProofSuccess / (ProofSuccess + ProofFailure), cumulative for the life of the miner record, not per-epoch. - Availability, 25%. Full marks when an unexpired provider record exists on chain (
MsgAnnounceProvider, 1,200-second default TTL). - Retrieval, 15%. Full marks as soon as
RetrievalProbeSuccess > 0, also cumulative.
The formula is multiplier = 0.5 + score, where score is the weighted sum above in the range 0–1. All three at full marks gives 1.5×; perfect proofs with no announcement and no successful retrieval gives 1.1×. The curve moves slowly: early failures stay in the denominator until the miner record is rebuilt.
The current falari-miner does not send MsgAnnounceProvider, and the gateway has no write route for it. Under a default deployment the availability dimension is zero, capping quality at 1.25× even with perfect proofs and retrieval. To make that 25% count, an operator tool has to construct the announcement transaction directly and keep the record fresh.
05Effective storage: stake caps the weight
When an epoch distributes its budget, a miner's weight is:
stake_far = floor(stake_wei / 1e18)
capped_bytes = min(stored_bytes, stake_far × 1 GB)
weight = capped_bytes × quality_multiplier
This cap is the core anti-Sybil rule: each 1 FAR staked lets at most 1 GB of stored data earn weight. 50 FAR caps at 50 GB; 1,000 FAR caps at 1 TB. Sub-FAR stake produces a zero cap and therefore zero weight. Self-dealing can inflate stored_bytes, but it cannot cross that line.
Capacity and stake do different jobs: capacity shapes assignment probability, stake caps countable storage. A miner advertising 100 TiB with 50 FAR staked can receive plenty of shards, but only the first 50 GB earns weight. The fractional FAR below the integer boundary is truncated by integer division and produces no cap.
Only miners that are active with stored_bytes > 0 enter distribution. Degraded miners are excluded. If an epoch has no eligible candidate, the whole budget returns to the storage pool rather than disappearing.
06Where an epoch's budget comes from
The storage stream is balance-driven: each pool pays 25% of its remaining balance per year, and the per-block emission follows from the year's budget and the per-block cap. At the year-1 full ramp on five-second blocks the storage stream tops out at 118.91 FAR per block: 2% (2.38 FAR) is carved into the permanent storage fund and the remaining 98% (116.53 FAR) is reserved for the open epoch. A 60-second epoch spans roughly 12 blocks at five-second block times, so a full epoch's budget tops out near 1,398.38 FAR. Before the capacity ramp fills or while the pool balance is low, each block emits less — the empty-net floor tier is about 23.78 FAR.
When the epoch closes, the budget is split by weight: share = budget × weight / total_weight. Addresses are sorted and the rounding remainder goes to the last candidate, so every node computes the same result. Anything undistributed returns to the storage pool.
| Item | Value | Note |
|---|---|---|
| Storage stream (year-1 full ramp) | 118.91 FAR / block | Estimated at 5-second blocks; empty-net floor tier is about 23.78 |
| Permanent fund | 2.38 FAR / block | 2%, capped by fund headroom |
| Epoch budget | 116.53 FAR / block | 98%, reserved for the open epoch |
| Gross daily issuance (year-1 full ramp) | 2,054,765 FAR | 17,280 blocks × 118.91 FAR |
| Daily epoch budget ceiling | 2,013,670 FAR | 17,280 blocks × 116.53 FAR |
These are issuance ceilings, not yields. What each miner receives depends on total network weight, pool balance, and who is present in the epoch. When the storage pool runs low, each block emits only what remains and then stops. Dividing 2,013,670 FAR by total stake does not produce an APR either — weight also includes the quality multiplier and the 1 GB/FAR cap.
There is no standalone early-mining campaign, airdrop contract, or extra subsidy in the code. Early participants receive exactly the protocol issuance described above. The only early advantage is less competing weight and therefore a larger relative share. There is no principal guarantee, fixed APR, or minimum return.
07How user storage fees reach miners
When a user finalizes a storage order, the fee splits 0% to the foundation, 3% to validators, 3% to retrieval, and 94% to miners. The miner share is not paid on the spot. It enters pending_miner_release and is released linearly, one epoch slice at a time, over the storage window the user paid for. Every release passes three gates: the deal is alive, the miner is not degraded, and no consecutive proof failure is outstanding.
A renewal creates a new tranche starting at the previous window's expiry, so renewal money can never vest inside a window the user already paid for. If the user terminates early, the unreleased remainder goes back to the user, not to the miner.
A released slice does not land in the miner's balance directly; it enters the same 60-day queue. In other words, storage fees pass through two delays: release over the paid window, then linear vesting over 60 days. This keeps the escrow from draining on day one and gives the miner a reason to keep proving and keep serving.
0860-day release and claiming
Every credit — epoch allocation, repair reward, released storage fee — is booked into the miner's UTC-day bucket. Each bucket vests linearly over 60 whole UTC days starting the next day: on day n the claimable portion is total × n / 60. Same-day credits are not claimable because elapsed = 0.
For example, 900 FAR credited on day D gives nothing on D, 15 FAR on D+1, 30 FAR on D+2, and the full amount on D+60. Integer-division remainders stay in the bucket and are released by the final slice. Buckets from different days are computed independently.
Claiming is a MsgClaimMiningRewards transaction signed by the miner account. It pays every bucket's released-but-unclaimed portion in one go and returns claimed plus the remaining claimable. There is no automatic claim and no background payout; if the miner never sends the transaction, the funds stay on chain.
The query surface is GET /miners/{address}/rewards, returning total_earned, total_released, claimable, and the daily buckets. Amounts are decimal wei strings; 18 decimals equal 1 FAR.
09Slashing, degradation, and exit
An expired challenge increments ProofFailure and the consecutive-failure counter, and withholds routing capacity proportional to that shard's size, returned once a proof succeeds. After one full window of sustained failure — degrade_after_failed_epochs × epoch_interval_seconds, by default 720 × 60 seconds ≈ 12 hours — the miner flips to degraded and one slash applies: 1% of current stake, taken directly from stake, hard-capped at 100% of stake, applied at most once per cooldown period. The proceeds go to the user-compensation pool, not to a burn address.
A degraded miner receives no epoch allocation and no storage-fee release, but stays in the audit pool. One successful storage proof restores active status; if the slash pushed stake below the serving floor, the miner must top up first. Every further window inside the same failure run slashes again, so a long absence does not cost only 10%.
Voluntary exit uses MsgDeregisterMiner and requires used_bytes == 0; a miner still holding data cannot exit. Exit refunds the remaining stake and sets status to exited. Re-registration creates a new miner record, so old proof counters are not inherited.
10Pre-flight checklist
- Check
min_miner_stake,epoch_challenges, andproof_deadline_secondsagainst the live chain; do not copy them from old documentation. - Make the endpoint publicly reachable and outside private or loopback ranges; after registration, confirm
GET /miners/{address}returns active. - Keep the data volume above the free-space floor and point
-dataat persistent storage, not a temporary directory. - Watch proving and broadcasting: the log should show proofs submitted, not challenges expired.
- If the availability dimension matters, send
MsgAnnounceProviderand keep it fresh; the current CLI does not do it for you. - Check
GET /miners/{address}/rewardsfor claimable balances and claim before the vested portion piles up.
The whole mechanism in one sentence: stake sets how much storage can count, proofs and availability discount it, the epoch budget is split by the discounted weight, and every credit then vests day by day across 60 UTC buckets.
Sources
- evm/x/storage/types/params.go — stake floor, epoch cadence, quality weights, vesting, caps
- evm/x/storage/keeper/msg_server.go — registration, stake lock, deregistration
- evm/x/storage/keeper/assignment.go — deterministic assignment and endpoint filtering
- evm/x/storage/keeper/challenge_gen.go, msg_proof.go — challenges, deadlines, degradation, provider announcements
- evm/x/storage/keeper/mining_v2.go — quality multiplier, weight, epoch split, vesting, claim
- evm/x/storage/keeper/slashing.go — slash order, cap, and cooldown
- evm/x/storage/keeper/token_release.go — per-block emission split (2% fund carve-out, 98% epoch budget)
- evm/x/storage/keeper/fee_split.go, deal_release.go — 94% deferred miner fee
- evm/cmd/falari-miner/main.go — flags, proving loop, client-side disk check