RubiconMarket Subgraph
An overview the RubiconMarket subgraph's key entities, contract event handlers, and example queries for a variety of use cases.
RubiconMarket Key Entities
The RubiconMarket subgraph contains a collection of entities that collect and store data related to trading activity on the protocol's order books. Below are key entities that we believe user's will find most relevant to their data needs.
User Entity (ID: Wallet Address)
1
type User @entity {
2
" <user address> "
3
id: ID!
4
" derived values "
5
swaps: [Swap!]! @derivedFrom(field: "user")
6
openOffers: [OpenOffer!]! @derivedFrom(field: "user")
7
offers: [Offer!]! @derivedFrom(field: "user")
8
takers: [Taker!]! @derivedFrom(field: "user")
9
}
Copied!
The user entity acts as a single point of reference to collect all trading activity related to a wallet's address. From within a user entity you can access the Swap, OpenOffer, Offer, and Taker entities. The contract events that update this entity are as follows:
Variable Updated
Function
Event Emit
Contract
user.swaps
function swap(
uint256 pay_amt,
uint256 buy_amt_min,
address[] calldata route,
uint256 expectedMarketFeeBPS,
address to
)
event LogSwap(
uint256 inputAmount,
address inputERC20,
uint256 hurdleBuyAmtMin,
address targetERC20,
bytes32 indexed pair,
uint256 realizedFill,
address recipient
);
RubiconRouter.sol
user.openOffers
user.offers
function offer(
uint256 pay_amt,
ERC20 pay_gem,
uint256 buy_amt,
ERC20 buy_gem
)
event LogMake(
bytes32 indexed id,
bytes32 indexed pair,
address indexed maker,
ERC20 pay_gem,
ERC20 buy_gem,
uint128 pay_amt,
uint128 buy_amt,
uint64 timestamp
);
RubiconMarket.sol
user.takers
function buy(
uint256 id,
uint256 quantity
)
public virtual can_buy(id) synchronized returns (bool)
event LogTake(
bytes32 indexed id,
bytes32 indexed pair,
address maker,
ERC20 pay_gem,
ERC20 buy_gem,
address indexed taker,
uint128 take_amt,
uint128 give_amt,
uint64 timestamp
);
RubiconMarket.sol
user.openOffers
user.offers
function cancel(
uint256 id
)
public virtual can_cancel(id) synchronized returns (bool success)
event LogKill(
bytes32 indexed id,
bytes32 indexed pair,
address indexed maker,
ERC20 pay_gem,
ERC20 buy_gem,
uint128 pay_amt,
uint128 buy_amt,
uint64 timestamp
);
RubiconMarket.sol
user.openOffers
user.offers
function buy(
uint256 id,
uint256 quantity
)
public virtual can_buy(id) synchronized returns (bool)
event OfferDeleted(
uint256 id
);
*conditional if taker trade fillers offer*
RubiconMarket.sol
Offer & OpenOffer Entities (ID: Offer ID Hash)
1
type Offer @entity {
2
" <offer id hash> "
3
id: ID!
4
" time of transaction "
5
timestamp: BigInt!
6
" track to User entity "
7
user: User!
8
" track to Transaction entity "
9
transaction: Transaction!
10
" track to Pair entity "
11
pair: Pair!
12
" track to DayPair entity "
13
dayPair: DayPair!
14
" track to HourPair entity "
15
hourPair: HourPair!
16
" asset the taker is paying in "
17
takeAsset: Token!
18
" asset the maker is selling "
19
makeAsset: Token!
20
" amout of takeAsset for makeAsset "
21
takeAmount: BigInt!
22
" amount of makeAsset for takeAsset "
23
makeAmount: BigInt!
24
" price of takeAmount in ETH "
25
priceTakeAssetETH: HistoricalAssetPriceETH!
26
" price of makeAmount in ETH "
27
priceMakeAssetETH: HistoricalAssetPriceETH!
28
" price of takeAmount in ETH "
29
priceTakeAssetUSD: HistoricalAssetPriceUSD!
30
" price of makeAmount in ETH "
31
priceMakeAssetUSD: HistoricalAssetPriceUSD!
32
" amount received of takeAsset "
33
receivedTakeAmount: BigInt!
34
" amount of partial fill on makeAsset "
35
partialFillMakeAmount: BigInt!
36
" variable for if offer is killed "
37
killed: Boolean!
38
" when the order is killed or filled "
39
timeKilled: BigInt!
40
}
Copied!
The Offer entity represents all maker trades that a user has made on the Rubicon order books. The Offer entity maps to multiple other entities that it is associated with. For most use cases, the most relevant entities are the Transaction entity, which contains all transaction details (time, block number, gas cost) about the offer, and the "HistoricalAssetPriceETH/USD" entities, which contains details about the last trade of an Asset to either ETH or USD on RubiconMarket (this allows the user to track the historical performance of their trade quoted in ETH & USD). All values are denominated in the integer value of the underlying ERC-20 token that they represent.
1
type OpenOffer @entity {
2
" <offer id hash> "
3
id: ID!
4
" time of transaction "
5
timestamp: BigInt!
6
" track to User entity "
7
user: User!
8
" track to Transaction entity "
9
transaction: Transaction!
10
" track to Pair entity "
11
pair: Pair!
12
" track to DayPair entity "
13
dayPair: DayPair!
14
" track to HourPair entity "
15
hourPair: HourPair!
16
" asset the taker is paying in "
17
takeAsset: Token!
18
" asset the maker is selling "
19
makeAsset: Token!
20
" amout of takeAsset for makeAsset "
21
takeAmount: BigInt!
22
" amount of makeAsset for takeAsset "
23
makeAmount: BigInt!
24
" price of takeAmount in ETH "
25
priceTakeAssetETH: HistoricalAssetPriceETH!
26
" price of makeAmount in ETH "
27
priceMakeAssetETH: HistoricalAssetPriceETH!
28
" price of takeAmount in ETH "
29
priceTakeAssetUSD: HistoricalAssetPriceUSD!
30
" price of makeAmount in ETH "
31
priceMakeAssetUSD: HistoricalAssetPriceUSD!
32
" amount received of takeAsset "
33
receivedTakeAmount: BigInt!
34
" amount of partial fill on makeAsset "
35
partialFillMakeAmount: BigInt!
36
}
Copied!
The OpenOffer entity is a copy of the Offer entity with two caveats: 1) when an offer is either filled or removed from the book the associated OpenOffer entity is removed from the subgraph (these removed entities can still be accessed through a time travel query), and 2) the OpenOffer entity does not contain the variable fields "killed" (false if offer is filled or on the book and true if an offer is canceled) or "timeKilled" (zero if offer is still on the book, updated to the time the offer is taken off the book). The contract events that update these entities are as follows:
Variable Updated
Function
Event Emit
Contract
offer/openOffer.id
offer/openOffer.timestamp
offer/openOffer.user
offer/openOffer.pair
offer/openOffer.dayPair
offer/openOffer.hourPair
offer/openOffer.takeAsset
offer/openOffer.makeAsset
offer/openOffer.takeAmount
offer/openOffer.makeAmount
offer/openOffer.priceTakeAssetETH
offer/openOffer.priceMakeAssetETH
offer/openOffer.priceTakeAssetUSD
offer/openOffer.priceMakeAssetUSD
function offer(
uint256 pay_amt,
ERC20 pay_gem,
uint256 buy_amt,
ERC20 buy_gem
)
event LogMake(
bytes32 indexed id,
bytes32 indexed pair,
address indexed maker,
ERC20 pay_gem,
ERC20 buy_gem,
uint128 pay_amt,
uint128 buy_amt,
uint64 timestamp
);
RubiconMarket.sol
offer/openOffer.receivedTakeAmount
offer/openOffer.partialFillMakeAmount
function buy(
uint256 id,
uint256 quantity
)
public virtual can_buy(id) synchronized returns (bool)
event LogTake(
bytes32 indexed id,
bytes32 indexed pair,
address maker,
ERC20 pay_gem,
ERC20 buy_gem,
address indexed taker,
uint128 take_amt,
uint128 give_amt,
uint64 timestamp
);
RubiconMarket.sol
offer/openOffer.killed
offer/openOffer.timeKilled
function cancel(
uint256 id
)
public virtual can_cancel(id) synchronized returns (bool success)
event LogKill(
bytes32 indexed id,
bytes32 indexed pair,
address indexed maker,
ERC20 pay_gem,
ERC20 buy_gem,
uint128 pay_amt,
uint128 buy_amt,
uint64 timestamp
);
RubiconMarket.sol
offer/openOffer.timeKilled
function buy(
uint256 id,
uint256 quantity
)
public virtual can_buy(id) synchronized returns (bool)
event OfferDeleted(
uint256 id
);
*conditional if taker trade fillers offer*
RubiconMarket.sol
Taker Entity (ID: Transaction Hash)
1
type Taker @entity {
2
" <transaction hash> "
3
id: ID!
4
" time of transaction "
5
timestamp: BigInt!
6
" track to User entity "
7
user: User!
8
" track to Transaction entity "
9
transaction: Transaction!
10
" track to Pair entity "
11
pair: Pair!
12
" track to DayPair entity "
13
dayPair: DayPair!
14
" track to HourPair entity "
15
hourPair: HourPair!
16
" asset the taker is paying in "
17
takeAsset: Token!
18
" asset the maker is selling "
19
makeAsset: Token!
20
" amout of takeAsset for makeAsset "
21
takeAmount: BigInt!
22
" amount of makeAsset for takeAsset "
23
makeAmount: BigInt!
24
" price of takeAmount in ETH "
25
priceTakeAssetETH: HistoricalAssetPriceETH!
26
" price of makeAmount in ETH "
27
priceMakeAssetETH: HistoricalAssetPriceETH!
28
" price of takeAmount in ETH "
29
priceTakeAssetUSD: HistoricalAssetPriceUSD!
30
" price of makeAmount in ETH "
31
priceMakeAssetUSD: HistoricalAssetPriceUSD!
32
" fee for the taker "
33
takerFee: BigInt!
34
" maker entity of the trade "
35
maker: Offer!
36
}
Copied!
The Taker entity represents all taker trades that have occurred on the Rubicon order books. The Taker entity maps to multiple other entities that it is associated with. The most relevant entities it maps to for most use cases is the Transaction entity, containing all transaction details (time, block number, gas cost) about the trade, the "HistoricalAssetPriceETH/USD" entities, containing details about the last trade of an Asset to either ETH or USD on the Rubicon Market (this allows the user to track the historical performance of their trade quoted in ETH & USD), and the Offer entity, the offer that the trade is taking off the book. All values are denominated in the integer value of the underlying ERC-20 token that they represent. The contract events that update these entities are as follows:
Variable Updated
Function
Event Emit
Contract
taker.id
taker.timestamp
taker.user
taker.pair
taker.dayPair
taker.hourPair
taker.takeAsset
taker.makeAsset
taker.takeAmount
taker.makeAmount
taker.priceTakeAssetETH
taker.priceMakeAssetETH
taker.priceTakeAssetUSD
taker.priceMakeAssetUSD
taker.maker
function buy(
uint256 id,
uint256 quantity
)
public virtual can_buy(id) synchronized returns (bool)
event LogTake(
bytes32 indexed id,
bytes32 indexed pair,
address maker,
ERC20 pay_gem,
ERC20 buy_gem,
address indexed taker,
uint128 take_amt,
uint128 give_amt,
uint64 timestamp
);
RubiconMarket.sol
taker.takerFee
function buy(
uint256 id,
uint256 quantity
)
public virtual can_buy(id) synchronized returns (bool)
event FeeTake(
bytes32 indexed id,
bytes32 indexed pair,
ERC20 asset,
address indexed taker,
address feeTo,
uint256 feeAmt,
uint64 timestamp
);
RubiconMarket.sol
Swap Entity (ID: Transaction Hash)
1
type Swap @entity {
2
" <transaction hash> "
3
id: ID!
4
" time of transaction "
5
timestamp: BigInt!
6
" track to User entity "
7
user: User!
8
" track to Transaction entity "
9
transaction: Transaction!
10
" track to Pair entity "
11
pair: Pair!
12
" track to DayPair entity "
13
dayPair: DayPair!
14
" track to HourPair entity "
15
hourPair: HourPair!
16
" asset the taker is paying in "
17
takeAsset: Token!
18
" asset the maker is selling "
19
makeAsset: Token!
20
" amout of takeAsset for makeAsset "
21
takeAmount: BigInt!
22
" amount of makeAsset for takeAsset "
23
makeAmount: BigInt!
24
" price of takeAmount in ETH "
25
priceTakeAssetETH: HistoricalAssetPriceETH!
26
" price of makeAmount in ETH "
27
priceMakeAssetETH: HistoricalAssetPriceETH!
28
" price of takeAmount in ETH "
29
priceTakeAssetUSD: HistoricalAssetPriceUSD!
30
" price of makeAmount in ETH "
31
priceMakeAssetUSD: HistoricalAssetPriceUSD!
32
" fee for the taker "
33
takerFee: BigInt!
34
}
Copied!
The Swap entity represents all swap trades that a user has made on the Rubicon order books. The Swap entity maps to multiple other entities that it is associated with. The most relevant entities it maps to for most use cases is the Transaction entity, containing all transaction details (time, block number, gas cost) about the swap, and the "HistoricalAssetPriceETH/USD" entities, containing details about the last trade of an Asset to either ETH or USD on the Rubicon Market (this allows the user to track the historical performance of their trade quoted in ETH & USD). All values are denominated in the integer value of the underlying ERC-20 token that they represent. The contract events that update these entities are as follows:
Variable Updated
Function
Event Emit
Contract
swap.id
swap.timestamp
swap.user
swap.transaction
swap.pair
swap.dayPair
swap.hourPair
swap.takeAsset
swap.makeAsset
swap.takeAmount
swap.makeAmount
swap.priceTakeAssetETH
swap.priceMakeAssetETH
swap.priceTakeAssetUSD
swap.priceMakeAssetUSD
function _swap(
uint256 pay_amt,
uint256 buy_amt_min,
address[] calldata route,
uint256 expectedMarketFeeBPS,
address to
)
event LogSwap(
uint256 inputAmount,
address inputERC20,
uint256 hurdleBuyAmtMin,
address targetERC20,
bytes32 indexed pair,
uint256 realizedFill,
address recipient
);
RubiconRouter.sol
swap.takerFee
function buy(
uint256 id,
uint256 quantity
)
public virtual can_buy(id) synchronized returns (bool)
event FeeTake(
bytes32 indexed id,
bytes32 indexed pair,
ERC20 asset,
address indexed taker,
address feeTo,
uint256 feeAmt,
uint64 timestamp
);
RubiconMarket.sol
AssetPriceETH/USD (ID: <asset>#<ETH/USD>) & HistoricalAssetPriceETH/USD Entities (ID: <asset>#<ETH/USD>#<timestamp>)
1
type AssetPriceETH @entity {
2
" <asset>#<ETH> "
3
id: ID!
4
" time of last price update "
5
timestamp: BigInt!
6
" asset "
7
asset: Token!
8
" price of asset in ETH "
9
assetPriceETH: BigDecimal!
10
" most recent price of asset in ETH "
11
lastPriceETH: HistoricalAssetPriceETH!
12
}
13
14
type AssetPriceUSD @entity {
15
" <asset>#<ETH> "
16
id: ID!
17
" time of last price update "
18
timestamp: BigInt!
19
" asset "
20
asset: Token!
21
" price of asset in ETH "
22
assetPriceUSD: BigDecimal!
23
" most recent price of asset in USD "
24
lastPriceUSD: HistoricalAssetPriceUSD!
25
}
Copied!
The AssetPriceETH/USD entity represents the price that an asset most recently traded at on the Rubicon order book against either ETH or a stablecoin. The AssetPriceUSD entity contains the stablecoin that most recently traded against the asset to get the USD price, this informs how many decimal places should be accounted for in the price calculation. The AssetPrice entity maps to the most recent traded price through the HistoricalAssetPriceETH/USD entity:
1
type HistoricalAssetPriceETH @entity {
2
" <asset>#<ETH>#<timestamp> "
3
id: ID!
4
" time of last price update "
5
timestamp: BigInt!
6
" asset "
7
asset: Token!
8
" asset amount "
9
assetAmount: BigInt!
10
" eth amount "
11
ethAmount: BigInt!
12
" price of asset in ETH "
13
historicalAssetPriceETH: BigDecimal!
14
}
15
16
type HistoricalAssetPriceUSD @entity {
17
" <asset>#<ETH>#<timestamp> "
18
id: ID!
19
" time of last price update "
20
timestamp: BigInt!
21
" asset "
22
asset: Token!
23
" usd asset "
24
usdAsset: Token
25
" asset amount "
26
assetAmount: BigInt!
27
" usd amount "
28
usdAmount: BigInt!
29
" price of asset in USD "
30
historicalAssetPriceUSD: BigDecimal!
31
}
Copied!
All values are denominated in the integer value of the underlying ERC-20 token that they represent. The contract events that update these entities are as follows:
Variable Updated
Function
Event Emit
Contract
AssetPriceETH/USD.id
AssetPriceETH/USD.timestamp
AssetPriceETH/USD.asset
AssetPriceETH/USD.assetPriceETH/USD
AssetPriceETH/USD.lastPriceETH/USD
HistoricalAssetPriceETH/USD.id
HistoricalAssetPriceETH/USD.timestamp
HistoricalAssetPriceETH/USD.asset
HistoricalAssetPriceETH/USD.assetAmount
HistoricalAssetPriceETH/USD.eth/usdAmount
HistoricalAssetPriceETH/USD.historicalAssetPriceETH/USD
HistoricalAssetPriceUSD.usdAsset
function buy(
uint256 id,
uint256 quantity
)
public virtual can_buy(id) synchronized returns (bool)
event LogTake(
bytes32 indexed id,
bytes32 indexed pair,
address maker,
ERC20 pay_gem,
ERC20 buy_gem,
address indexed taker,
uint128 take_amt,
uint128 give_amt,
uint64 timestamp
);
RubiconMarket.sol
FullPair (ID: <token0 address>#<token1 address>) & Pair Entities (ID: <pay_token address>#<buy_token address>)
1
type FullPair @entity {
2
" <token0 address>#<token1 address> "
3
id: ID!
4
" <pay_token = token0>#<buy_token = token1> "
5
pair0: Pair
6
" <pay_token = token1>#<buy_token = token0> "
7
pair1: Pair
8
" last trade across the pair "
9
lastTrade: Trade
10
" map to all trades across the pair "
11
trades: [Trade!]! @derivedFrom(field: "fullPair")
12
}
Copied!
The FullPair entity represents any ERC20-ERC20 pair that has traded on the Rubicon's order books. This entity maps to two pair entities, they differ from each other in which ERC20 of the pair is the pay/buy token respectively. This represents both directions of trades between an ERC20-ERC20 pair. The lastTrade variable represents the last trade of this pair, regardless of direction, and can be used to access the most recent price data (ERC20 to ERC20, ERC20 to ETH, ERC20 and to USD) of the pair.
1
type Pair @entity {
2
" <pay_token address>#<buy_token address> "
3
id: ID!
4
" market entity "
5
market: RubiconMarket!
6
" first started trading at "
7
startAtTimestamp: BigInt!
8
" block in which pair first started trading "
9
startBlockNumber: BigInt!
10
" pay_token "
11
pay_token: Token!
12
" buy_token "
13
buy_token: Token!
14
" pay_token price - most recent trade price derived from buy_token "
15
pricePayToken: BigDecimal!
16
" buy_token price - most recent trade price derived from pay_token "
17
priceBuyToken: BigDecimal!
18
" volume in pay_token "
19
volumePayToken: BigInt!
20
" volume in buy_token "
21
volumeBuyToken: BigInt!
22
" total number of trades of that pair "
23
txCount: BigInt!
24
" total fees collected of pay_token for this pair "
25
payTokenFees: BigInt!
26
" total fees collected of buy_token for this pair "
27
buyTokenFees: BigInt!
28
" token metrics on that day "
29
dayPairs: [DayPair!]! @derivedFrom(field: "pair")
30
" token metrics for that hour "
31
hourPairs: [HourPair!]! @derivedFrom(field: "pair")
32
" derived values "
33
swaps: [Swap!]! @derivedFrom(field: "pair")
34
openOffers: [OpenOffer!]! @derivedFrom(field: "pair")
35
offers: [Offer!]! @derivedFrom(field: "pair")
36
takers: [Taker!]! @derivedFrom(field: "pair")
37
trades: [Trade!]! @derivedFrom(field: "pair")
38
}
Copied!
The Pair entity represents any directional trade across an ERC20-ERC20 pair. The direction corresponds to which ERC20 of the pair is the pay_token (take asset) and which is the buy_token (make asset). Every pair also has an associated pair entity that tracks pair statistics over a set period of time: 1) MonthPair, 2) WeekPair, 3) DayPair, and 4) HourPair. The IDs for these pair are as follows:
- MonthPair(ID: <pay_token address>#<buy_token address>#<timestamp rounded to current day by dividing by 2629743>)
- WeekPair(ID: <pay_token address>#<buy_token address>#<timestamp rounded to current day by dividing by 604800>)
- DayPair(ID: <pay_token address>#<buy_token address>#<timestamp rounded to current day by dividing by 86400>)
- HourPair(ID: <pay_token address>#<buy_token address>#<timestamp rounded to current day by dividing by 3600>)
All values are denominated in the integer value of the underlying ERC20 token that they represent. The contract events that update these entities are as follows:
Variable Updated
Function
Event Emit
Contract
pair.id
pair.startAtTimestamp
pair.startBlockNumber
pair.pay_token
pair.buy_token
pair.txCount
function offer(
uint256 pay_amt,
ERC20 pay_gem,
uint256 buy_amt,
ERC20 buy_gem
)
event LogMake(
bytes32 indexed id,
bytes32 indexed pair,
address indexed maker,
ERC20 pay_gem,
ERC20 buy_gem,
uint128 pay_amt,
uint128 buy_amt,
uint64 timestamp
);
RubiconMarket.sol
pair.pricePayToken
pair.priceBuyToken
pair.volumePayToken
pair.volumeBuyToken
function buy(
uint256 id,
uint256 quantity
)
public virtual can_buy(id) synchronized returns (bool)
event LogTake(
bytes32 indexed id,
bytes32 indexed pair,
address maker,
ERC20 pay_gem,
ERC20 buy_gem,
address indexed taker,
uint128 take_amt,
uint128 give_amt,
uint64 timestamp
);
RubiconMarket.sol
pair.payTokenFees
pair.buyTokenFees
function buy(
uint256 id,
uint256 quantity
)
public virtual can_buy(id) synchronized returns (bool)
vent FeeTake(
bytes32 indexed id,
bytes32 indexed pair,
ERC20 asset,
address indexed taker,
address feeTo,
uint256 feeAmt,
uint64 timestamp
);
RubiconMarket.sol
Token Entity (ID: Token Address)
1
type Token @entity {
2
" <token address> "
3
id: ID!
4
" market entity "
5
market: RubiconMarket!
6
" first started trading at "
7
startAtTimestamp: BigInt!
8
" block in which token first started trading "
9
startBlockNumber: BigInt!
10
" token symbol "
11
symbol: String!
12
" token name "
13
name: String!
14
" token decimals "
15
decimals: Int!
16
" volume in token units "
17
volume: BigInt!
18
" total number of transactions involving that token "
19
txCount: BigInt!
20
" total fees collected for this token "
21
tokenFees: BigInt!
22
" token metrics on that day "
23
dayTokens: [DayToken!]! @derivedFrom(field: "token")
24
" token metrics for that hour "
25
hourTokens: [HourToken!]! @derivedFrom(field: "token")
26
}
Copied!
The Token entity tracks data related to the activity of an ERC20 token on the Rubicon order books. Every Token also has an associated Token entity that tracks token statistics over a set period of time: DayToken and HourToken. The IDs for these Token entities is as follows:
- DayToken(ID: <token address>#<timestamp rounded to current day by dividing by 86400>)
- HourToken(ID: <token address>#<timestamp rounded to current day by dividing by 86400>
All values are denominated in the integer value of the underlying ERC20 token that they represent. The contract events that update these entities are as follows:
Variable Updated
Function
Event Emit
Contract
token.id
token.startAtTimestamp
token.startBlockNumber
token.txCount
function offer(
uint256 pay_amt,
ERC20 pay_gem,
uint256 buy_amt,
ERC20 buy_gem
)
event LogMake(
bytes32 indexed id,
bytes32 indexed pair,
address indexed maker,
ERC20 pay_gem,
ERC20 buy_gem,
uint128 pay_amt,
uint128 buy_amt,
uint64 timestamp
);
RubiconMarket.sol
token.volume
token.txCount
function buy(
uint256 id,
uint256 quantity
)
public virtual can_buy(id) synchronized returns (bool)
event LogTake(
bytes32 indexed id,
bytes32 indexed pair,
address maker,
ERC20 pay_gem,
ERC20 buy_gem,
address indexed taker,
uint128 take_amt,
uint128 give_amt,
uint64 timestamp
);
RubiconMarket.sol
token.tokenFees
function buy(
uint256 id,
uint256 quantity
)
public virtual can_buy(id) synchronized returns (bool)
vent FeeTake(
bytes32 indexed id,
bytes32 indexed pair,
ERC20 asset,
address indexed taker,
address feeTo,
uint256 feeAmt,
uint64 timestamp
);
RubiconMarket.sol
Example Queries
The following queries are some common use case scenarios for potential data needs relating to the RubiconMarket subgraph.
Use Case
Subgraph Studio Example
Access a User's trade history
Access a User's open offers
Check the status of the entire order book
Historical trading stats for tokens by day
Last trade and entire trade history of a pair of assets
Last modified 3mo ago
Copy link
Contents
RubiconMarket Key Entities
User Entity (ID: Wallet Address)
Offer & OpenOffer Entities (ID: Offer ID Hash)
Taker Entity (ID: Transaction Hash)
Swap Entity (ID: Transaction Hash)
AssetPriceETH/USD (ID: <asset>#<ETH/USD>) & HistoricalAssetPriceETH/USD Entities (ID: <asset>#<ETH/USD>#<timestamp>)
FullPair (ID: <token0 address>#<token1 address>) & Pair Entities (ID: <pay_token address>#<buy_token address>)
Token Entity (ID: Token Address)
Example Queries