bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 3쪽 중 3쪽
Points
):
Field
Type
Required
Description
dataFeedId
string
Yes
Feed identifier, e.g.
"ETH"
value
number | string
Yes
Price value; may be delivered as a string for large numbers
decimals
number
No
Decimal precision of the value; may be absent
passthrough
Delivers each individual signer payload immediately, without waiting for a quorum threshold. Use this when you need the lowest possible latency and handle signer aggregation yourself.
{
"dataPackageId": "ETH",
"timestampMilliseconds": 1712345678000,
"dataPoints": [
{
"dataFeedId": "ETH",
"value": 2543.12,
"decimals": 8, // optional
},
],
"signature": "<base64>",
}
One
SignedDataPackagePlainObj
per signer, delivered as it arrives.
error
Sent when a request cannot be fulfilled but the connection stays open. The server replies with an error frame on the same connection.
{
"type": "error",
"code": "TOPIC_LIMIT_EXCEEDED",
"message": "Subscribe rejected: exceeds the 50-topic limit for this connection",
"limit": 50,
}
Field
Type
Required
Description
type
"error"
Yes
Discriminant field
code
string
Yes
Machine-readable error code
message
string
Yes
Human-readable description
limit
number
No
The limit that was exceeded, when applicable
Error codes:
code
Cause
TOPIC_LIMIT_EXCEEDED
The subscribe would exceed the per-connection topic limit. The request is rejected; existing subscriptions and the connection stay intact.
Parsing messages
Use the
type
field to distinguish message kinds on the client side:
ws
.
on
(
"message"
,
(
raw
)
=>
{
const
msg
=
JSON
.
parse
(
raw
)
;
if
(
msg
.
type
===
"price"
)
{
console
.
log
(
msg
.
dataPackageId
,
msg
.
value
)
;
}
else
if
(
msg
.
type
===
"redstonePackages"
)
{
console
.
log
(
msg
.
dataPackageId
,
msg
.
payloads
.
length
,
"signers"
)
;
}
else
if
(
msg
.
type
===
"error"
)
{
console
.
warn
(
msg
.
code
,
msg
.
message
)
;
}
else
if
(
msg
.
dataPackageId
)
{
console
.
log
(
msg
.
dataPackageId
,
msg
.
timestampMilliseconds
,
msg
.
signature
)
;
}
}
)
;
Keepalive
The server sends a WebSocket
ping
frame after 120 seconds of inactivity.
Spec-compliant clients respond with a
pong
automatically - no application-level handling is required.
If no pong is received the server closes the connection with code
1001
. Reconnect and re-subscribe after that.
Limits
Up to
30
concurrent connections per API key. Attempts to open more are rejected with
HTTP 429
.
Connections are forcibly closed after
8 hours
(code
1006
) regardless of activity. Clients must handle this close event and reconnect.
1 req/s
per connection with bursts up to
20
req - these are WebSocket messages sent over an already-open connection. Exceeding this closes the connection with code
1008
.
There is an outgoing buffer of
1MB
per connection, if a consumer is slow and the buffer fills up, they are disconnected.
Messages from a subscriber, larger than
64Kb
are dropped.
Connection-open rate: applies to the HTTP upgrade request that opens a connection, not to WebSocket messages sent afterwards. Limited to
60 requests/minute
per client IP and per API key, rejected with
HTTP 403
; and to
10 upgrades/second per API key
with short bursts up to
30
, rejected with
HTTP 429
.
Up to
50
distinct topics per connection. A subscribe that would exceed this is rejected with a
TOPIC_LIMIT_EXCEEDED
error frame
. The connection and existing subscriptions stay intact. Open an additional connection to subscribe to more feeds.
## /docs/stage1-market-data/proof-of-reserve
On this page
A tokenized asset issuer claims a certain level of reserve backing. A Proof of Reserve feed makes that claim verifiable onchain, in real time, by any protocol or user who needs it.
Without onchain PoR, DeFi protocols accepting a tokenized asset as collateral are relying on periodic audit reports or issuer trust. None of these are readable by a smart contract or update fast enough for a liquidation engine.
RedStone Proof of Reserve feeds bridge that gap, taking verified reserve data from the offchain world and publishing it onchain as a cryptographically verifiable price feed.
When to Use a Proof of Reserve Feed
Not every RWA or yield-bearing token needs a PoR feed. RedStone supports three distinct feed types for this category of asset:
Contract rate feeds
— If the asset's backing is fully onchain (example: stETH by Lido), the price can be derived directly from the asset's smart contract. No offchain attestation is required. This is the simplest and fastest integration path when applicable. Similar logic can also be applied to pricing ERC-4626 funds provided that they are composed entirely of crypto collateral (if they also include RWAs, an additional proof of reserve feed may be needed to arrive at the final price of the vault).
Off-chain attestation feeds
— For assets with offchain backing (custodied gold, T-bills, bank deposits, exchange-held collateral, fund assets), PoR feeds are the right tool. The backing exists offchain; it needs to be attested and then published onchain.
Market price feeds
— A secondary market price for an RWA token. Vulnerable to liquidity manipulation and generally not the preferred input for lending markets and risk curators assessing collateral value.
In practice, some assets use more than one feed type simultaneously: a primary PoR or smart contract feed for fundamental valuation and a secondary market feed as a redundancy signal.
How It Works
Proof of Reserve is a two-layer system:
Layer 1: Offchain attestation.
RedStone connects directly to custodian APIs, exchange APIs, bank statement or fund administrator feeds, and other data sources, or works with third-party attestation partners who do, to verify that the claimed reserves exist. This layer produces a verified reserve value, updated on a configured cadence. This layer can also include liabilities alongside reserves, turning a snapshot of assets into a real-time proof of solvency.
Layer 2: Onchain publication.
RedStone pulls the verified data from the attestation endpoint and applies additional logic to make sure the data can be used as a price by smart contracts. It then publishes it onchain as a price feed, using the same push model infrastructure as other RedStone feeds. Onchain publication is triggered by a deviation threshold (configurable to fine granularity) and a heartbeat: the feed updates both on a schedule and when the value changes.
For contract rate feeds or pricing ERC4626 vaults with crypto collateral, the attestation layer is replaced by a direct smart contract read. RedStone calls the respective smart contract function and publishes the result on the target chain. No external data partner is needed.
Supported Data Sources
RedStone can ingest reserve data from:
Custodian and exchange APIs (e.g. for assets held on centralized venues)
Fund administrator APIs and calculation agent feeds (e.g. CACEIS, third-party NAV services)
Bank statements and reserve confirmation PDFs
Exchange price feeds
Smart contract reads
Integration time is typically under 10 days once the data source or smart contract is available. For more complex custodian or fund administrator setups, this may extend to 2–4 weeks.
Supported Asset Types
RedStone has built PoR and NAV feeds for:
Tokenized gold and other physical commodities
Yield-bearing stablecoins backed by TradFi strategies
Tokenized T-bills and government securities
Tokenized real estate and infrastructure bonds
Tokenized corporate bonds and fixed income
Private credit vaults and bridge loan vehicles
Quantitative trading strategy vaults (NAV + P&L attestation)
ERC-4626 vault tokens
Liquid staking and restaking tokens
Technical Details
Deviation threshold:
Onchain publication is triggered by price movement beyond a configurable threshold. For assets with irregular pricing patterns (e.g. bonds that move significantly on macro events), this ensures the feed reflects the market without unnecessary updates during stable periods.
Update frequency:
Attestation partners can provide solvency data updated continuously, even in real-time, including both reserves and liabilities. Onchain publication cadence is configurable.
Push model:
PoR feeds use RedStone's push architecture and are compatible with standard adapter interfaces.
Privacy-Preserving PoR
Some assets require reserve verification while protecting sensitive underlying data — for example, a trading strategy that needs to prove NAV and exchange exposure to LPs without revealing the strategy logic or asset breakdown, or an institutional custodian that requires the highest privacy standards for its holdings.
For these cases, RedStone can deploy computation inside a trusted execution environment (TEE), such as AWS Nitro Enclaves. Exchange API keys are injected into the secure enclave; calculations (NAV, P&L, exposure by exchange, long/short positions) happen inside the enclave without exposing sensitive data to any external party. The resulting attested metrics are then published onchain or delivered to a transparency dashboard.
This approach lets issuers provide verifiable, auditable reporting to LPs and protocols without disclosing proprietary strategy details.
Reference Implementation
See the
Lombard LBTC feed
for a worked example of a continuous Proof of Reserve calculation for a Bitcoin liquid staking token.
Get Started
PoR feed setup is handled directly with the RedStone team. The onboarding process starts with identifying the data source, configuring the attestation layer (or confirming the smart contract interface for Contract Rate feeds), and aligning on update parameters.
Contact RedStone
to start the process.
## /docs/stage1-market-data/sanctions-oracle
On this page
The RedStone Sanctions Oracle keeps sanctioned wallets out of your protocol. It publishes a screened list of designated addresses onchain, so any smart contract can check a counterparty with a single read call and refuse the transaction if the address is listed.
The list is maintained on a fixed schedule, aggregated from hundreds of official sources, and readable by anyone onchain.
Why Onchain Sanctions Screening
Every institution moving value on public blockchains carries a sanctions obligation. OFAC rules apply to every person linked with the US and digital-asset transactions touching the US financial system, and the GENIUS Act requires permitted stablecoin issuers to maintain sanctions-screening and freezing capability. In the EU, the Transfer of Funds Regulation and EBA guidelines require CASPs to screen transfers against EU sanctions lists, with the AML Regulation adding supervision from 2027.
Regulators increasingly expect that control to sit inside the transaction itself, rather than in an offchain review that happens after settlement. A sanctions oracle makes this possible. Because the list lives onchain, a contract can screen a counterparty at execution time, the check is free to query, and because onchain state is preserved at every block, you can show exactly what the list contained when any transaction went through.
Background: The Chainalysis Sanctions Oracle
Chainalysis launched the first free sanctions oracle in March 2022, and it was widely integrated across the industry. The list, however, was never updated frequently: ChainArgos found a May 2024 designation still missing 66 days later. Additionally, updates were controlled by a single externally owned account (one private key).
The last update to that contract (
0x40C57923924B5c5c5455c48D93317139ADDaC8fb
) was on 18 March 2026; the previous one was on 22 September 2025. In our review in September 2026, we found at least six wallets added to the OFAC sanctions list in the 20 May 2026 update that were not covered by the oracle at the time:
0x038989cBB1710C72b9920Dc4Fa529158f463e72c
0x14779CEC0B117d5194c750C55Ea1f42086631964
0x32dA24Ca413F3E7B53145D4737e172C3bdF81e3e
0xF2235D55b2950a0B1317469d72d07Ae65b2e27CB
0x4F428c11Dc82388fa5136D636e613ad923Eb700B
0xaC4cC4B68ea24BbFAAC8fD127B67Ed445ACcCE22
The RedStone Sanctions Oracle uses the same interface, so migrating is a one-line change. See
Integration
below.
How It Works
Multi-sourced list.
The oracle aggregates 463 official sanctions lists and regulator feeds through OpenSanctions, including OFAC, the EU, the UK, the UN, and others. No single entity decides who is listed.
Weekly update cadence.
A reviewed batch of designations is published every week. The time of the last update is recorded onchain, which lets you define a staleness limit in your compliance policy and enforce it in code.
Cold wallet and multisig security.
Every list update is signed from cold storage. Any change to the contract itself requires approval from a geographically distributed multisig, so no single key can alter the code.
Integration
The oracle exposes the same
isSanctioned(address)
function as the Chainalysis contract. If you already integrate with Chainalysis, replace the contract address, and no other code changes are needed.
Contract address
Network
Address
Ethereum Mainnet
0x574Ad490fE8087B580DB227a8Ca7EfB7C19Dc8C4
Interface
interface
ISanctionsList
{
function
isSanctioned
(
address
addr
)
external
view
returns
(
bool
)
;
}
Example: blocking sanctioned addresses
// SPDX-License-Identifier: MIT
pragma
solidity
^
0.8.20
;
interface
ISanctionsList
{
function
isSanctioned
(
address
addr
)
external
view
returns
(
bool
)
;
}
contract
MyProtocol
{
ISanctionsList
public
constant
SANCTIONS_LIST
=
ISanctionsList
(
0x574Ad490fE8087B580DB227a8Ca7EfB7C19Dc8C4
)
;
error
SanctionedAddress
(
address
account
)
;
modifier
notSanctioned
(
address
account
)
{
if
(
SANCTIONS_LIST
.
isSanctioned
(
account
)
)
revert
SanctionedAddress
(
account
)
;
_
;
}
function
deposit
(
uint256
amount
)
external
notSanctioned
(
msg
.
sender
)
{
// ...
}
}
warning
msg.sender
only identifies the immediate caller, which may be a router or another smart contract rather than the end user. If your protocol needs to screen the actual beneficiary or depositor, pass that address to
isSanctioned
explicitly.
Additional functions
Beyond the Chainalysis-compatible
isSanctioned
, the oracle exposes a batch check and the timestamp of the last list update:
interface
IRedStoneSanctionsList
{
function
isSanctioned
(
address
addr
)
external
view
returns
(
bool
)
;
function
areSanctioned
(
address
[
]
calldata
addrs
)
external
view
returns
(
bool
[
]
memory
)
;
function
getLastUpdateBlockTimestamp
(
)
external
view
returns
(
uint256
)
;
}
getLastUpdateBlockTimestamp()
lets you enforce a staleness limit in code, so your contract stops accepting transactions if the list hasn't been updated within the window your compliance policy allows. Using the example above, with
SANCTIONS_LIST
declared as
IRedStoneSanctionsList
:
uint256
public
constant
MAX_LIST_AGE
=
8
days
;
error
StaleSanctionsList
(
uint256
lastUpdate
)
;
modifier
notSanctioned
(
address
account
)
{
uint256
lastUpdate
=
SANCTIONS_LIST
.
getLastUpdateBlockTimestamp
(
)
;
if
(
block
.
timestamp
-
lastUpdate
>
MAX_LIST_AGE
)
revert
StaleSanctionsList
(
lastUpdate
)
;
if
(
SANCTIONS_LIST
.
isSanctioned
(
account
)
)
revert
SanctionedAddress
(
account
)
;
_
;
}
Migrating from Chainalysis
If you followed the Chainalysis integration example, swap the address constant:
- address constant SANCTIONS_CONTRACT = 0x40C57923924B5c5c5455c48D93317139ADDaC8fb;
+ address constant SANCTIONS_CONTRACT = 0x574Ad490fE8087B580DB227a8Ca7EfB7C19Dc8C4;
Why RedStone Sanctions Oracle
The Sanctions Oracle uses the same battle-tested RedStone infrastructure which has been running in production since 2021 with no downtime or mispricing incidents, securing billions of dollars in the most important onchain protocols. RedStone's data pipeline is also covered by ISO 27001-certified information security.
Get Started
The Sanctions Oracle is live on Ethereum mainnet and can be integrated directly using the address above. To discuss deployment on other chains, custom list configurations, or your compliance requirements, contact the RedStone team.프로젝트로 돌아가기