bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 3쪽 중 2쪽
and used for staking, tipping, dispute fee and voting. All
tokenomics will remain the same (as it is hardcoded and cannot be changed). Four thousand
tokens will continue to be the dev share to the team each month and an equivalent amount of
tokens will be distributed to reporters and validators as inflationary rewards. Seventy-five percent
of time based rewards go to reporters with the other twenty-five percent are given to validators.
Gas fees go to the block proposing validator (selected randomly by validator weight), while tips and
inflationary rewards to reporters are distributed proportionally to the reports submissions based on
weighted validator support. As an example, if a query is submitted for and gets 50% of the stake
contributing to the aggregated value, this report gets some inflationary rewards, however if a more
supported query gets submitted for with 100% of total stakes reporting for it, this gets 2x the
rewards as the first value. There is no benefit being the only reporter for a query, unless of course
there are tips that support that query over others. Additionally, to prevent tips on queries that only a
handful of reporters support, time based rewards are only available on cycle list queries.
The goal is to get broad support among as many queries as possible without either incentivizing
parties to report things that no one needs (e.g. report an obscure query that only one reporter
supports) or disincentivizing reports of new queries. Tips are still, and should, be used as the
primary incentive mechanism used to garner support for a given query.
Bridging
Updating the Validator Set
The bridge was initialized with a starting validator set. Whenever the Tellor validator set changes by
5%, all validators sign this new validator set checkpoint. This 5% threshold helps limit bridging
costs as updating the validator set in the bridge contract costs gas. These signatures are used to
update the bridge’s record of the validator set, and any new data proofs do not pass the bridge’s
checks until the new validator set is relayed. Like data proofs, the bridge accepts a validator set
update if at least ⅔ of the last known validator set signed oE on it.
Tellor Token Bridge
The Tellor token is interchangeable between the current ERC20 TRB contract on Ethereum and the
base token TRB on Tellor. It is secured by a two way bridge, operated by Tellor itself via a light client
bridge.
Bridging TRB from Ethereum to Tellor takes 13 hours. Once the deposit is made, Tellor reporters can
report this information to Tellor for an hour (to allow for a high level of finality on Ethereum). Once
that one hour window is closed, the deposit can be claimed 12 hours later on Tellor. A party
bridging TRB to Tellor for the first time will not have TRB available on Tellor to pay the required gas
fee to claim the deposit so deposits are automatically claimed after the waiting period (12 hours).
In order to prevent attacks, withdrawals from Tellor can only be done if unstaked from being a
validator on Tellor (which requires 21 days). Once a withdrawal is initiated and attested to by
validators, it can be retrieved on Ethereum 12 hours later. As an additional security measure, the
bridge contract does not allow more than 20% of the bridge balance to be bridged to Tellor and 5%
from Tellor to Ethereum within a 12 hour period (the function is locked). We have prioritized security
over speed on the token bridge.
Staking is still growing on Tellor chain and the cost of capture increases as staking grows. To allow
safe growth, anyone in the community that suspects Tellor chain has been compromised can
propose a bridge pause by paying 10,000 TRB which will be burned if the pause is approved by the
team’s multisig(this permission can be removed). Once the chain is forked, the community can
slash the malicious actor and compensate the pause proposer. The bridge can be unpaused after
21 days by anyone. It’s worth noting that even if the token bridge is paused, data can still be
produced by the chain as consensus and rewards happen on the chain.
Data Bridge
Tellor can be used as a push or pull oracle and both implementations require validation of Tellor ’s
validator set via light client bridge contract. A light client bridge is needed on each chain and
parties relay the requested data and signatures as well as information related to validator set
updates and chain upgrades. Anyone can deploy a light client bridge contract and relaying is a
trustless and permissionless role, meaning that anyone can push validator signatures from Tellor to
validate data on the data bridge contract. However, additional, access controls can be put in place
at the chain or user contract level by the user.
Signing Prices
Once a value is aggregated (finalized in a given block), all validators sign the information. The
resulting signatures allow users to access the value, timestamp, aggregate power (amount of
reporter stake used in aggregation), previous report timestamp, and next report timestamp of a
given query. The previous report timestamp and next report timestamp by queryID are included for
proving various properties of a given report.
Where: data = value, timestamp, aggregatePower, previousReportTimestamp,
nextReportTimestamp
Validators will: sign( queryId, data, validatorCheckpoint, attestationTimestamp )
Parties using Tellor can then grab the signatures and relay it to their chain.
Users can also request new signatures for data from previous blocks, (e.g. request(queryId,
timestamp)) and the chain will return signatures on the older data, but with a newer
attestationTimestamp. This is so parties can use values optimistically, by checking that the data
has stayed on Tellor for a certain amount of time without disputes, as data that has been disputed
will not be signed again.
Relayer
The relayer (pushing signed data from Tellor to user chains) can be done by anyone. We provide
software for relaying values and tipper scripts for setting up recurring feeds. Many keeper services
also could fill this role (Keepr, Gelato, etc.).
Relay fallback
If there are no updates to a given light client bridge for >21 days (the unbonding period on Tellor),
then the bridge is considered stale, a situation where it needs a manual update of the validator set.
To address this, the light client bridge includes a function for a guardian to be able to update the
validator set manually after 21 days. Anyone can deploy the light client bridge and set themselves
as the guardian or remove that capability. There can be multiple light client bridge contracts on a
chain. For most use cases, missing data for more than 21 days would be a severe failure condition
and should trigger the users to relay themselves (unless the users or the chain are dead or some
other extreme event has occurred, in which case, the guardian becomes immaterial).
The Tellor team will deploy light client bridges with the team’s address as a fallback that can update
the validator set but users are not required to use these (these will act as a public good). If parties
do not want it to fallback to the team, they can simply update the validator set before the 21days or
deploy a light client bridge where it falls back to a diEerent address (or remove that functionality).
Other cross-chain methods
We know that some parties already have existing bridge solutions that they prefer. Tellor data can
be used via any of these solutions and we look forward to building and working with the teams to
deliver the fastest and most secure solution for users. Some potential usage solutions include IBC,
Hyperlane, Succinct and many more.
In the future, it is likely that native or zero-knowledge bridges will be used to verify signatures,
consensus, as well as inclusion of values. Tellor will be leaning on other teams currently
specializing in cryptography research, but we fully expect that all bridges will be cheaper and faster
using this method and should be operational within the next cycle.
Figure C: Tellor process of aggregation, attestation, and relaying data to other chains.
Note: Staked reporters, staked validators, users and relayers, and data monitors are all
permissionless roles.
Data Usage
Reporters are not required to provide data for all queries. This creates two types of data on-chain,
robust data and edge data. Robust data is data that reaches consensus or support from ⅔ of the
reporters and validators, while edge data can be any data that did not. While confidence on both
types of data increases as time goes by (no disputes or forks in the case of robust data), they have
to be used diEerently.
Robust Data Usage (aka Consensus data)
If ⅔ of Tellor reporters sign oE on a value, it can be consumed faster. A relayer will grab the desired
data and signatures and push it to the consumer chain. Parties can then use the information in
their protocol. There is no need to validate it any further, however waiting could be helpful, if only in
extreme cases (e.g. large price moves), to check for forks, or widespread dispute conditions (e.g. a
protocol or exchange failure/hack where api information may not properly reflect desired data
specifications). In most cases however, this method will allow for updates as fast as the chain
itself.
Robust data can be consumed instantly only if it is assumed that the Tellor validator set is not
compromised (signed oE on bad data to the bridge or in the chain). However unlikely it is that the
validator set would be compromised we advise implementing some precautions when using the
data immediately. Users can run or whitelist relayers on their contracts and/or run monitoring tools,
not allow immediate withdrawals, system freezes, etc. as necessary. See the Additional Self-
Driven Security and Fallbacks section for more information.
Edge Data Usage (aka Optimistic data)
Similar to robust data usage, parties request signatures and relay data from Tellor. However, edge
data should be handled optimistically, meaning that the user should allow time for a dispute to be
raised and before using the data validate that the timestamp returned is within the needed period
of relevance (old enough to allow for disputes but fresh enough to use). They can either use an
older value (similar to current Tellor), and/or verify that X% of validators signed oE on it.
Additional data security
Dispute Monitoring
Dispute monitoring is beneficial for both robust and edge data. However, this is especially
important when parties are using edge data; they must be cognizant that the system is only as
secure as the monitoring for disputes. If, for instance, a party requests an obscure piece of data
that only one validator reports for, and their stake is low, there will likely be few parties checking
this query for disputes. This is why if using an edge value, adding extra security is essential9.
Running your own dispute monitor, educating more reporters to support it, or even more secure
measures such as using only if the median is within x% of a given (e.g. their own team’s) reporter.
Successful disputes earn the majority of the slashed amount of the disputed party so there is also
an economic incentive for anyone to run a monitor10.
Optimistic as Fallback
If consensus fails on certain values that are typically robust, parties have two choices: wait for
consensus to return or handle the edge value, optimistically as specified above. This could be a
great option for some parties using data where quality can quickly change. A price feed for example
might not come to consensus in times of api failures or exchange manipulations (e.g. feeds go
down). In this case, it might be best to pause the system, but they could also go with the optimistic
approach if their protocol needs a faster (albeit still slower than consensus) price. Note that in
most cases, an uncertain value would NOT be pushed to your protocol. Tellor is unique in that
9 More information on Tellor’s security can be found here: https://tellor.io/blog/layer-security-201/
10 An open-source disputable values monitor is available
rather than forcing reporters/validators to sign oE on an api or price feed, the addition of their value
is optional. This means that if a reporter is not certain it’s a valid value, they will likely just sit out
that round(not risk their stake or part of it) and the value will not reach consensus; something that
should be seen as a good thing in cases where ambiguity still exists (e.g. two exchanges diEer
wildly on price).
Additional Self-Driven Security and Fallbacks
Although security is at the center of Tellor’s design, consumers of Tellor data can add custom
additional security. Manipulation attacks should always be considered by users. There are many
examples where using the oracle value immediately has led to exploits or unintended
consequences.11 Data manipulation attacks are oracle agnostic and have occurred even when
the oracle was centralized. But users can implement user level controls to mitigate losses and even
dissuade attackers. One of the bigger players12 in the crypto space includes pauses, delays
throughout their system, a one hour delay before using the oracle value, debt ceilings and other
governance delays. They are proof that you can become a big player and be responsible.
Monitors, delays and pauses are useful because if the oracle is compromised in any way it allows
users to react: overwrite, update the databank address, get a governance vote in, etc... However
unlikely the scenario, users can implement controls to protect themselves and their users if the
data is manipulated directly or by compromising the data provider/node, validator or reporter set.
One way is to simply limit who can push prices/ state updates on the consumer chain. By adding
validation at this level, chains could use either their own validators or stakers to push over the
prices after validating them. This would be an excellent option for users with this level of ownership
over their protocol.
An option for non-chains via the low latency model would be to add validation before a trusted
party (e.g. the app’s dao) pushes the data. It gives the trusted party an option to censor, but they
would be unable to change what the price is, something that would work similarly to a multisig
having pause authority/control over a protocol. Users can also do OEV limits this way (relayer is a
known party or even auction oE the right for OEV13 each day/month).
Another option to increase security is consumer side pauses and delays. Pausing the system could
be similar to the Maker design, where token holders of their own system can freeze the system in
the case of a bad value14 or trust a curator or committee (multisig) to do it for them. For delays,
parties could just design a system where the oracle value is used after X amount of time or it costs
11 Take for example Elixir protocol, now defunct, in 2025 jaredfromsubway.eth made a trade in a Curve pool on Ethereum
of 210K USDT for deUSD, the oracle was providing a VWAP and this trade caused a change and the new value was
reported to Euler on Avalanche where it caused a $532K liquidation. Unfortunatley neither the user or the oracle had any
data checks or variance thresholds check in place. This was a reminder that when data that is collected and attested o=-
chain in subseconds without visibility or dispute mechanism will still end up in the mempool subject to MEV or OEV and
the user has no ability to stop it. That was the tradeo= made, speed over risk mitigation. This was the beginning of the
end for Elixir. More information https://rekt.news/house-of-cards and
https://x.com/omeragoldberg/status/1928149178862952604
12 Sky (formerly MakerDAO) is one of the longest running DeFi apps and they still employ a one hour delay on their oracle
updates. https://developers.skyeco.com/security/security-measures/security-mechanisms/#oracle-price-delay 13 Oracle extractable value
14 Depending on the type of data, this is a best practice for any system using an oracle
X dollars (a large amount) to delay the use of a reported value. While delayed, they could initiate a
dispute on the Tellor system to remove a reporter or evaluate the situation. This would work well for
systems that can handle delays (e.g. a prediction market delaying payouts). Just note that this
would be on a per-user basis and custom as the cost to dispute/pause is also the cost to censor if
it freezes the system for certain protocols.
Users can also add disputes directly in their protocol similar to Tellor ’s disputing system, but can
be handled by their governance. This would work well if coupled with custom staking requirements
for reporters and could also be added as the “trusted” party that the Tellor value must match. A
user side based dispute mechanism could also allow falling back to a more robust data feed such
as going from a VWAP to TWAP before a governance vote. This works well if the protocol allows a
grace period for their users to challenge data and they have a payout delay, since disputes are only
useful before settlement.
For numeric data, implementing caps or thresholds on changes between the previous value and
the incoming value can also help limit losses in an attack scenario or help trigger a payout delay or
data challenge period. This types of volatility caps are on per user and data feed basis.
Users can use multiple oracle feeds and use the median of these similar to how Ampleforth
architecture uses Tellor or as fallback similar to how Liquity V1uses a primary and Tello as a
fallback oracle.
Multiple oracles, oracle fallbacks, data feed fallbacks, pauses, payout delays, oracle use delay,
thresholds caps for changes, overwriting the oracle value15 or updating the oracle address are
options that provide a high level of control and can be modularly implemented at the users’
discretion. Many of these options are used and/or have been used by protocols. Determining what
level of control is right for your protocol, if these should be controlled via governance, a curator, or
mutlisig is up to you, the user (and always provide proper disclosures of these levels of controls to
your users).
These options require a higher level of control and are optional. They add layers of security that is
user driven based on their desired or required level of control and level of ownership over their
protocol. Some of these controls are preventive while others allow users to be proactive in the
event of a hack or manipulation event. Most of the blue chip crypto we see today was made
possible because they grew in proportion with the industry. Bitcoin’s and Ethereum’s market caps
were very low when they first launched and could have been easily captured and manipulated too.
However, incentives to capture or hack a protocol will always exist when the cost of attack is lower
than the gain. Newer protocols need an environment in which they can thrive and grow securely.
They need to be treated diEerently than blue chip crypto assets. Blue chips are harder to
manipulate and capture than low liquidity and emerging assets/protocols. Additionally, the user
can choose to implement these guardrails temporarily or not(for most of these, removing the
control could be as easy as throwing the controlling address or removing it automatically if a
market cap, liquidity, stake amount threshold or a combination of these is surpassed).
15 Hyperliquid validators overwrote and delisted $JELLY when attacked last year. This works well for protocols with this
level of ownership and fair disclosure to their users https://rekt.news/hyperliquidate2
Fork Choice
Upgrades and forks to Tellor will likely happen. Upgrades in the form of better data aggregat프로젝트로 돌아가기