From 9f829d23fa5b80c2e4a3b6a0065af5d8691cce89 Mon Sep 17 00:00:00 2001 From: gmbronco <83549293+gmbronco@users.noreply.github.com> Date: Tue, 10 Oct 2023 13:50:18 +0200 Subject: [PATCH] subgraph schema update --- .../generated/balancer-gauges.graphql | 581 +++++++++++++++- .../subgraph/generated/balancer-gauges.ts | 526 +++++++++++++- .../balancer-subgraph-schema.graphql | 648 ++++++++++++++++++ .../generated/balancer-subgraph-types.ts | 639 +++++++++++++++++ 4 files changed, 2387 insertions(+), 7 deletions(-) diff --git a/balancer-js/src/modules/subgraph/generated/balancer-gauges.graphql b/balancer-js/src/modules/subgraph/generated/balancer-gauges.graphql index 87feffe01..bb022a5bc 100644 --- a/balancer-js/src/modules/subgraph/generated/balancer-gauges.graphql +++ b/balancer-js/src/modules/subgraph/generated/balancer-gauges.graphql @@ -29,9 +29,12 @@ scalar Bytes enum Chain { Arbitrum + Avalanche + Base Gnosis Optimism Polygon + PolygonZkEvm } type Gauge { @@ -463,6 +466,12 @@ enum Gauge_orderBy { type__name } +""" +8 bytes signed integer + +""" +scalar Int8 + type LiquidityGauge { """ Factory contract address """ factory: GaugeFactory! @@ -493,6 +502,10 @@ type LiquidityGauge { """ Relative weight cap of the gauge (0.01 = 1%) - V2 factories only """ relativeWeightCap: BigDecimal + """ List of reward tokens depositted in the gauge - ChildChainLiquidityGauge only + """ + rewardTokensList: [Bytes!] + """ List of user shares """ shares(first: Int = 100, orderBy: GaugeShare_orderBy, orderDirection: OrderDirection, skip: Int = 0, where: GaugeShare_filter): [GaugeShare!] @@ -622,6 +635,12 @@ input LiquidityGauge_filter { relativeWeightCap_lte: BigDecimal relativeWeightCap_not: BigDecimal relativeWeightCap_not_in: [BigDecimal!] + rewardTokensList: [Bytes!] + rewardTokensList_contains: [Bytes!] + rewardTokensList_contains_nocase: [Bytes!] + rewardTokensList_not: [Bytes!] + rewardTokensList_not_contains: [Bytes!] + rewardTokensList_not_contains_nocase: [Bytes!] shares_: GaugeShare_filter streamer: Bytes streamer_contains: Bytes @@ -682,6 +701,7 @@ enum LiquidityGauge_orderBy { pool__id pool__poolId relativeWeightCap + rewardTokensList shares streamer symbol @@ -689,6 +709,231 @@ enum LiquidityGauge_orderBy { totalSupply } +type LockSnapshot { + """ veBAL balance at the moment user locks """ + bias: BigDecimal! + + """ Equal to - """ + id: ID! + + """ veBAL decay rate (per second) """ + slope: BigDecimal! + + """ Timestamp at which the snapshot was taken [seconds] """ + timestamp: Int! + + """ Reference to User entity """ + user: User! +} + +input LockSnapshot_filter { + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [LockSnapshot_filter] + bias: BigDecimal + bias_gt: BigDecimal + bias_gte: BigDecimal + bias_in: [BigDecimal!] + bias_lt: BigDecimal + bias_lte: BigDecimal + bias_not: BigDecimal + bias_not_in: [BigDecimal!] + id: ID + id_gt: ID + id_gte: ID + id_in: [ID!] + id_lt: ID + id_lte: ID + id_not: ID + id_not_in: [ID!] + or: [LockSnapshot_filter] + slope: BigDecimal + slope_gt: BigDecimal + slope_gte: BigDecimal + slope_in: [BigDecimal!] + slope_lt: BigDecimal + slope_lte: BigDecimal + slope_not: BigDecimal + slope_not_in: [BigDecimal!] + timestamp: Int + timestamp_gt: Int + timestamp_gte: Int + timestamp_in: [Int!] + timestamp_lt: Int + timestamp_lte: Int + timestamp_not: Int + timestamp_not_in: [Int!] + user: String + user_: User_filter + user_contains: String + user_contains_nocase: String + user_ends_with: String + user_ends_with_nocase: String + user_gt: String + user_gte: String + user_in: [String!] + user_lt: String + user_lte: String + user_not: String + user_not_contains: String + user_not_contains_nocase: String + user_not_ends_with: String + user_not_ends_with_nocase: String + user_not_in: [String!] + user_not_starts_with: String + user_not_starts_with_nocase: String + user_starts_with: String + user_starts_with_nocase: String +} + +enum LockSnapshot_orderBy { + bias + id + slope + timestamp + user + user__id +} + +type OmniVotingEscrowLock { + """ veBAL balance at the moment user locks """ + bias: BigDecimal! + + """ Chain where the lock was bridged to """ + dstChainId: Int! + + """ Equal to: - """ + id: ID! + + """ User on the local chain (reference to User entity) """ + localUser: User! + + """ User address on the remote chain """ + remoteUser: Bytes! + + """ veBAL decay rate (per second) """ + slope: BigDecimal! + + """ Timestamp the lock was created [seconds] """ + timestamp: Int! + + """ Reference to VotingEscrow entity """ + votingEscrowID: VotingEscrow! +} + +input OmniVotingEscrowLock_filter { + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [OmniVotingEscrowLock_filter] + bias: BigDecimal + bias_gt: BigDecimal + bias_gte: BigDecimal + bias_in: [BigDecimal!] + bias_lt: BigDecimal + bias_lte: BigDecimal + bias_not: BigDecimal + bias_not_in: [BigDecimal!] + dstChainId: Int + dstChainId_gt: Int + dstChainId_gte: Int + dstChainId_in: [Int!] + dstChainId_lt: Int + dstChainId_lte: Int + dstChainId_not: Int + dstChainId_not_in: [Int!] + id: ID + id_gt: ID + id_gte: ID + id_in: [ID!] + id_lt: ID + id_lte: ID + id_not: ID + id_not_in: [ID!] + localUser: String + localUser_: User_filter + localUser_contains: String + localUser_contains_nocase: String + localUser_ends_with: String + localUser_ends_with_nocase: String + localUser_gt: String + localUser_gte: String + localUser_in: [String!] + localUser_lt: String + localUser_lte: String + localUser_not: String + localUser_not_contains: String + localUser_not_contains_nocase: String + localUser_not_ends_with: String + localUser_not_ends_with_nocase: String + localUser_not_in: [String!] + localUser_not_starts_with: String + localUser_not_starts_with_nocase: String + localUser_starts_with: String + localUser_starts_with_nocase: String + or: [OmniVotingEscrowLock_filter] + remoteUser: Bytes + remoteUser_contains: Bytes + remoteUser_gt: Bytes + remoteUser_gte: Bytes + remoteUser_in: [Bytes!] + remoteUser_lt: Bytes + remoteUser_lte: Bytes + remoteUser_not: Bytes + remoteUser_not_contains: Bytes + remoteUser_not_in: [Bytes!] + slope: BigDecimal + slope_gt: BigDecimal + slope_gte: BigDecimal + slope_in: [BigDecimal!] + slope_lt: BigDecimal + slope_lte: BigDecimal + slope_not: BigDecimal + slope_not_in: [BigDecimal!] + timestamp: Int + timestamp_gt: Int + timestamp_gte: Int + timestamp_in: [Int!] + timestamp_lt: Int + timestamp_lte: Int + timestamp_not: Int + timestamp_not_in: [Int!] + votingEscrowID: String + votingEscrowID_: VotingEscrow_filter + votingEscrowID_contains: String + votingEscrowID_contains_nocase: String + votingEscrowID_ends_with: String + votingEscrowID_ends_with_nocase: String + votingEscrowID_gt: String + votingEscrowID_gte: String + votingEscrowID_in: [String!] + votingEscrowID_lt: String + votingEscrowID_lte: String + votingEscrowID_not: String + votingEscrowID_not_contains: String + votingEscrowID_not_contains_nocase: String + votingEscrowID_not_ends_with: String + votingEscrowID_not_ends_with_nocase: String + votingEscrowID_not_in: [String!] + votingEscrowID_not_starts_with: String + votingEscrowID_not_starts_with_nocase: String + votingEscrowID_starts_with: String + votingEscrowID_starts_with_nocase: String +} + +enum OmniVotingEscrowLock_orderBy { + bias + dstChainId + id + localUser + localUser__id + remoteUser + slope + timestamp + votingEscrowID + votingEscrowID__id + votingEscrowID__stakedSupply +} + """Defines the order direction, either ascending or descending""" enum OrderDirection { asc @@ -967,6 +1212,62 @@ type Query { subgraphError: _SubgraphErrorPolicy_! = deny where: LiquidityGauge_filter ): [LiquidityGauge!]! + lockSnapshot( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + id: ID! + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): LockSnapshot + lockSnapshots( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + first: Int = 100 + orderBy: LockSnapshot_orderBy + orderDirection: OrderDirection + skip: Int = 0 + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + where: LockSnapshot_filter + ): [LockSnapshot!]! + omniVotingEscrowLock( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + id: ID! + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): OmniVotingEscrowLock + omniVotingEscrowLocks( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + first: Int = 100 + orderBy: OmniVotingEscrowLock_orderBy + orderDirection: OrderDirection + skip: Int = 0 + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + where: OmniVotingEscrowLock_filter + ): [OmniVotingEscrowLock!]! pool( """ The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. @@ -1051,6 +1352,34 @@ type Query { subgraphError: _SubgraphErrorPolicy_! = deny where: RootGauge_filter ): [RootGauge!]! + singleRecipientGauge( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + id: ID! + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SingleRecipientGauge + singleRecipientGauges( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + first: Int = 100 + orderBy: SingleRecipientGauge_orderBy + orderDirection: OrderDirection + skip: Int = 0 + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + where: SingleRecipientGauge_filter + ): [SingleRecipientGauge!]! user( """ The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. @@ -1389,6 +1718,120 @@ enum RootGauge_orderBy { relativeWeightCap } +type SingleRecipientGauge { + """ Factory contract address """ + factory: GaugeFactory! + + """ Reference to Gauge entity - created when SingleRecipientGauge is added to GaugeController + """ + gauge: Gauge + + """ SingleRecipientGauge contract address""" + id: ID! + + """ Whether Balancer DAO killed the gauge """ + isKilled: Boolean! + + """ Address where emissions for this gauge will be sent to """ + recipient: Bytes! + + """ Relative weight cap of the gauge (0.01 = 1%) - V2 factories only """ + relativeWeightCap: BigDecimal +} + +input SingleRecipientGauge_filter { + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [SingleRecipientGauge_filter] + factory: String + factory_: GaugeFactory_filter + factory_contains: String + factory_contains_nocase: String + factory_ends_with: String + factory_ends_with_nocase: String + factory_gt: String + factory_gte: String + factory_in: [String!] + factory_lt: String + factory_lte: String + factory_not: String + factory_not_contains: String + factory_not_contains_nocase: String + factory_not_ends_with: String + factory_not_ends_with_nocase: String + factory_not_in: [String!] + factory_not_starts_with: String + factory_not_starts_with_nocase: String + factory_starts_with: String + factory_starts_with_nocase: String + gauge: String + gauge_: Gauge_filter + gauge_contains: String + gauge_contains_nocase: String + gauge_ends_with: String + gauge_ends_with_nocase: String + gauge_gt: String + gauge_gte: String + gauge_in: [String!] + gauge_lt: String + gauge_lte: String + gauge_not: String + gauge_not_contains: String + gauge_not_contains_nocase: String + gauge_not_ends_with: String + gauge_not_ends_with_nocase: String + gauge_not_in: [String!] + gauge_not_starts_with: String + gauge_not_starts_with_nocase: String + gauge_starts_with: String + gauge_starts_with_nocase: String + id: ID + id_gt: ID + id_gte: ID + id_in: [ID!] + id_lt: ID + id_lte: ID + id_not: ID + id_not_in: [ID!] + isKilled: Boolean + isKilled_in: [Boolean!] + isKilled_not: Boolean + isKilled_not_in: [Boolean!] + or: [SingleRecipientGauge_filter] + recipient: Bytes + recipient_contains: Bytes + recipient_gt: Bytes + recipient_gte: Bytes + recipient_in: [Bytes!] + recipient_lt: Bytes + recipient_lte: Bytes + recipient_not: Bytes + recipient_not_contains: Bytes + recipient_not_in: [Bytes!] + relativeWeightCap: BigDecimal + relativeWeightCap_gt: BigDecimal + relativeWeightCap_gte: BigDecimal + relativeWeightCap_in: [BigDecimal!] + relativeWeightCap_lt: BigDecimal + relativeWeightCap_lte: BigDecimal + relativeWeightCap_not: BigDecimal + relativeWeightCap_not_in: [BigDecimal!] +} + +enum SingleRecipientGauge_orderBy { + factory + factory__id + factory__numGauges + gauge + gauge__addedTimestamp + gauge__address + gauge__id + id + isKilled + recipient + relativeWeightCap +} + type Subscription { """Access to subgraph metadata""" _meta(block: Block_height): _Meta_ @@ -1560,6 +2003,62 @@ type Subscription { subgraphError: _SubgraphErrorPolicy_! = deny where: LiquidityGauge_filter ): [LiquidityGauge!]! + lockSnapshot( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + id: ID! + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): LockSnapshot + lockSnapshots( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + first: Int = 100 + orderBy: LockSnapshot_orderBy + orderDirection: OrderDirection + skip: Int = 0 + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + where: LockSnapshot_filter + ): [LockSnapshot!]! + omniVotingEscrowLock( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + id: ID! + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): OmniVotingEscrowLock + omniVotingEscrowLocks( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + first: Int = 100 + orderBy: OmniVotingEscrowLock_orderBy + orderDirection: OrderDirection + skip: Int = 0 + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + where: OmniVotingEscrowLock_filter + ): [OmniVotingEscrowLock!]! pool( """ The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. @@ -1644,6 +2143,34 @@ type Subscription { subgraphError: _SubgraphErrorPolicy_! = deny where: RootGauge_filter ): [RootGauge!]! + singleRecipientGauge( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + id: ID! + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SingleRecipientGauge + singleRecipientGauges( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + first: Int = 100 + orderBy: SingleRecipientGauge_orderBy + orderDirection: OrderDirection + skip: Int = 0 + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + where: SingleRecipientGauge_filter + ): [SingleRecipientGauge!]! user( """ The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. @@ -1740,6 +2267,9 @@ type User { """ User address """ id: ID! + """ List of omni locks the user created """ + omniVotingLocks(first: Int = 100, orderBy: OmniVotingEscrowLock_orderBy, orderDirection: OrderDirection, skip: Int = 0, where: OmniVotingEscrowLock_filter): [OmniVotingEscrowLock!] + """ List of locks the user created """ votingLocks(first: Int = 100, orderBy: VotingEscrowLock_orderBy, orderDirection: OrderDirection, skip: Int = 0, where: VotingEscrowLock_filter): [VotingEscrowLock!] } @@ -1758,6 +2288,7 @@ input User_filter { id_lte: ID id_not: ID id_not_in: [ID!] + omniVotingLocks_: OmniVotingEscrowLock_filter or: [User_filter] votingLocks_: VotingEscrowLock_filter } @@ -1766,6 +2297,7 @@ enum User_orderBy { gaugeShares gaugeVotes id + omniVotingLocks votingLocks } @@ -1776,20 +2308,34 @@ type VotingEscrow { """ List of veBAL locks created """ locks(first: Int = 100, orderBy: VotingEscrowLock_orderBy, orderDirection: OrderDirection, skip: Int = 0, where: VotingEscrowLock_filter): [VotingEscrowLock!] - """ Amount of B-80BAL-20WETH BPT locked """ - stakedSupply: BigDecimal! + """ List of veBAL locks created """ + omniLocks(first: Int = 100, orderBy: OmniVotingEscrowLock_orderBy, orderDirection: OrderDirection, skip: Int = 0, where: OmniVotingEscrowLock_filter): [OmniVotingEscrowLock!] + + """ Amount of B-80BAL-20WETH BPT locked, only applies on mainnet """ + stakedSupply: BigDecimal } type VotingEscrowLock { + """ veBAL balance at the moment user locks """ + bias: BigDecimal! + """ Equal to: - """ id: ID! """ Amount of B-80BAL-20WETH BPT the user has locked """ lockedBalance: BigDecimal! + """ veBAL decay rate (per second) """ + slope: BigDecimal! + + """ Timestamp at which the lock was created [seconds] """ + timestamp: Int! + """ Timestamp at which B-80BAL-20WETH BPT can be unlocked by user [seconds] """ - unlockTime: BigInt + unlockTime: BigInt! + + """ Timestamp at which the lcok was created [seconds]. Same as timestamp """ updatedAt: Int! """ Reference to User entity """ @@ -1803,6 +2349,14 @@ input VotingEscrowLock_filter { """Filter for the block changed event.""" _change_block: BlockChangedFilter and: [VotingEscrowLock_filter] + bias: BigDecimal + bias_gt: BigDecimal + bias_gte: BigDecimal + bias_in: [BigDecimal!] + bias_lt: BigDecimal + bias_lte: BigDecimal + bias_not: BigDecimal + bias_not_in: [BigDecimal!] id: ID id_gt: ID id_gte: ID @@ -1820,6 +2374,22 @@ input VotingEscrowLock_filter { lockedBalance_not: BigDecimal lockedBalance_not_in: [BigDecimal!] or: [VotingEscrowLock_filter] + slope: BigDecimal + slope_gt: BigDecimal + slope_gte: BigDecimal + slope_in: [BigDecimal!] + slope_lt: BigDecimal + slope_lte: BigDecimal + slope_not: BigDecimal + slope_not_in: [BigDecimal!] + timestamp: Int + timestamp_gt: Int + timestamp_gte: Int + timestamp_in: [Int!] + timestamp_lt: Int + timestamp_lte: Int + timestamp_not: Int + timestamp_not_in: [Int!] unlockTime: BigInt unlockTime_gt: BigInt unlockTime_gte: BigInt @@ -1881,8 +2451,11 @@ input VotingEscrowLock_filter { } enum VotingEscrowLock_orderBy { + bias id lockedBalance + slope + timestamp unlockTime updatedAt user @@ -1905,6 +2478,7 @@ input VotingEscrow_filter { id_not: ID id_not_in: [ID!] locks_: VotingEscrowLock_filter + omniLocks_: OmniVotingEscrowLock_filter or: [VotingEscrow_filter] stakedSupply: BigDecimal stakedSupply_gt: BigDecimal @@ -1919,6 +2493,7 @@ input VotingEscrow_filter { enum VotingEscrow_orderBy { id locks + omniLocks stakedSupply } diff --git a/balancer-js/src/modules/subgraph/generated/balancer-gauges.ts b/balancer-js/src/modules/subgraph/generated/balancer-gauges.ts index 0ae57502c..5f4a0ae6d 100644 --- a/balancer-js/src/modules/subgraph/generated/balancer-gauges.ts +++ b/balancer-js/src/modules/subgraph/generated/balancer-gauges.ts @@ -16,6 +16,7 @@ export type Scalars = { BigDecimal: string; BigInt: string; Bytes: string; + Int8: any; }; export type BlockChangedFilter = { @@ -30,9 +31,12 @@ export type Block_Height = { export enum Chain { Arbitrum = 'Arbitrum', + Avalanche = 'Avalanche', + Base = 'Base', Gnosis = 'Gnosis', Optimism = 'Optimism', - Polygon = 'Polygon' + Polygon = 'Polygon', + PolygonZkEvm = 'PolygonZkEvm' } export type Gauge = { @@ -482,6 +486,8 @@ export type LiquidityGauge = { poolId?: Maybe; /** Relative weight cap of the gauge (0.01 = 1%) - V2 factories only */ relativeWeightCap?: Maybe; + /** List of reward tokens depositted in the gauge - ChildChainLiquidityGauge only */ + rewardTokensList?: Maybe>; /** List of user shares */ shares?: Maybe>; /** Address of the contract that streams reward tokens to the gauge - ChildChainLiquidityGauge only */ @@ -624,6 +630,12 @@ export type LiquidityGauge_Filter = { relativeWeightCap_lte?: InputMaybe; relativeWeightCap_not?: InputMaybe; relativeWeightCap_not_in?: InputMaybe>; + rewardTokensList?: InputMaybe>; + rewardTokensList_contains?: InputMaybe>; + rewardTokensList_contains_nocase?: InputMaybe>; + rewardTokensList_not?: InputMaybe>; + rewardTokensList_not_contains?: InputMaybe>; + rewardTokensList_not_contains_nocase?: InputMaybe>; shares_?: InputMaybe; streamer?: InputMaybe; streamer_contains?: InputMaybe; @@ -684,6 +696,7 @@ export enum LiquidityGauge_OrderBy { pool__id = 'pool__id', pool__poolId = 'pool__poolId', relativeWeightCap = 'relativeWeightCap', + rewardTokensList = 'rewardTokensList', shares = 'shares', streamer = 'streamer', symbol = 'symbol', @@ -691,6 +704,222 @@ export enum LiquidityGauge_OrderBy { totalSupply = 'totalSupply' } +export type LockSnapshot = { + __typename?: 'LockSnapshot'; + /** veBAL balance at the moment user locks */ + bias: Scalars['BigDecimal']; + /** Equal to - */ + id: Scalars['ID']; + /** veBAL decay rate (per second) */ + slope: Scalars['BigDecimal']; + /** Timestamp at which the snapshot was taken [seconds] */ + timestamp: Scalars['Int']; + /** Reference to User entity */ + user: User; +}; + +export type LockSnapshot_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + and?: InputMaybe>>; + bias?: InputMaybe; + bias_gt?: InputMaybe; + bias_gte?: InputMaybe; + bias_in?: InputMaybe>; + bias_lt?: InputMaybe; + bias_lte?: InputMaybe; + bias_not?: InputMaybe; + bias_not_in?: InputMaybe>; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + or?: InputMaybe>>; + slope?: InputMaybe; + slope_gt?: InputMaybe; + slope_gte?: InputMaybe; + slope_in?: InputMaybe>; + slope_lt?: InputMaybe; + slope_lte?: InputMaybe; + slope_not?: InputMaybe; + slope_not_in?: InputMaybe>; + timestamp?: InputMaybe; + timestamp_gt?: InputMaybe; + timestamp_gte?: InputMaybe; + timestamp_in?: InputMaybe>; + timestamp_lt?: InputMaybe; + timestamp_lte?: InputMaybe; + timestamp_not?: InputMaybe; + timestamp_not_in?: InputMaybe>; + user?: InputMaybe; + user_?: InputMaybe; + user_contains?: InputMaybe; + user_contains_nocase?: InputMaybe; + user_ends_with?: InputMaybe; + user_ends_with_nocase?: InputMaybe; + user_gt?: InputMaybe; + user_gte?: InputMaybe; + user_in?: InputMaybe>; + user_lt?: InputMaybe; + user_lte?: InputMaybe; + user_not?: InputMaybe; + user_not_contains?: InputMaybe; + user_not_contains_nocase?: InputMaybe; + user_not_ends_with?: InputMaybe; + user_not_ends_with_nocase?: InputMaybe; + user_not_in?: InputMaybe>; + user_not_starts_with?: InputMaybe; + user_not_starts_with_nocase?: InputMaybe; + user_starts_with?: InputMaybe; + user_starts_with_nocase?: InputMaybe; +}; + +export enum LockSnapshot_OrderBy { + bias = 'bias', + id = 'id', + slope = 'slope', + timestamp = 'timestamp', + user = 'user', + user__id = 'user__id' +} + +export type OmniVotingEscrowLock = { + __typename?: 'OmniVotingEscrowLock'; + /** veBAL balance at the moment user locks */ + bias: Scalars['BigDecimal']; + /** Chain where the lock was bridged to */ + dstChainId: Scalars['Int']; + /** Equal to: - */ + id: Scalars['ID']; + /** User on the local chain (reference to User entity) */ + localUser: User; + /** User address on the remote chain */ + remoteUser: Scalars['Bytes']; + /** veBAL decay rate (per second) */ + slope: Scalars['BigDecimal']; + /** Timestamp the lock was created [seconds] */ + timestamp: Scalars['Int']; + /** Reference to VotingEscrow entity */ + votingEscrowID: VotingEscrow; +}; + +export type OmniVotingEscrowLock_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + and?: InputMaybe>>; + bias?: InputMaybe; + bias_gt?: InputMaybe; + bias_gte?: InputMaybe; + bias_in?: InputMaybe>; + bias_lt?: InputMaybe; + bias_lte?: InputMaybe; + bias_not?: InputMaybe; + bias_not_in?: InputMaybe>; + dstChainId?: InputMaybe; + dstChainId_gt?: InputMaybe; + dstChainId_gte?: InputMaybe; + dstChainId_in?: InputMaybe>; + dstChainId_lt?: InputMaybe; + dstChainId_lte?: InputMaybe; + dstChainId_not?: InputMaybe; + dstChainId_not_in?: InputMaybe>; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + localUser?: InputMaybe; + localUser_?: InputMaybe; + localUser_contains?: InputMaybe; + localUser_contains_nocase?: InputMaybe; + localUser_ends_with?: InputMaybe; + localUser_ends_with_nocase?: InputMaybe; + localUser_gt?: InputMaybe; + localUser_gte?: InputMaybe; + localUser_in?: InputMaybe>; + localUser_lt?: InputMaybe; + localUser_lte?: InputMaybe; + localUser_not?: InputMaybe; + localUser_not_contains?: InputMaybe; + localUser_not_contains_nocase?: InputMaybe; + localUser_not_ends_with?: InputMaybe; + localUser_not_ends_with_nocase?: InputMaybe; + localUser_not_in?: InputMaybe>; + localUser_not_starts_with?: InputMaybe; + localUser_not_starts_with_nocase?: InputMaybe; + localUser_starts_with?: InputMaybe; + localUser_starts_with_nocase?: InputMaybe; + or?: InputMaybe>>; + remoteUser?: InputMaybe; + remoteUser_contains?: InputMaybe; + remoteUser_gt?: InputMaybe; + remoteUser_gte?: InputMaybe; + remoteUser_in?: InputMaybe>; + remoteUser_lt?: InputMaybe; + remoteUser_lte?: InputMaybe; + remoteUser_not?: InputMaybe; + remoteUser_not_contains?: InputMaybe; + remoteUser_not_in?: InputMaybe>; + slope?: InputMaybe; + slope_gt?: InputMaybe; + slope_gte?: InputMaybe; + slope_in?: InputMaybe>; + slope_lt?: InputMaybe; + slope_lte?: InputMaybe; + slope_not?: InputMaybe; + slope_not_in?: InputMaybe>; + timestamp?: InputMaybe; + timestamp_gt?: InputMaybe; + timestamp_gte?: InputMaybe; + timestamp_in?: InputMaybe>; + timestamp_lt?: InputMaybe; + timestamp_lte?: InputMaybe; + timestamp_not?: InputMaybe; + timestamp_not_in?: InputMaybe>; + votingEscrowID?: InputMaybe; + votingEscrowID_?: InputMaybe; + votingEscrowID_contains?: InputMaybe; + votingEscrowID_contains_nocase?: InputMaybe; + votingEscrowID_ends_with?: InputMaybe; + votingEscrowID_ends_with_nocase?: InputMaybe; + votingEscrowID_gt?: InputMaybe; + votingEscrowID_gte?: InputMaybe; + votingEscrowID_in?: InputMaybe>; + votingEscrowID_lt?: InputMaybe; + votingEscrowID_lte?: InputMaybe; + votingEscrowID_not?: InputMaybe; + votingEscrowID_not_contains?: InputMaybe; + votingEscrowID_not_contains_nocase?: InputMaybe; + votingEscrowID_not_ends_with?: InputMaybe; + votingEscrowID_not_ends_with_nocase?: InputMaybe; + votingEscrowID_not_in?: InputMaybe>; + votingEscrowID_not_starts_with?: InputMaybe; + votingEscrowID_not_starts_with_nocase?: InputMaybe; + votingEscrowID_starts_with?: InputMaybe; + votingEscrowID_starts_with_nocase?: InputMaybe; +}; + +export enum OmniVotingEscrowLock_OrderBy { + bias = 'bias', + dstChainId = 'dstChainId', + id = 'id', + localUser = 'localUser', + localUser__id = 'localUser__id', + remoteUser = 'remoteUser', + slope = 'slope', + timestamp = 'timestamp', + votingEscrowID = 'votingEscrowID', + votingEscrowID__id = 'votingEscrowID__id', + votingEscrowID__stakedSupply = 'votingEscrowID__stakedSupply' +} + /** Defines the order direction, either ascending or descending */ export enum OrderDirection { asc = 'asc', @@ -819,12 +1048,18 @@ export type Query = { gauges: Array; liquidityGauge?: Maybe; liquidityGauges: Array; + lockSnapshot?: Maybe; + lockSnapshots: Array; + omniVotingEscrowLock?: Maybe; + omniVotingEscrowLocks: Array; pool?: Maybe; pools: Array; rewardToken?: Maybe; rewardTokens: Array; rootGauge?: Maybe; rootGauges: Array; + singleRecipientGauge?: Maybe; + singleRecipientGauges: Array; user?: Maybe; users: Array; votingEscrow?: Maybe; @@ -947,6 +1182,42 @@ export type QueryLiquidityGaugesArgs = { }; +export type QueryLockSnapshotArgs = { + block?: InputMaybe; + id: Scalars['ID']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryLockSnapshotsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type QueryOmniVotingEscrowLockArgs = { + block?: InputMaybe; + id: Scalars['ID']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryOmniVotingEscrowLocksArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + export type QueryPoolArgs = { block?: InputMaybe; id: Scalars['ID']; @@ -1001,6 +1272,24 @@ export type QueryRootGaugesArgs = { }; +export type QuerySingleRecipientGaugeArgs = { + block?: InputMaybe; + id: Scalars['ID']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QuerySingleRecipientGaugesArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + export type QueryUserArgs = { block?: InputMaybe; id: Scalars['ID']; @@ -1295,6 +1584,115 @@ export enum RootGauge_OrderBy { relativeWeightCap = 'relativeWeightCap' } +export type SingleRecipientGauge = { + __typename?: 'SingleRecipientGauge'; + /** Factory contract address */ + factory: GaugeFactory; + /** Reference to Gauge entity - created when SingleRecipientGauge is added to GaugeController */ + gauge?: Maybe; + /** SingleRecipientGauge contract address */ + id: Scalars['ID']; + /** Whether Balancer DAO killed the gauge */ + isKilled: Scalars['Boolean']; + /** Address where emissions for this gauge will be sent to */ + recipient: Scalars['Bytes']; + /** Relative weight cap of the gauge (0.01 = 1%) - V2 factories only */ + relativeWeightCap?: Maybe; +}; + +export type SingleRecipientGauge_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + and?: InputMaybe>>; + factory?: InputMaybe; + factory_?: InputMaybe; + factory_contains?: InputMaybe; + factory_contains_nocase?: InputMaybe; + factory_ends_with?: InputMaybe; + factory_ends_with_nocase?: InputMaybe; + factory_gt?: InputMaybe; + factory_gte?: InputMaybe; + factory_in?: InputMaybe>; + factory_lt?: InputMaybe; + factory_lte?: InputMaybe; + factory_not?: InputMaybe; + factory_not_contains?: InputMaybe; + factory_not_contains_nocase?: InputMaybe; + factory_not_ends_with?: InputMaybe; + factory_not_ends_with_nocase?: InputMaybe; + factory_not_in?: InputMaybe>; + factory_not_starts_with?: InputMaybe; + factory_not_starts_with_nocase?: InputMaybe; + factory_starts_with?: InputMaybe; + factory_starts_with_nocase?: InputMaybe; + gauge?: InputMaybe; + gauge_?: InputMaybe; + gauge_contains?: InputMaybe; + gauge_contains_nocase?: InputMaybe; + gauge_ends_with?: InputMaybe; + gauge_ends_with_nocase?: InputMaybe; + gauge_gt?: InputMaybe; + gauge_gte?: InputMaybe; + gauge_in?: InputMaybe>; + gauge_lt?: InputMaybe; + gauge_lte?: InputMaybe; + gauge_not?: InputMaybe; + gauge_not_contains?: InputMaybe; + gauge_not_contains_nocase?: InputMaybe; + gauge_not_ends_with?: InputMaybe; + gauge_not_ends_with_nocase?: InputMaybe; + gauge_not_in?: InputMaybe>; + gauge_not_starts_with?: InputMaybe; + gauge_not_starts_with_nocase?: InputMaybe; + gauge_starts_with?: InputMaybe; + gauge_starts_with_nocase?: InputMaybe; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + isKilled?: InputMaybe; + isKilled_in?: InputMaybe>; + isKilled_not?: InputMaybe; + isKilled_not_in?: InputMaybe>; + or?: InputMaybe>>; + recipient?: InputMaybe; + recipient_contains?: InputMaybe; + recipient_gt?: InputMaybe; + recipient_gte?: InputMaybe; + recipient_in?: InputMaybe>; + recipient_lt?: InputMaybe; + recipient_lte?: InputMaybe; + recipient_not?: InputMaybe; + recipient_not_contains?: InputMaybe; + recipient_not_in?: InputMaybe>; + relativeWeightCap?: InputMaybe; + relativeWeightCap_gt?: InputMaybe; + relativeWeightCap_gte?: InputMaybe; + relativeWeightCap_in?: InputMaybe>; + relativeWeightCap_lt?: InputMaybe; + relativeWeightCap_lte?: InputMaybe; + relativeWeightCap_not?: InputMaybe; + relativeWeightCap_not_in?: InputMaybe>; +}; + +export enum SingleRecipientGauge_OrderBy { + factory = 'factory', + factory__id = 'factory__id', + factory__numGauges = 'factory__numGauges', + gauge = 'gauge', + gauge__addedTimestamp = 'gauge__addedTimestamp', + gauge__address = 'gauge__address', + gauge__id = 'gauge__id', + id = 'id', + isKilled = 'isKilled', + recipient = 'recipient', + relativeWeightCap = 'relativeWeightCap' +} + export type Subscription = { __typename?: 'Subscription'; /** Access to subgraph metadata */ @@ -1311,12 +1709,18 @@ export type Subscription = { gauges: Array; liquidityGauge?: Maybe; liquidityGauges: Array; + lockSnapshot?: Maybe; + lockSnapshots: Array; + omniVotingEscrowLock?: Maybe; + omniVotingEscrowLocks: Array; pool?: Maybe; pools: Array; rewardToken?: Maybe; rewardTokens: Array; rootGauge?: Maybe; rootGauges: Array; + singleRecipientGauge?: Maybe; + singleRecipientGauges: Array; user?: Maybe; users: Array; votingEscrow?: Maybe; @@ -1439,6 +1843,42 @@ export type SubscriptionLiquidityGaugesArgs = { }; +export type SubscriptionLockSnapshotArgs = { + block?: InputMaybe; + id: Scalars['ID']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionLockSnapshotsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type SubscriptionOmniVotingEscrowLockArgs = { + block?: InputMaybe; + id: Scalars['ID']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionOmniVotingEscrowLocksArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + export type SubscriptionPoolArgs = { block?: InputMaybe; id: Scalars['ID']; @@ -1493,6 +1933,24 @@ export type SubscriptionRootGaugesArgs = { }; +export type SubscriptionSingleRecipientGaugeArgs = { + block?: InputMaybe; + id: Scalars['ID']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionSingleRecipientGaugesArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + export type SubscriptionUserArgs = { block?: InputMaybe; id: Scalars['ID']; @@ -1554,6 +2012,8 @@ export type User = { gaugeVotes?: Maybe>; /** User address */ id: Scalars['ID']; + /** List of omni locks the user created */ + omniVotingLocks?: Maybe>; /** List of locks the user created */ votingLocks?: Maybe>; }; @@ -1577,6 +2037,15 @@ export type UserGaugeVotesArgs = { }; +export type UserOmniVotingLocksArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + + export type UserVotingLocksArgs = { first?: InputMaybe; orderBy?: InputMaybe; @@ -1599,6 +2068,7 @@ export type User_Filter = { id_lte?: InputMaybe; id_not?: InputMaybe; id_not_in?: InputMaybe>; + omniVotingLocks_?: InputMaybe; or?: InputMaybe>>; votingLocks_?: InputMaybe; }; @@ -1607,6 +2077,7 @@ export enum User_OrderBy { gaugeShares = 'gaugeShares', gaugeVotes = 'gaugeVotes', id = 'id', + omniVotingLocks = 'omniVotingLocks', votingLocks = 'votingLocks' } @@ -1616,8 +2087,10 @@ export type VotingEscrow = { id: Scalars['ID']; /** List of veBAL locks created */ locks?: Maybe>; - /** Amount of B-80BAL-20WETH BPT locked */ - stakedSupply: Scalars['BigDecimal']; + /** List of veBAL locks created */ + omniLocks?: Maybe>; + /** Amount of B-80BAL-20WETH BPT locked, only applies on mainnet */ + stakedSupply?: Maybe; }; @@ -1629,14 +2102,30 @@ export type VotingEscrowLocksArgs = { where?: InputMaybe; }; + +export type VotingEscrowOmniLocksArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + export type VotingEscrowLock = { __typename?: 'VotingEscrowLock'; + /** veBAL balance at the moment user locks */ + bias: Scalars['BigDecimal']; /** Equal to: - */ id: Scalars['ID']; /** Amount of B-80BAL-20WETH BPT the user has locked */ lockedBalance: Scalars['BigDecimal']; + /** veBAL decay rate (per second) */ + slope: Scalars['BigDecimal']; + /** Timestamp at which the lock was created [seconds] */ + timestamp: Scalars['Int']; /** Timestamp at which B-80BAL-20WETH BPT can be unlocked by user [seconds] */ - unlockTime?: Maybe; + unlockTime: Scalars['BigInt']; + /** Timestamp at which the lcok was created [seconds]. Same as timestamp */ updatedAt: Scalars['Int']; /** Reference to User entity */ user: User; @@ -1648,6 +2137,14 @@ export type VotingEscrowLock_Filter = { /** Filter for the block changed event. */ _change_block?: InputMaybe; and?: InputMaybe>>; + bias?: InputMaybe; + bias_gt?: InputMaybe; + bias_gte?: InputMaybe; + bias_in?: InputMaybe>; + bias_lt?: InputMaybe; + bias_lte?: InputMaybe; + bias_not?: InputMaybe; + bias_not_in?: InputMaybe>; id?: InputMaybe; id_gt?: InputMaybe; id_gte?: InputMaybe; @@ -1665,6 +2162,22 @@ export type VotingEscrowLock_Filter = { lockedBalance_not?: InputMaybe; lockedBalance_not_in?: InputMaybe>; or?: InputMaybe>>; + slope?: InputMaybe; + slope_gt?: InputMaybe; + slope_gte?: InputMaybe; + slope_in?: InputMaybe>; + slope_lt?: InputMaybe; + slope_lte?: InputMaybe; + slope_not?: InputMaybe; + slope_not_in?: InputMaybe>; + timestamp?: InputMaybe; + timestamp_gt?: InputMaybe; + timestamp_gte?: InputMaybe; + timestamp_in?: InputMaybe>; + timestamp_lt?: InputMaybe; + timestamp_lte?: InputMaybe; + timestamp_not?: InputMaybe; + timestamp_not_in?: InputMaybe>; unlockTime?: InputMaybe; unlockTime_gt?: InputMaybe; unlockTime_gte?: InputMaybe; @@ -1726,8 +2239,11 @@ export type VotingEscrowLock_Filter = { }; export enum VotingEscrowLock_OrderBy { + bias = 'bias', id = 'id', lockedBalance = 'lockedBalance', + slope = 'slope', + timestamp = 'timestamp', unlockTime = 'unlockTime', updatedAt = 'updatedAt', user = 'user', @@ -1750,6 +2266,7 @@ export type VotingEscrow_Filter = { id_not?: InputMaybe; id_not_in?: InputMaybe>; locks_?: InputMaybe; + omniLocks_?: InputMaybe; or?: InputMaybe>>; stakedSupply?: InputMaybe; stakedSupply_gt?: InputMaybe; @@ -1764,6 +2281,7 @@ export type VotingEscrow_Filter = { export enum VotingEscrow_OrderBy { id = 'id', locks = 'locks', + omniLocks = 'omniLocks', stakedSupply = 'stakedSupply' } diff --git a/balancer-js/src/modules/subgraph/generated/balancer-subgraph-schema.graphql b/balancer-js/src/modules/subgraph/generated/balancer-subgraph-schema.graphql index 65662aee4..bc315729b 100644 --- a/balancer-js/src/modules/subgraph/generated/balancer-subgraph-schema.graphql +++ b/balancer-js/src/modules/subgraph/generated/balancer-subgraph-schema.graphql @@ -118,11 +118,15 @@ enum AmpUpdate_orderBy { poolId__id poolId__isInRecoveryMode poolId__isPaused + poolId__joinExitEnabled poolId__lambda + poolId__lastJoinExitAmp poolId__lastPostJoinExitInvariant poolId__lowerTarget poolId__mainIndex + poolId__managementAumFee poolId__managementFee + poolId__mustAllowlistLPs poolId__name poolId__oracleEnabled poolId__owner @@ -139,6 +143,8 @@ enum AmpUpdate_orderBy { poolId__sqrtBeta poolId__strategyType poolId__swapEnabled + poolId__swapEnabledCurationSignal + poolId__swapEnabledInternal poolId__swapFee poolId__swapsCount poolId__symbol @@ -146,7 +152,11 @@ enum AmpUpdate_orderBy { poolId__tauAlphaY poolId__tauBetaX poolId__tauBetaY + poolId__totalAumFeeCollectedInBPT poolId__totalLiquidity + poolId__totalLiquiditySansBPT + poolId__totalProtocolFee + poolId__totalProtocolFeePaidInBPT poolId__totalShares poolId__totalSwapFee poolId__totalSwapVolume @@ -168,7 +178,9 @@ type Balancer { id: ID! poolCount: Int! pools(first: Int = 100, orderBy: Pool_orderBy, orderDirection: OrderDirection, skip: Int = 0, where: Pool_filter): [Pool!] + protocolFeesCollector: Bytes totalLiquidity: BigDecimal! + totalProtocolFee: BigDecimal totalSwapCount: BigInt! totalSwapFee: BigDecimal! totalSwapVolume: BigDecimal! @@ -179,6 +191,7 @@ type BalancerSnapshot { poolCount: Int! timestamp: Int! totalLiquidity: BigDecimal! + totalProtocolFee: BigDecimal totalSwapCount: BigInt! totalSwapFee: BigDecimal! totalSwapVolume: BigDecimal! @@ -222,6 +235,14 @@ input BalancerSnapshot_filter { totalLiquidity_lte: BigDecimal totalLiquidity_not: BigDecimal totalLiquidity_not_in: [BigDecimal!] + totalProtocolFee: BigDecimal + totalProtocolFee_gt: BigDecimal + totalProtocolFee_gte: BigDecimal + totalProtocolFee_in: [BigDecimal!] + totalProtocolFee_lt: BigDecimal + totalProtocolFee_lte: BigDecimal + totalProtocolFee_not: BigDecimal + totalProtocolFee_not_in: [BigDecimal!] totalSwapCount: BigInt totalSwapCount_gt: BigInt totalSwapCount_gte: BigInt @@ -274,13 +295,16 @@ enum BalancerSnapshot_orderBy { poolCount timestamp totalLiquidity + totalProtocolFee totalSwapCount totalSwapFee totalSwapVolume vault vault__id vault__poolCount + vault__protocolFeesCollector vault__totalLiquidity + vault__totalProtocolFee vault__totalSwapCount vault__totalSwapFee vault__totalSwapVolume @@ -308,6 +332,16 @@ input Balancer_filter { poolCount_not: Int poolCount_not_in: [Int!] pools_: Pool_filter + protocolFeesCollector: Bytes + protocolFeesCollector_contains: Bytes + protocolFeesCollector_gt: Bytes + protocolFeesCollector_gte: Bytes + protocolFeesCollector_in: [Bytes!] + protocolFeesCollector_lt: Bytes + protocolFeesCollector_lte: Bytes + protocolFeesCollector_not: Bytes + protocolFeesCollector_not_contains: Bytes + protocolFeesCollector_not_in: [Bytes!] totalLiquidity: BigDecimal totalLiquidity_gt: BigDecimal totalLiquidity_gte: BigDecimal @@ -316,6 +350,14 @@ input Balancer_filter { totalLiquidity_lte: BigDecimal totalLiquidity_not: BigDecimal totalLiquidity_not_in: [BigDecimal!] + totalProtocolFee: BigDecimal + totalProtocolFee_gt: BigDecimal + totalProtocolFee_gte: BigDecimal + totalProtocolFee_in: [BigDecimal!] + totalProtocolFee_lt: BigDecimal + totalProtocolFee_lte: BigDecimal + totalProtocolFee_not: BigDecimal + totalProtocolFee_not_in: [BigDecimal!] totalSwapCount: BigInt totalSwapCount_gt: BigInt totalSwapCount_gte: BigInt @@ -346,7 +388,9 @@ enum Balancer_orderBy { id poolCount pools + protocolFeesCollector totalLiquidity + totalProtocolFee totalSwapCount totalSwapFee totalSwapVolume @@ -368,6 +412,187 @@ input Block_height { scalar Bytes +type CircuitBreaker { + bptPrice: BigDecimal! + id: ID! + lowerBoundPercentage: BigDecimal! + pool: Pool! + token: PoolToken! + upperBoundPercentage: BigDecimal! +} + +input CircuitBreaker_filter { + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [CircuitBreaker_filter] + bptPrice: BigDecimal + bptPrice_gt: BigDecimal + bptPrice_gte: BigDecimal + bptPrice_in: [BigDecimal!] + bptPrice_lt: BigDecimal + bptPrice_lte: BigDecimal + bptPrice_not: BigDecimal + bptPrice_not_in: [BigDecimal!] + id: ID + id_gt: ID + id_gte: ID + id_in: [ID!] + id_lt: ID + id_lte: ID + id_not: ID + id_not_in: [ID!] + lowerBoundPercentage: BigDecimal + lowerBoundPercentage_gt: BigDecimal + lowerBoundPercentage_gte: BigDecimal + lowerBoundPercentage_in: [BigDecimal!] + lowerBoundPercentage_lt: BigDecimal + lowerBoundPercentage_lte: BigDecimal + lowerBoundPercentage_not: BigDecimal + lowerBoundPercentage_not_in: [BigDecimal!] + or: [CircuitBreaker_filter] + pool: String + pool_: Pool_filter + pool_contains: String + pool_contains_nocase: String + pool_ends_with: String + pool_ends_with_nocase: String + pool_gt: String + pool_gte: String + pool_in: [String!] + pool_lt: String + pool_lte: String + pool_not: String + pool_not_contains: String + pool_not_contains_nocase: String + pool_not_ends_with: String + pool_not_ends_with_nocase: String + pool_not_in: [String!] + pool_not_starts_with: String + pool_not_starts_with_nocase: String + pool_starts_with: String + pool_starts_with_nocase: String + token: String + token_: PoolToken_filter + token_contains: String + token_contains_nocase: String + token_ends_with: String + token_ends_with_nocase: String + token_gt: String + token_gte: String + token_in: [String!] + token_lt: String + token_lte: String + token_not: String + token_not_contains: String + token_not_contains_nocase: String + token_not_ends_with: String + token_not_ends_with_nocase: String + token_not_in: [String!] + token_not_starts_with: String + token_not_starts_with_nocase: String + token_starts_with: String + token_starts_with_nocase: String + upperBoundPercentage: BigDecimal + upperBoundPercentage_gt: BigDecimal + upperBoundPercentage_gte: BigDecimal + upperBoundPercentage_in: [BigDecimal!] + upperBoundPercentage_lt: BigDecimal + upperBoundPercentage_lte: BigDecimal + upperBoundPercentage_not: BigDecimal + upperBoundPercentage_not_in: [BigDecimal!] +} + +enum CircuitBreaker_orderBy { + bptPrice + id + lowerBoundPercentage + pool + pool__address + pool__alpha + pool__amp + pool__baseToken + pool__beta + pool__c + pool__createTime + pool__dSq + pool__delta + pool__epsilon + pool__expiryTime + pool__factory + pool__holdersCount + pool__id + pool__isInRecoveryMode + pool__isPaused + pool__joinExitEnabled + pool__lambda + pool__lastJoinExitAmp + pool__lastPostJoinExitInvariant + pool__lowerTarget + pool__mainIndex + pool__managementAumFee + pool__managementFee + pool__mustAllowlistLPs + pool__name + pool__oracleEnabled + pool__owner + pool__poolType + pool__poolTypeVersion + pool__principalToken + pool__protocolAumFeeCache + pool__protocolId + pool__protocolSwapFeeCache + pool__protocolYieldFeeCache + pool__root3Alpha + pool__s + pool__sqrtAlpha + pool__sqrtBeta + pool__strategyType + pool__swapEnabled + pool__swapEnabledCurationSignal + pool__swapEnabledInternal + pool__swapFee + pool__swapsCount + pool__symbol + pool__tauAlphaX + pool__tauAlphaY + pool__tauBetaX + pool__tauBetaY + pool__totalAumFeeCollectedInBPT + pool__totalLiquidity + pool__totalLiquiditySansBPT + pool__totalProtocolFee + pool__totalProtocolFeePaidInBPT + pool__totalShares + pool__totalSwapFee + pool__totalSwapVolume + pool__totalWeight + pool__tx + pool__u + pool__unitSeconds + pool__upperTarget + pool__v + pool__w + pool__wrappedIndex + pool__z + token + token__address + token__assetManager + token__balance + token__cashBalance + token__decimals + token__id + token__index + token__isExemptFromYieldProtocolFee + token__managedBalance + token__name + token__oldPriceRate + token__paidProtocolFees + token__priceRate + token__symbol + token__weight + upperBoundPercentage +} + type GradualWeightUpdate { endTimestamp: BigInt! endWeights: [BigInt!]! @@ -471,11 +696,15 @@ enum GradualWeightUpdate_orderBy { poolId__id poolId__isInRecoveryMode poolId__isPaused + poolId__joinExitEnabled poolId__lambda + poolId__lastJoinExitAmp poolId__lastPostJoinExitInvariant poolId__lowerTarget poolId__mainIndex + poolId__managementAumFee poolId__managementFee + poolId__mustAllowlistLPs poolId__name poolId__oracleEnabled poolId__owner @@ -492,6 +721,8 @@ enum GradualWeightUpdate_orderBy { poolId__sqrtBeta poolId__strategyType poolId__swapEnabled + poolId__swapEnabledCurationSignal + poolId__swapEnabledInternal poolId__swapFee poolId__swapsCount poolId__symbol @@ -499,7 +730,11 @@ enum GradualWeightUpdate_orderBy { poolId__tauAlphaY poolId__tauBetaX poolId__tauBetaY + poolId__totalAumFeeCollectedInBPT poolId__totalLiquidity + poolId__totalLiquiditySansBPT + poolId__totalProtocolFee + poolId__totalProtocolFeePaidInBPT poolId__totalShares poolId__totalSwapFee poolId__totalSwapVolume @@ -517,6 +752,12 @@ enum GradualWeightUpdate_orderBy { startWeights } +""" +8 bytes signed integer + +""" +scalar Int8 + enum InvestType { Exit Join @@ -657,11 +898,15 @@ enum JoinExit_orderBy { pool__id pool__isInRecoveryMode pool__isPaused + pool__joinExitEnabled pool__lambda + pool__lastJoinExitAmp pool__lastPostJoinExitInvariant pool__lowerTarget pool__mainIndex + pool__managementAumFee pool__managementFee + pool__mustAllowlistLPs pool__name pool__oracleEnabled pool__owner @@ -678,6 +923,8 @@ enum JoinExit_orderBy { pool__sqrtBeta pool__strategyType pool__swapEnabled + pool__swapEnabledCurationSignal + pool__swapEnabledInternal pool__swapFee pool__swapsCount pool__symbol @@ -685,7 +932,11 @@ enum JoinExit_orderBy { pool__tauAlphaY pool__tauBetaX pool__tauBetaY + pool__totalAumFeeCollectedInBPT pool__totalLiquidity + pool__totalLiquiditySansBPT + pool__totalProtocolFee + pool__totalProtocolFeePaidInBPT pool__totalShares pool__totalSwapFee pool__totalSwapVolume @@ -809,11 +1060,15 @@ enum LatestPrice_orderBy { poolId__id poolId__isInRecoveryMode poolId__isPaused + poolId__joinExitEnabled poolId__lambda + poolId__lastJoinExitAmp poolId__lastPostJoinExitInvariant poolId__lowerTarget poolId__mainIndex + poolId__managementAumFee poolId__managementFee + poolId__mustAllowlistLPs poolId__name poolId__oracleEnabled poolId__owner @@ -830,6 +1085,8 @@ enum LatestPrice_orderBy { poolId__sqrtBeta poolId__strategyType poolId__swapEnabled + poolId__swapEnabledCurationSignal + poolId__swapEnabledInternal poolId__swapFee poolId__swapsCount poolId__symbol @@ -837,7 +1094,11 @@ enum LatestPrice_orderBy { poolId__tauAlphaY poolId__tauBetaX poolId__tauBetaY + poolId__totalAumFeeCollectedInBPT poolId__totalLiquidity + poolId__totalLiquiditySansBPT + poolId__totalProtocolFee + poolId__totalProtocolFeePaidInBPT poolId__totalShares poolId__totalSwapFee poolId__totalSwapVolume @@ -943,6 +1204,7 @@ enum ManagementOperation_orderBy { poolTokenId__managedBalance poolTokenId__name poolTokenId__oldPriceRate + poolTokenId__paidProtocolFees poolTokenId__priceRate poolTokenId__symbol poolTokenId__weight @@ -966,9 +1228,11 @@ type Pool { address: Bytes! alpha: BigDecimal amp: BigInt + ampUpdates(first: Int = 100, orderBy: AmpUpdate_orderBy, orderDirection: OrderDirection, skip: Int = 0, where: AmpUpdate_filter): [AmpUpdate!] baseToken: Bytes beta: BigDecimal c: BigDecimal + circuitBreakers(first: Int = 100, orderBy: CircuitBreaker_orderBy, orderDirection: OrderDirection, skip: Int = 0, where: CircuitBreaker_filter): [CircuitBreaker!] createTime: Int! dSq: BigDecimal delta: BigDecimal @@ -980,11 +1244,16 @@ type Pool { id: ID! isInRecoveryMode: Boolean isPaused: Boolean + joinExitEnabled: Boolean lambda: BigDecimal + lastJoinExitAmp: BigInt lastPostJoinExitInvariant: BigDecimal + latestAmpUpdate: AmpUpdate lowerTarget: BigDecimal mainIndex: Int + managementAumFee: BigDecimal managementFee: BigDecimal + mustAllowlistLPs: Boolean name: String oracleEnabled: Boolean! owner: Bytes @@ -1004,7 +1273,19 @@ type Pool { sqrtAlpha: BigDecimal sqrtBeta: BigDecimal strategyType: Int! + + """ + Indicates if a pool can be swapped against. Combines multiple sources, including offchain curation + """ swapEnabled: Boolean! + + """External indication from an offchain permissioned actor""" + swapEnabledCurationSignal: Boolean + + """ + The native swapEnabled boolean. internal to the pool. Only applies to Gyro, LBPs and InvestmentPools + """ + swapEnabledInternal: Boolean swapFee: BigDecimal! swaps(first: Int = 100, orderBy: Swap_orderBy, orderDirection: OrderDirection, skip: Int = 0, where: Swap_filter): [Swap!] swapsCount: BigInt! @@ -1015,7 +1296,11 @@ type Pool { tauBetaY: BigDecimal tokens(first: Int = 100, orderBy: PoolToken_orderBy, orderDirection: OrderDirection, skip: Int = 0, where: PoolToken_filter): [PoolToken!] tokensList: [Bytes!]! + totalAumFeeCollectedInBPT: BigDecimal totalLiquidity: BigDecimal! + totalLiquiditySansBPT: BigDecimal + totalProtocolFee: BigDecimal + totalProtocolFeePaidInBPT: BigDecimal totalShares: BigDecimal! totalSwapFee: BigDecimal! totalSwapVolume: BigDecimal! @@ -1092,11 +1377,15 @@ enum PoolContract_orderBy { pool__id pool__isInRecoveryMode pool__isPaused + pool__joinExitEnabled pool__lambda + pool__lastJoinExitAmp pool__lastPostJoinExitInvariant pool__lowerTarget pool__mainIndex + pool__managementAumFee pool__managementFee + pool__mustAllowlistLPs pool__name pool__oracleEnabled pool__owner @@ -1113,6 +1402,8 @@ enum PoolContract_orderBy { pool__sqrtBeta pool__strategyType pool__swapEnabled + pool__swapEnabledCurationSignal + pool__swapEnabledInternal pool__swapFee pool__swapsCount pool__symbol @@ -1120,7 +1411,11 @@ enum PoolContract_orderBy { pool__tauAlphaY pool__tauBetaX pool__tauBetaY + pool__totalAumFeeCollectedInBPT pool__totalLiquidity + pool__totalLiquiditySansBPT + pool__totalProtocolFee + pool__totalProtocolFeePaidInBPT pool__totalShares pool__totalSwapFee pool__totalSwapVolume @@ -1243,11 +1538,15 @@ enum PoolHistoricalLiquidity_orderBy { poolId__id poolId__isInRecoveryMode poolId__isPaused + poolId__joinExitEnabled poolId__lambda + poolId__lastJoinExitAmp poolId__lastPostJoinExitInvariant poolId__lowerTarget poolId__mainIndex + poolId__managementAumFee poolId__managementFee + poolId__mustAllowlistLPs poolId__name poolId__oracleEnabled poolId__owner @@ -1264,6 +1563,8 @@ enum PoolHistoricalLiquidity_orderBy { poolId__sqrtBeta poolId__strategyType poolId__swapEnabled + poolId__swapEnabledCurationSignal + poolId__swapEnabledInternal poolId__swapFee poolId__swapsCount poolId__symbol @@ -1271,7 +1572,11 @@ enum PoolHistoricalLiquidity_orderBy { poolId__tauAlphaY poolId__tauBetaX poolId__tauBetaY + poolId__totalAumFeeCollectedInBPT poolId__totalLiquidity + poolId__totalLiquiditySansBPT + poolId__totalProtocolFee + poolId__totalProtocolFeePaidInBPT poolId__totalShares poolId__totalSwapFee poolId__totalSwapVolume @@ -1382,11 +1687,15 @@ enum PoolShare_orderBy { poolId__id poolId__isInRecoveryMode poolId__isPaused + poolId__joinExitEnabled poolId__lambda + poolId__lastJoinExitAmp poolId__lastPostJoinExitInvariant poolId__lowerTarget poolId__mainIndex + poolId__managementAumFee poolId__managementFee + poolId__mustAllowlistLPs poolId__name poolId__oracleEnabled poolId__owner @@ -1403,6 +1712,8 @@ enum PoolShare_orderBy { poolId__sqrtBeta poolId__strategyType poolId__swapEnabled + poolId__swapEnabledCurationSignal + poolId__swapEnabledInternal poolId__swapFee poolId__swapsCount poolId__symbol @@ -1410,7 +1721,11 @@ enum PoolShare_orderBy { poolId__tauAlphaY poolId__tauBetaX poolId__tauBetaY + poolId__totalAumFeeCollectedInBPT poolId__totalLiquidity + poolId__totalLiquiditySansBPT + poolId__totalProtocolFee + poolId__totalProtocolFeePaidInBPT poolId__totalShares poolId__totalSwapFee poolId__totalSwapVolume @@ -1433,6 +1748,7 @@ type PoolSnapshot { id: ID! liquidity: BigDecimal! pool: Pool! + protocolFee: BigDecimal swapFees: BigDecimal! swapVolume: BigDecimal! swapsCount: BigInt! @@ -1496,6 +1812,14 @@ input PoolSnapshot_filter { pool_not_starts_with_nocase: String pool_starts_with: String pool_starts_with_nocase: String + protocolFee: BigDecimal + protocolFee_gt: BigDecimal + protocolFee_gte: BigDecimal + protocolFee_in: [BigDecimal!] + protocolFee_lt: BigDecimal + protocolFee_lte: BigDecimal + protocolFee_not: BigDecimal + protocolFee_not_in: [BigDecimal!] swapFees: BigDecimal swapFees_gt: BigDecimal swapFees_gte: BigDecimal @@ -1560,11 +1884,15 @@ enum PoolSnapshot_orderBy { pool__id pool__isInRecoveryMode pool__isPaused + pool__joinExitEnabled pool__lambda + pool__lastJoinExitAmp pool__lastPostJoinExitInvariant pool__lowerTarget pool__mainIndex + pool__managementAumFee pool__managementFee + pool__mustAllowlistLPs pool__name pool__oracleEnabled pool__owner @@ -1581,6 +1909,8 @@ enum PoolSnapshot_orderBy { pool__sqrtBeta pool__strategyType pool__swapEnabled + pool__swapEnabledCurationSignal + pool__swapEnabledInternal pool__swapFee pool__swapsCount pool__symbol @@ -1588,7 +1918,11 @@ enum PoolSnapshot_orderBy { pool__tauAlphaY pool__tauBetaX pool__tauBetaY + pool__totalAumFeeCollectedInBPT pool__totalLiquidity + pool__totalLiquiditySansBPT + pool__totalProtocolFee + pool__totalProtocolFeePaidInBPT pool__totalShares pool__totalSwapFee pool__totalSwapVolume @@ -1601,6 +1935,7 @@ enum PoolSnapshot_orderBy { pool__w pool__wrappedIndex pool__z + protocolFee swapFees swapVolume swapsCount @@ -1613,6 +1948,7 @@ type PoolToken { assetManager: Bytes! balance: BigDecimal! cashBalance: BigDecimal! + circuitBreaker: CircuitBreaker decimals: Int! id: ID! index: Int @@ -1621,6 +1957,7 @@ type PoolToken { managements(first: Int = 100, orderBy: ManagementOperation_orderBy, orderDirection: OrderDirection, skip: Int = 0, where: ManagementOperation_filter): [ManagementOperation!] name: String! oldPriceRate: BigDecimal + paidProtocolFees: BigDecimal poolId: Pool priceRate: BigDecimal! symbol: String! @@ -1678,6 +2015,27 @@ input PoolToken_filter { cashBalance_lte: BigDecimal cashBalance_not: BigDecimal cashBalance_not_in: [BigDecimal!] + circuitBreaker: String + circuitBreaker_: CircuitBreaker_filter + circuitBreaker_contains: String + circuitBreaker_contains_nocase: String + circuitBreaker_ends_with: String + circuitBreaker_ends_with_nocase: String + circuitBreaker_gt: String + circuitBreaker_gte: String + circuitBreaker_in: [String!] + circuitBreaker_lt: String + circuitBreaker_lte: String + circuitBreaker_not: String + circuitBreaker_not_contains: String + circuitBreaker_not_contains_nocase: String + circuitBreaker_not_ends_with: String + circuitBreaker_not_ends_with_nocase: String + circuitBreaker_not_in: [String!] + circuitBreaker_not_starts_with: String + circuitBreaker_not_starts_with_nocase: String + circuitBreaker_starts_with: String + circuitBreaker_starts_with_nocase: String decimals: Int decimals_gt: Int decimals_gte: Int @@ -1744,6 +2102,14 @@ input PoolToken_filter { oldPriceRate_not: BigDecimal oldPriceRate_not_in: [BigDecimal!] or: [PoolToken_filter] + paidProtocolFees: BigDecimal + paidProtocolFees_gt: BigDecimal + paidProtocolFees_gte: BigDecimal + paidProtocolFees_in: [BigDecimal!] + paidProtocolFees_lt: BigDecimal + paidProtocolFees_lte: BigDecimal + paidProtocolFees_not: BigDecimal + paidProtocolFees_not_in: [BigDecimal!] poolId: String poolId_: Pool_filter poolId_contains: String @@ -1829,6 +2195,11 @@ enum PoolToken_orderBy { assetManager balance cashBalance + circuitBreaker + circuitBreaker__bptPrice + circuitBreaker__id + circuitBreaker__lowerBoundPercentage + circuitBreaker__upperBoundPercentage decimals id index @@ -1837,6 +2208,7 @@ enum PoolToken_orderBy { managements name oldPriceRate + paidProtocolFees poolId poolId__address poolId__alpha @@ -1854,11 +2226,15 @@ enum PoolToken_orderBy { poolId__id poolId__isInRecoveryMode poolId__isPaused + poolId__joinExitEnabled poolId__lambda + poolId__lastJoinExitAmp poolId__lastPostJoinExitInvariant poolId__lowerTarget poolId__mainIndex + poolId__managementAumFee poolId__managementFee + poolId__mustAllowlistLPs poolId__name poolId__oracleEnabled poolId__owner @@ -1875,6 +2251,8 @@ enum PoolToken_orderBy { poolId__sqrtBeta poolId__strategyType poolId__swapEnabled + poolId__swapEnabledCurationSignal + poolId__swapEnabledInternal poolId__swapFee poolId__swapsCount poolId__symbol @@ -1882,7 +2260,11 @@ enum PoolToken_orderBy { poolId__tauAlphaY poolId__tauBetaX poolId__tauBetaY + poolId__totalAumFeeCollectedInBPT poolId__totalLiquidity + poolId__totalLiquiditySansBPT + poolId__totalProtocolFee + poolId__totalProtocolFeePaidInBPT poolId__totalShares poolId__totalSwapFee poolId__totalSwapVolume @@ -1900,6 +2282,7 @@ enum PoolToken_orderBy { token token__address token__decimals + token__fxOracleDecimals token__id token__latestFXPrice token__latestUSDPrice @@ -1936,6 +2319,7 @@ input Pool_filter { alpha_not: BigDecimal alpha_not_in: [BigDecimal!] amp: BigInt + ampUpdates_: AmpUpdate_filter amp_gt: BigInt amp_gte: BigInt amp_in: [BigInt!] @@ -1970,6 +2354,7 @@ input Pool_filter { c_lte: BigDecimal c_not: BigDecimal c_not_in: [BigDecimal!] + circuitBreakers_: CircuitBreaker_filter createTime: Int createTime_gt: Int createTime_gte: Int @@ -2045,6 +2430,10 @@ input Pool_filter { isPaused_in: [Boolean!] isPaused_not: Boolean isPaused_not_in: [Boolean!] + joinExitEnabled: Boolean + joinExitEnabled_in: [Boolean!] + joinExitEnabled_not: Boolean + joinExitEnabled_not_in: [Boolean!] lambda: BigDecimal lambda_gt: BigDecimal lambda_gte: BigDecimal @@ -2053,6 +2442,14 @@ input Pool_filter { lambda_lte: BigDecimal lambda_not: BigDecimal lambda_not_in: [BigDecimal!] + lastJoinExitAmp: BigInt + lastJoinExitAmp_gt: BigInt + lastJoinExitAmp_gte: BigInt + lastJoinExitAmp_in: [BigInt!] + lastJoinExitAmp_lt: BigInt + lastJoinExitAmp_lte: BigInt + lastJoinExitAmp_not: BigInt + lastJoinExitAmp_not_in: [BigInt!] lastPostJoinExitInvariant: BigDecimal lastPostJoinExitInvariant_gt: BigDecimal lastPostJoinExitInvariant_gte: BigDecimal @@ -2061,6 +2458,27 @@ input Pool_filter { lastPostJoinExitInvariant_lte: BigDecimal lastPostJoinExitInvariant_not: BigDecimal lastPostJoinExitInvariant_not_in: [BigDecimal!] + latestAmpUpdate: String + latestAmpUpdate_: AmpUpdate_filter + latestAmpUpdate_contains: String + latestAmpUpdate_contains_nocase: String + latestAmpUpdate_ends_with: String + latestAmpUpdate_ends_with_nocase: String + latestAmpUpdate_gt: String + latestAmpUpdate_gte: String + latestAmpUpdate_in: [String!] + latestAmpUpdate_lt: String + latestAmpUpdate_lte: String + latestAmpUpdate_not: String + latestAmpUpdate_not_contains: String + latestAmpUpdate_not_contains_nocase: String + latestAmpUpdate_not_ends_with: String + latestAmpUpdate_not_ends_with_nocase: String + latestAmpUpdate_not_in: [String!] + latestAmpUpdate_not_starts_with: String + latestAmpUpdate_not_starts_with_nocase: String + latestAmpUpdate_starts_with: String + latestAmpUpdate_starts_with_nocase: String lowerTarget: BigDecimal lowerTarget_gt: BigDecimal lowerTarget_gte: BigDecimal @@ -2077,6 +2495,14 @@ input Pool_filter { mainIndex_lte: Int mainIndex_not: Int mainIndex_not_in: [Int!] + managementAumFee: BigDecimal + managementAumFee_gt: BigDecimal + managementAumFee_gte: BigDecimal + managementAumFee_in: [BigDecimal!] + managementAumFee_lt: BigDecimal + managementAumFee_lte: BigDecimal + managementAumFee_not: BigDecimal + managementAumFee_not_in: [BigDecimal!] managementFee: BigDecimal managementFee_gt: BigDecimal managementFee_gte: BigDecimal @@ -2085,6 +2511,10 @@ input Pool_filter { managementFee_lte: BigDecimal managementFee_not: BigDecimal managementFee_not_in: [BigDecimal!] + mustAllowlistLPs: Boolean + mustAllowlistLPs_in: [Boolean!] + mustAllowlistLPs_not: Boolean + mustAllowlistLPs_not_in: [Boolean!] name: String name_contains: String name_contains_nocase: String @@ -2255,6 +2685,14 @@ input Pool_filter { strategyType_not: Int strategyType_not_in: [Int!] swapEnabled: Boolean + swapEnabledCurationSignal: Boolean + swapEnabledCurationSignal_in: [Boolean!] + swapEnabledCurationSignal_not: Boolean + swapEnabledCurationSignal_not_in: [Boolean!] + swapEnabledInternal: Boolean + swapEnabledInternal_in: [Boolean!] + swapEnabledInternal_not: Boolean + swapEnabledInternal_not_in: [Boolean!] swapEnabled_in: [Boolean!] swapEnabled_not: Boolean swapEnabled_not_in: [Boolean!] @@ -2334,7 +2772,23 @@ input Pool_filter { tokensList_not_contains: [Bytes!] tokensList_not_contains_nocase: [Bytes!] tokens_: PoolToken_filter + totalAumFeeCollectedInBPT: BigDecimal + totalAumFeeCollectedInBPT_gt: BigDecimal + totalAumFeeCollectedInBPT_gte: BigDecimal + totalAumFeeCollectedInBPT_in: [BigDecimal!] + totalAumFeeCollectedInBPT_lt: BigDecimal + totalAumFeeCollectedInBPT_lte: BigDecimal + totalAumFeeCollectedInBPT_not: BigDecimal + totalAumFeeCollectedInBPT_not_in: [BigDecimal!] totalLiquidity: BigDecimal + totalLiquiditySansBPT: BigDecimal + totalLiquiditySansBPT_gt: BigDecimal + totalLiquiditySansBPT_gte: BigDecimal + totalLiquiditySansBPT_in: [BigDecimal!] + totalLiquiditySansBPT_lt: BigDecimal + totalLiquiditySansBPT_lte: BigDecimal + totalLiquiditySansBPT_not: BigDecimal + totalLiquiditySansBPT_not_in: [BigDecimal!] totalLiquidity_gt: BigDecimal totalLiquidity_gte: BigDecimal totalLiquidity_in: [BigDecimal!] @@ -2342,6 +2796,22 @@ input Pool_filter { totalLiquidity_lte: BigDecimal totalLiquidity_not: BigDecimal totalLiquidity_not_in: [BigDecimal!] + totalProtocolFee: BigDecimal + totalProtocolFeePaidInBPT: BigDecimal + totalProtocolFeePaidInBPT_gt: BigDecimal + totalProtocolFeePaidInBPT_gte: BigDecimal + totalProtocolFeePaidInBPT_in: [BigDecimal!] + totalProtocolFeePaidInBPT_lt: BigDecimal + totalProtocolFeePaidInBPT_lte: BigDecimal + totalProtocolFeePaidInBPT_not: BigDecimal + totalProtocolFeePaidInBPT_not_in: [BigDecimal!] + totalProtocolFee_gt: BigDecimal + totalProtocolFee_gte: BigDecimal + totalProtocolFee_in: [BigDecimal!] + totalProtocolFee_lt: BigDecimal + totalProtocolFee_lte: BigDecimal + totalProtocolFee_not: BigDecimal + totalProtocolFee_not_in: [BigDecimal!] totalShares: BigDecimal totalShares_gt: BigDecimal totalShares_gte: BigDecimal @@ -2468,9 +2938,11 @@ enum Pool_orderBy { address alpha amp + ampUpdates baseToken beta c + circuitBreakers createTime dSq delta @@ -2482,11 +2954,22 @@ enum Pool_orderBy { id isInRecoveryMode isPaused + joinExitEnabled lambda + lastJoinExitAmp lastPostJoinExitInvariant + latestAmpUpdate + latestAmpUpdate__endAmp + latestAmpUpdate__endTimestamp + latestAmpUpdate__id + latestAmpUpdate__scheduledTimestamp + latestAmpUpdate__startAmp + latestAmpUpdate__startTimestamp lowerTarget mainIndex + managementAumFee managementFee + mustAllowlistLPs name oracleEnabled owner @@ -2509,6 +2992,8 @@ enum Pool_orderBy { sqrtBeta strategyType swapEnabled + swapEnabledCurationSignal + swapEnabledInternal swapFee swaps swapsCount @@ -2519,7 +3004,11 @@ enum Pool_orderBy { tauBetaY tokens tokensList + totalAumFeeCollectedInBPT totalLiquidity + totalLiquiditySansBPT + totalProtocolFee + totalProtocolFeePaidInBPT totalShares totalSwapFee totalSwapVolume @@ -2532,7 +3021,9 @@ enum Pool_orderBy { vaultID vaultID__id vaultID__poolCount + vaultID__protocolFeesCollector vaultID__totalLiquidity + vaultID__totalProtocolFee vaultID__totalSwapCount vaultID__totalSwapFee vaultID__totalSwapVolume @@ -2675,11 +3166,15 @@ enum PriceRateProvider_orderBy { poolId__id poolId__isInRecoveryMode poolId__isPaused + poolId__joinExitEnabled poolId__lambda + poolId__lastJoinExitAmp poolId__lastPostJoinExitInvariant poolId__lowerTarget poolId__mainIndex + poolId__managementAumFee poolId__managementFee + poolId__mustAllowlistLPs poolId__name poolId__oracleEnabled poolId__owner @@ -2696,6 +3191,8 @@ enum PriceRateProvider_orderBy { poolId__sqrtBeta poolId__strategyType poolId__swapEnabled + poolId__swapEnabledCurationSignal + poolId__swapEnabledInternal poolId__swapFee poolId__swapsCount poolId__symbol @@ -2703,7 +3200,11 @@ enum PriceRateProvider_orderBy { poolId__tauAlphaY poolId__tauBetaX poolId__tauBetaY + poolId__totalAumFeeCollectedInBPT poolId__totalLiquidity + poolId__totalLiquiditySansBPT + poolId__totalProtocolFee + poolId__totalProtocolFeePaidInBPT poolId__totalShares poolId__totalSwapFee poolId__totalSwapVolume @@ -2729,6 +3230,7 @@ enum PriceRateProvider_orderBy { token__managedBalance token__name token__oldPriceRate + token__paidProtocolFees token__priceRate token__symbol token__weight @@ -2866,6 +3368,34 @@ type Query { subgraphError: _SubgraphErrorPolicy_! = deny where: Balancer_filter ): [Balancer!]! + circuitBreaker( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + id: ID! + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): CircuitBreaker + circuitBreakers( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + first: Int = 100 + orderBy: CircuitBreaker_orderBy + orderDirection: OrderDirection + skip: Int = 0 + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + where: CircuitBreaker_filter + ): [CircuitBreaker!]! gradualWeightUpdate( """ The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. @@ -3543,6 +4073,34 @@ type Subscription { subgraphError: _SubgraphErrorPolicy_! = deny where: Balancer_filter ): [Balancer!]! + circuitBreaker( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + id: ID! + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): CircuitBreaker + circuitBreakers( + """ + The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. + """ + block: Block_height + first: Int = 100 + orderBy: CircuitBreaker_orderBy + orderDirection: OrderDirection + skip: Int = 0 + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + where: CircuitBreaker_filter + ): [CircuitBreaker!]! gradualWeightUpdate( """ The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted. @@ -4256,11 +4814,15 @@ enum SwapFeeUpdate_orderBy { pool__id pool__isInRecoveryMode pool__isPaused + pool__joinExitEnabled pool__lambda + pool__lastJoinExitAmp pool__lastPostJoinExitInvariant pool__lowerTarget pool__mainIndex + pool__managementAumFee pool__managementFee + pool__mustAllowlistLPs pool__name pool__oracleEnabled pool__owner @@ -4277,6 +4839,8 @@ enum SwapFeeUpdate_orderBy { pool__sqrtBeta pool__strategyType pool__swapEnabled + pool__swapEnabledCurationSignal + pool__swapEnabledInternal pool__swapFee pool__swapsCount pool__symbol @@ -4284,7 +4848,11 @@ enum SwapFeeUpdate_orderBy { pool__tauAlphaY pool__tauBetaX pool__tauBetaY + pool__totalAumFeeCollectedInBPT pool__totalLiquidity + pool__totalLiquiditySansBPT + pool__totalProtocolFee + pool__totalProtocolFeePaidInBPT pool__totalShares pool__totalSwapFee pool__totalSwapVolume @@ -4491,11 +5059,15 @@ enum Swap_orderBy { poolId__id poolId__isInRecoveryMode poolId__isPaused + poolId__joinExitEnabled poolId__lambda + poolId__lastJoinExitAmp poolId__lastPostJoinExitInvariant poolId__lowerTarget poolId__mainIndex + poolId__managementAumFee poolId__managementFee + poolId__mustAllowlistLPs poolId__name poolId__oracleEnabled poolId__owner @@ -4512,6 +5084,8 @@ enum Swap_orderBy { poolId__sqrtBeta poolId__strategyType poolId__swapEnabled + poolId__swapEnabledCurationSignal + poolId__swapEnabledInternal poolId__swapFee poolId__swapsCount poolId__symbol @@ -4519,7 +5093,11 @@ enum Swap_orderBy { poolId__tauAlphaY poolId__tauBetaX poolId__tauBetaY + poolId__totalAumFeeCollectedInBPT poolId__totalLiquidity + poolId__totalLiquiditySansBPT + poolId__totalProtocolFee + poolId__totalProtocolFeePaidInBPT poolId__totalShares poolId__totalSwapFee poolId__totalSwapVolume @@ -4548,6 +5126,7 @@ enum Swap_orderBy { type Token { address: String! decimals: Int! + fxOracleDecimals: Int id: ID! latestFXPrice: BigDecimal latestPrice: LatestPrice @@ -4684,11 +5263,15 @@ enum TokenPrice_orderBy { poolId__id poolId__isInRecoveryMode poolId__isPaused + poolId__joinExitEnabled poolId__lambda + poolId__lastJoinExitAmp poolId__lastPostJoinExitInvariant poolId__lowerTarget poolId__mainIndex + poolId__managementAumFee poolId__managementFee + poolId__mustAllowlistLPs poolId__name poolId__oracleEnabled poolId__owner @@ -4705,6 +5288,8 @@ enum TokenPrice_orderBy { poolId__sqrtBeta poolId__strategyType poolId__swapEnabled + poolId__swapEnabledCurationSignal + poolId__swapEnabledInternal poolId__swapFee poolId__swapsCount poolId__symbol @@ -4712,7 +5297,11 @@ enum TokenPrice_orderBy { poolId__tauAlphaY poolId__tauBetaX poolId__tauBetaY + poolId__totalAumFeeCollectedInBPT poolId__totalLiquidity + poolId__totalLiquiditySansBPT + poolId__totalProtocolFee + poolId__totalProtocolFeePaidInBPT poolId__totalShares poolId__totalSwapFee poolId__totalSwapVolume @@ -4831,6 +5420,7 @@ enum TokenSnapshot_orderBy { token token__address token__decimals + token__fxOracleDecimals token__id token__latestFXPrice token__latestUSDPrice @@ -4881,6 +5471,14 @@ input Token_filter { decimals_lte: Int decimals_not: Int decimals_not_in: [Int!] + fxOracleDecimals: Int + fxOracleDecimals_gt: Int + fxOracleDecimals_gte: Int + fxOracleDecimals_in: [Int!] + fxOracleDecimals_lt: Int + fxOracleDecimals_lte: Int + fxOracleDecimals_not: Int + fxOracleDecimals_not_in: [Int!] id: ID id_gt: ID id_gte: ID @@ -5041,6 +5639,7 @@ input Token_filter { enum Token_orderBy { address decimals + fxOracleDecimals id latestFXPrice latestPrice @@ -5069,11 +5668,15 @@ enum Token_orderBy { pool__id pool__isInRecoveryMode pool__isPaused + pool__joinExitEnabled pool__lambda + pool__lastJoinExitAmp pool__lastPostJoinExitInvariant pool__lowerTarget pool__mainIndex + pool__managementAumFee pool__managementFee + pool__mustAllowlistLPs pool__name pool__oracleEnabled pool__owner @@ -5090,6 +5693,8 @@ enum Token_orderBy { pool__sqrtBeta pool__strategyType pool__swapEnabled + pool__swapEnabledCurationSignal + pool__swapEnabledInternal pool__swapFee pool__swapsCount pool__symbol @@ -5097,7 +5702,11 @@ enum Token_orderBy { pool__tauAlphaY pool__tauBetaX pool__tauBetaY + pool__totalAumFeeCollectedInBPT pool__totalLiquidity + pool__totalLiquiditySansBPT + pool__totalProtocolFee + pool__totalProtocolFeePaidInBPT pool__totalShares pool__totalSwapFee pool__totalSwapVolume @@ -5284,6 +5893,7 @@ enum TradePair_orderBy { token0 token0__address token0__decimals + token0__fxOracleDecimals token0__id token0__latestFXPrice token0__latestUSDPrice @@ -5298,6 +5908,7 @@ enum TradePair_orderBy { token1 token1__address token1__decimals + token1__fxOracleDecimals token1__id token1__latestFXPrice token1__latestUSDPrice @@ -5324,6 +5935,7 @@ type UserInternalBalance { balance: BigDecimal! id: ID! token: Bytes! + tokenInfo: Token userAddress: User } @@ -5349,6 +5961,27 @@ input UserInternalBalance_filter { id_not_in: [ID!] or: [UserInternalBalance_filter] token: Bytes + tokenInfo: String + tokenInfo_: Token_filter + tokenInfo_contains: String + tokenInfo_contains_nocase: String + tokenInfo_ends_with: String + tokenInfo_ends_with_nocase: String + tokenInfo_gt: String + tokenInfo_gte: String + tokenInfo_in: [String!] + tokenInfo_lt: String + tokenInfo_lte: String + tokenInfo_not: String + tokenInfo_not_contains: String + tokenInfo_not_contains_nocase: String + tokenInfo_not_ends_with: String + tokenInfo_not_ends_with_nocase: String + tokenInfo_not_in: [String!] + tokenInfo_not_starts_with: String + tokenInfo_not_starts_with_nocase: String + tokenInfo_starts_with: String + tokenInfo_starts_with_nocase: String token_contains: Bytes token_gt: Bytes token_gte: Bytes @@ -5385,6 +6018,21 @@ enum UserInternalBalance_orderBy { balance id token + tokenInfo + tokenInfo__address + tokenInfo__decimals + tokenInfo__fxOracleDecimals + tokenInfo__id + tokenInfo__latestFXPrice + tokenInfo__latestUSDPrice + tokenInfo__latestUSDPriceTimestamp + tokenInfo__name + tokenInfo__symbol + tokenInfo__totalBalanceNotional + tokenInfo__totalBalanceUSD + tokenInfo__totalSwapCount + tokenInfo__totalVolumeNotional + tokenInfo__totalVolumeUSD userAddress userAddress__id } diff --git a/balancer-js/src/modules/subgraph/generated/balancer-subgraph-types.ts b/balancer-js/src/modules/subgraph/generated/balancer-subgraph-types.ts index 7787c788b..5da13f246 100644 --- a/balancer-js/src/modules/subgraph/generated/balancer-subgraph-types.ts +++ b/balancer-js/src/modules/subgraph/generated/balancer-subgraph-types.ts @@ -16,6 +16,7 @@ export type Scalars = { BigDecimal: string; BigInt: string; Bytes: string; + Int8: any; }; export type AmpUpdate = { @@ -126,11 +127,15 @@ export enum AmpUpdate_OrderBy { PoolIdId = 'poolId__id', PoolIdIsInRecoveryMode = 'poolId__isInRecoveryMode', PoolIdIsPaused = 'poolId__isPaused', + PoolIdJoinExitEnabled = 'poolId__joinExitEnabled', PoolIdLambda = 'poolId__lambda', + PoolIdLastJoinExitAmp = 'poolId__lastJoinExitAmp', PoolIdLastPostJoinExitInvariant = 'poolId__lastPostJoinExitInvariant', PoolIdLowerTarget = 'poolId__lowerTarget', PoolIdMainIndex = 'poolId__mainIndex', + PoolIdManagementAumFee = 'poolId__managementAumFee', PoolIdManagementFee = 'poolId__managementFee', + PoolIdMustAllowlistLPs = 'poolId__mustAllowlistLPs', PoolIdName = 'poolId__name', PoolIdOracleEnabled = 'poolId__oracleEnabled', PoolIdOwner = 'poolId__owner', @@ -147,6 +152,8 @@ export enum AmpUpdate_OrderBy { PoolIdSqrtBeta = 'poolId__sqrtBeta', PoolIdStrategyType = 'poolId__strategyType', PoolIdSwapEnabled = 'poolId__swapEnabled', + PoolIdSwapEnabledCurationSignal = 'poolId__swapEnabledCurationSignal', + PoolIdSwapEnabledInternal = 'poolId__swapEnabledInternal', PoolIdSwapFee = 'poolId__swapFee', PoolIdSwapsCount = 'poolId__swapsCount', PoolIdSymbol = 'poolId__symbol', @@ -154,7 +161,11 @@ export enum AmpUpdate_OrderBy { PoolIdTauAlphaY = 'poolId__tauAlphaY', PoolIdTauBetaX = 'poolId__tauBetaX', PoolIdTauBetaY = 'poolId__tauBetaY', + PoolIdTotalAumFeeCollectedInBpt = 'poolId__totalAumFeeCollectedInBPT', PoolIdTotalLiquidity = 'poolId__totalLiquidity', + PoolIdTotalLiquiditySansBpt = 'poolId__totalLiquiditySansBPT', + PoolIdTotalProtocolFee = 'poolId__totalProtocolFee', + PoolIdTotalProtocolFeePaidInBpt = 'poolId__totalProtocolFeePaidInBPT', PoolIdTotalShares = 'poolId__totalShares', PoolIdTotalSwapFee = 'poolId__totalSwapFee', PoolIdTotalSwapVolume = 'poolId__totalSwapVolume', @@ -177,7 +188,9 @@ export type Balancer = { id: Scalars['ID']; poolCount: Scalars['Int']; pools?: Maybe>; + protocolFeesCollector?: Maybe; totalLiquidity: Scalars['BigDecimal']; + totalProtocolFee?: Maybe; totalSwapCount: Scalars['BigInt']; totalSwapFee: Scalars['BigDecimal']; totalSwapVolume: Scalars['BigDecimal']; @@ -198,6 +211,7 @@ export type BalancerSnapshot = { poolCount: Scalars['Int']; timestamp: Scalars['Int']; totalLiquidity: Scalars['BigDecimal']; + totalProtocolFee?: Maybe; totalSwapCount: Scalars['BigInt']; totalSwapFee: Scalars['BigDecimal']; totalSwapVolume: Scalars['BigDecimal']; @@ -241,6 +255,14 @@ export type BalancerSnapshot_Filter = { totalLiquidity_lte?: InputMaybe; totalLiquidity_not?: InputMaybe; totalLiquidity_not_in?: InputMaybe>; + totalProtocolFee?: InputMaybe; + totalProtocolFee_gt?: InputMaybe; + totalProtocolFee_gte?: InputMaybe; + totalProtocolFee_in?: InputMaybe>; + totalProtocolFee_lt?: InputMaybe; + totalProtocolFee_lte?: InputMaybe; + totalProtocolFee_not?: InputMaybe; + totalProtocolFee_not_in?: InputMaybe>; totalSwapCount?: InputMaybe; totalSwapCount_gt?: InputMaybe; totalSwapCount_gte?: InputMaybe; @@ -293,13 +315,16 @@ export enum BalancerSnapshot_OrderBy { PoolCount = 'poolCount', Timestamp = 'timestamp', TotalLiquidity = 'totalLiquidity', + TotalProtocolFee = 'totalProtocolFee', TotalSwapCount = 'totalSwapCount', TotalSwapFee = 'totalSwapFee', TotalSwapVolume = 'totalSwapVolume', Vault = 'vault', VaultId = 'vault__id', VaultPoolCount = 'vault__poolCount', + VaultProtocolFeesCollector = 'vault__protocolFeesCollector', VaultTotalLiquidity = 'vault__totalLiquidity', + VaultTotalProtocolFee = 'vault__totalProtocolFee', VaultTotalSwapCount = 'vault__totalSwapCount', VaultTotalSwapFee = 'vault__totalSwapFee', VaultTotalSwapVolume = 'vault__totalSwapVolume' @@ -327,6 +352,16 @@ export type Balancer_Filter = { poolCount_not?: InputMaybe; poolCount_not_in?: InputMaybe>; pools_?: InputMaybe; + protocolFeesCollector?: InputMaybe; + protocolFeesCollector_contains?: InputMaybe; + protocolFeesCollector_gt?: InputMaybe; + protocolFeesCollector_gte?: InputMaybe; + protocolFeesCollector_in?: InputMaybe>; + protocolFeesCollector_lt?: InputMaybe; + protocolFeesCollector_lte?: InputMaybe; + protocolFeesCollector_not?: InputMaybe; + protocolFeesCollector_not_contains?: InputMaybe; + protocolFeesCollector_not_in?: InputMaybe>; totalLiquidity?: InputMaybe; totalLiquidity_gt?: InputMaybe; totalLiquidity_gte?: InputMaybe; @@ -335,6 +370,14 @@ export type Balancer_Filter = { totalLiquidity_lte?: InputMaybe; totalLiquidity_not?: InputMaybe; totalLiquidity_not_in?: InputMaybe>; + totalProtocolFee?: InputMaybe; + totalProtocolFee_gt?: InputMaybe; + totalProtocolFee_gte?: InputMaybe; + totalProtocolFee_in?: InputMaybe>; + totalProtocolFee_lt?: InputMaybe; + totalProtocolFee_lte?: InputMaybe; + totalProtocolFee_not?: InputMaybe; + totalProtocolFee_not_in?: InputMaybe>; totalSwapCount?: InputMaybe; totalSwapCount_gt?: InputMaybe; totalSwapCount_gte?: InputMaybe; @@ -365,7 +408,9 @@ export enum Balancer_OrderBy { Id = 'id', PoolCount = 'poolCount', Pools = 'pools', + ProtocolFeesCollector = 'protocolFeesCollector', TotalLiquidity = 'totalLiquidity', + TotalProtocolFee = 'totalProtocolFee', TotalSwapCount = 'totalSwapCount', TotalSwapFee = 'totalSwapFee', TotalSwapVolume = 'totalSwapVolume' @@ -381,6 +426,188 @@ export type Block_Height = { number_gte?: InputMaybe; }; +export type CircuitBreaker = { + __typename?: 'CircuitBreaker'; + bptPrice: Scalars['BigDecimal']; + id: Scalars['ID']; + lowerBoundPercentage: Scalars['BigDecimal']; + pool: Pool; + token: PoolToken; + upperBoundPercentage: Scalars['BigDecimal']; +}; + +export type CircuitBreaker_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + and?: InputMaybe>>; + bptPrice?: InputMaybe; + bptPrice_gt?: InputMaybe; + bptPrice_gte?: InputMaybe; + bptPrice_in?: InputMaybe>; + bptPrice_lt?: InputMaybe; + bptPrice_lte?: InputMaybe; + bptPrice_not?: InputMaybe; + bptPrice_not_in?: InputMaybe>; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + lowerBoundPercentage?: InputMaybe; + lowerBoundPercentage_gt?: InputMaybe; + lowerBoundPercentage_gte?: InputMaybe; + lowerBoundPercentage_in?: InputMaybe>; + lowerBoundPercentage_lt?: InputMaybe; + lowerBoundPercentage_lte?: InputMaybe; + lowerBoundPercentage_not?: InputMaybe; + lowerBoundPercentage_not_in?: InputMaybe>; + or?: InputMaybe>>; + pool?: InputMaybe; + pool_?: InputMaybe; + pool_contains?: InputMaybe; + pool_contains_nocase?: InputMaybe; + pool_ends_with?: InputMaybe; + pool_ends_with_nocase?: InputMaybe; + pool_gt?: InputMaybe; + pool_gte?: InputMaybe; + pool_in?: InputMaybe>; + pool_lt?: InputMaybe; + pool_lte?: InputMaybe; + pool_not?: InputMaybe; + pool_not_contains?: InputMaybe; + pool_not_contains_nocase?: InputMaybe; + pool_not_ends_with?: InputMaybe; + pool_not_ends_with_nocase?: InputMaybe; + pool_not_in?: InputMaybe>; + pool_not_starts_with?: InputMaybe; + pool_not_starts_with_nocase?: InputMaybe; + pool_starts_with?: InputMaybe; + pool_starts_with_nocase?: InputMaybe; + token?: InputMaybe; + token_?: InputMaybe; + token_contains?: InputMaybe; + token_contains_nocase?: InputMaybe; + token_ends_with?: InputMaybe; + token_ends_with_nocase?: InputMaybe; + token_gt?: InputMaybe; + token_gte?: InputMaybe; + token_in?: InputMaybe>; + token_lt?: InputMaybe; + token_lte?: InputMaybe; + token_not?: InputMaybe; + token_not_contains?: InputMaybe; + token_not_contains_nocase?: InputMaybe; + token_not_ends_with?: InputMaybe; + token_not_ends_with_nocase?: InputMaybe; + token_not_in?: InputMaybe>; + token_not_starts_with?: InputMaybe; + token_not_starts_with_nocase?: InputMaybe; + token_starts_with?: InputMaybe; + token_starts_with_nocase?: InputMaybe; + upperBoundPercentage?: InputMaybe; + upperBoundPercentage_gt?: InputMaybe; + upperBoundPercentage_gte?: InputMaybe; + upperBoundPercentage_in?: InputMaybe>; + upperBoundPercentage_lt?: InputMaybe; + upperBoundPercentage_lte?: InputMaybe; + upperBoundPercentage_not?: InputMaybe; + upperBoundPercentage_not_in?: InputMaybe>; +}; + +export enum CircuitBreaker_OrderBy { + BptPrice = 'bptPrice', + Id = 'id', + LowerBoundPercentage = 'lowerBoundPercentage', + Pool = 'pool', + PoolAddress = 'pool__address', + PoolAlpha = 'pool__alpha', + PoolAmp = 'pool__amp', + PoolBaseToken = 'pool__baseToken', + PoolBeta = 'pool__beta', + PoolC = 'pool__c', + PoolCreateTime = 'pool__createTime', + PoolDSq = 'pool__dSq', + PoolDelta = 'pool__delta', + PoolEpsilon = 'pool__epsilon', + PoolExpiryTime = 'pool__expiryTime', + PoolFactory = 'pool__factory', + PoolHoldersCount = 'pool__holdersCount', + PoolId = 'pool__id', + PoolIsInRecoveryMode = 'pool__isInRecoveryMode', + PoolIsPaused = 'pool__isPaused', + PoolJoinExitEnabled = 'pool__joinExitEnabled', + PoolLambda = 'pool__lambda', + PoolLastJoinExitAmp = 'pool__lastJoinExitAmp', + PoolLastPostJoinExitInvariant = 'pool__lastPostJoinExitInvariant', + PoolLowerTarget = 'pool__lowerTarget', + PoolMainIndex = 'pool__mainIndex', + PoolManagementAumFee = 'pool__managementAumFee', + PoolManagementFee = 'pool__managementFee', + PoolMustAllowlistLPs = 'pool__mustAllowlistLPs', + PoolName = 'pool__name', + PoolOracleEnabled = 'pool__oracleEnabled', + PoolOwner = 'pool__owner', + PoolPoolType = 'pool__poolType', + PoolPoolTypeVersion = 'pool__poolTypeVersion', + PoolPrincipalToken = 'pool__principalToken', + PoolProtocolAumFeeCache = 'pool__protocolAumFeeCache', + PoolProtocolId = 'pool__protocolId', + PoolProtocolSwapFeeCache = 'pool__protocolSwapFeeCache', + PoolProtocolYieldFeeCache = 'pool__protocolYieldFeeCache', + PoolRoot3Alpha = 'pool__root3Alpha', + PoolS = 'pool__s', + PoolSqrtAlpha = 'pool__sqrtAlpha', + PoolSqrtBeta = 'pool__sqrtBeta', + PoolStrategyType = 'pool__strategyType', + PoolSwapEnabled = 'pool__swapEnabled', + PoolSwapEnabledCurationSignal = 'pool__swapEnabledCurationSignal', + PoolSwapEnabledInternal = 'pool__swapEnabledInternal', + PoolSwapFee = 'pool__swapFee', + PoolSwapsCount = 'pool__swapsCount', + PoolSymbol = 'pool__symbol', + PoolTauAlphaX = 'pool__tauAlphaX', + PoolTauAlphaY = 'pool__tauAlphaY', + PoolTauBetaX = 'pool__tauBetaX', + PoolTauBetaY = 'pool__tauBetaY', + PoolTotalAumFeeCollectedInBpt = 'pool__totalAumFeeCollectedInBPT', + PoolTotalLiquidity = 'pool__totalLiquidity', + PoolTotalLiquiditySansBpt = 'pool__totalLiquiditySansBPT', + PoolTotalProtocolFee = 'pool__totalProtocolFee', + PoolTotalProtocolFeePaidInBpt = 'pool__totalProtocolFeePaidInBPT', + PoolTotalShares = 'pool__totalShares', + PoolTotalSwapFee = 'pool__totalSwapFee', + PoolTotalSwapVolume = 'pool__totalSwapVolume', + PoolTotalWeight = 'pool__totalWeight', + PoolTx = 'pool__tx', + PoolU = 'pool__u', + PoolUnitSeconds = 'pool__unitSeconds', + PoolUpperTarget = 'pool__upperTarget', + PoolV = 'pool__v', + PoolW = 'pool__w', + PoolWrappedIndex = 'pool__wrappedIndex', + PoolZ = 'pool__z', + Token = 'token', + TokenAddress = 'token__address', + TokenAssetManager = 'token__assetManager', + TokenBalance = 'token__balance', + TokenCashBalance = 'token__cashBalance', + TokenDecimals = 'token__decimals', + TokenId = 'token__id', + TokenIndex = 'token__index', + TokenIsExemptFromYieldProtocolFee = 'token__isExemptFromYieldProtocolFee', + TokenManagedBalance = 'token__managedBalance', + TokenName = 'token__name', + TokenOldPriceRate = 'token__oldPriceRate', + TokenPaidProtocolFees = 'token__paidProtocolFees', + TokenPriceRate = 'token__priceRate', + TokenSymbol = 'token__symbol', + TokenWeight = 'token__weight', + UpperBoundPercentage = 'upperBoundPercentage' +} + export type GradualWeightUpdate = { __typename?: 'GradualWeightUpdate'; endTimestamp: Scalars['BigInt']; @@ -485,11 +712,15 @@ export enum GradualWeightUpdate_OrderBy { PoolIdId = 'poolId__id', PoolIdIsInRecoveryMode = 'poolId__isInRecoveryMode', PoolIdIsPaused = 'poolId__isPaused', + PoolIdJoinExitEnabled = 'poolId__joinExitEnabled', PoolIdLambda = 'poolId__lambda', + PoolIdLastJoinExitAmp = 'poolId__lastJoinExitAmp', PoolIdLastPostJoinExitInvariant = 'poolId__lastPostJoinExitInvariant', PoolIdLowerTarget = 'poolId__lowerTarget', PoolIdMainIndex = 'poolId__mainIndex', + PoolIdManagementAumFee = 'poolId__managementAumFee', PoolIdManagementFee = 'poolId__managementFee', + PoolIdMustAllowlistLPs = 'poolId__mustAllowlistLPs', PoolIdName = 'poolId__name', PoolIdOracleEnabled = 'poolId__oracleEnabled', PoolIdOwner = 'poolId__owner', @@ -506,6 +737,8 @@ export enum GradualWeightUpdate_OrderBy { PoolIdSqrtBeta = 'poolId__sqrtBeta', PoolIdStrategyType = 'poolId__strategyType', PoolIdSwapEnabled = 'poolId__swapEnabled', + PoolIdSwapEnabledCurationSignal = 'poolId__swapEnabledCurationSignal', + PoolIdSwapEnabledInternal = 'poolId__swapEnabledInternal', PoolIdSwapFee = 'poolId__swapFee', PoolIdSwapsCount = 'poolId__swapsCount', PoolIdSymbol = 'poolId__symbol', @@ -513,7 +746,11 @@ export enum GradualWeightUpdate_OrderBy { PoolIdTauAlphaY = 'poolId__tauAlphaY', PoolIdTauBetaX = 'poolId__tauBetaX', PoolIdTauBetaY = 'poolId__tauBetaY', + PoolIdTotalAumFeeCollectedInBpt = 'poolId__totalAumFeeCollectedInBPT', PoolIdTotalLiquidity = 'poolId__totalLiquidity', + PoolIdTotalLiquiditySansBpt = 'poolId__totalLiquiditySansBPT', + PoolIdTotalProtocolFee = 'poolId__totalProtocolFee', + PoolIdTotalProtocolFeePaidInBpt = 'poolId__totalProtocolFeePaidInBPT', PoolIdTotalShares = 'poolId__totalShares', PoolIdTotalSwapFee = 'poolId__totalSwapFee', PoolIdTotalSwapVolume = 'poolId__totalSwapVolume', @@ -672,11 +909,15 @@ export enum JoinExit_OrderBy { PoolId = 'pool__id', PoolIsInRecoveryMode = 'pool__isInRecoveryMode', PoolIsPaused = 'pool__isPaused', + PoolJoinExitEnabled = 'pool__joinExitEnabled', PoolLambda = 'pool__lambda', + PoolLastJoinExitAmp = 'pool__lastJoinExitAmp', PoolLastPostJoinExitInvariant = 'pool__lastPostJoinExitInvariant', PoolLowerTarget = 'pool__lowerTarget', PoolMainIndex = 'pool__mainIndex', + PoolManagementAumFee = 'pool__managementAumFee', PoolManagementFee = 'pool__managementFee', + PoolMustAllowlistLPs = 'pool__mustAllowlistLPs', PoolName = 'pool__name', PoolOracleEnabled = 'pool__oracleEnabled', PoolOwner = 'pool__owner', @@ -693,6 +934,8 @@ export enum JoinExit_OrderBy { PoolSqrtBeta = 'pool__sqrtBeta', PoolStrategyType = 'pool__strategyType', PoolSwapEnabled = 'pool__swapEnabled', + PoolSwapEnabledCurationSignal = 'pool__swapEnabledCurationSignal', + PoolSwapEnabledInternal = 'pool__swapEnabledInternal', PoolSwapFee = 'pool__swapFee', PoolSwapsCount = 'pool__swapsCount', PoolSymbol = 'pool__symbol', @@ -700,7 +943,11 @@ export enum JoinExit_OrderBy { PoolTauAlphaY = 'pool__tauAlphaY', PoolTauBetaX = 'pool__tauBetaX', PoolTauBetaY = 'pool__tauBetaY', + PoolTotalAumFeeCollectedInBpt = 'pool__totalAumFeeCollectedInBPT', PoolTotalLiquidity = 'pool__totalLiquidity', + PoolTotalLiquiditySansBpt = 'pool__totalLiquiditySansBPT', + PoolTotalProtocolFee = 'pool__totalProtocolFee', + PoolTotalProtocolFeePaidInBpt = 'pool__totalProtocolFeePaidInBPT', PoolTotalShares = 'pool__totalShares', PoolTotalSwapFee = 'pool__totalSwapFee', PoolTotalSwapVolume = 'pool__totalSwapVolume', @@ -825,11 +1072,15 @@ export enum LatestPrice_OrderBy { PoolIdId = 'poolId__id', PoolIdIsInRecoveryMode = 'poolId__isInRecoveryMode', PoolIdIsPaused = 'poolId__isPaused', + PoolIdJoinExitEnabled = 'poolId__joinExitEnabled', PoolIdLambda = 'poolId__lambda', + PoolIdLastJoinExitAmp = 'poolId__lastJoinExitAmp', PoolIdLastPostJoinExitInvariant = 'poolId__lastPostJoinExitInvariant', PoolIdLowerTarget = 'poolId__lowerTarget', PoolIdMainIndex = 'poolId__mainIndex', + PoolIdManagementAumFee = 'poolId__managementAumFee', PoolIdManagementFee = 'poolId__managementFee', + PoolIdMustAllowlistLPs = 'poolId__mustAllowlistLPs', PoolIdName = 'poolId__name', PoolIdOracleEnabled = 'poolId__oracleEnabled', PoolIdOwner = 'poolId__owner', @@ -846,6 +1097,8 @@ export enum LatestPrice_OrderBy { PoolIdSqrtBeta = 'poolId__sqrtBeta', PoolIdStrategyType = 'poolId__strategyType', PoolIdSwapEnabled = 'poolId__swapEnabled', + PoolIdSwapEnabledCurationSignal = 'poolId__swapEnabledCurationSignal', + PoolIdSwapEnabledInternal = 'poolId__swapEnabledInternal', PoolIdSwapFee = 'poolId__swapFee', PoolIdSwapsCount = 'poolId__swapsCount', PoolIdSymbol = 'poolId__symbol', @@ -853,7 +1106,11 @@ export enum LatestPrice_OrderBy { PoolIdTauAlphaY = 'poolId__tauAlphaY', PoolIdTauBetaX = 'poolId__tauBetaX', PoolIdTauBetaY = 'poolId__tauBetaY', + PoolIdTotalAumFeeCollectedInBpt = 'poolId__totalAumFeeCollectedInBPT', PoolIdTotalLiquidity = 'poolId__totalLiquidity', + PoolIdTotalLiquiditySansBpt = 'poolId__totalLiquiditySansBPT', + PoolIdTotalProtocolFee = 'poolId__totalProtocolFee', + PoolIdTotalProtocolFeePaidInBpt = 'poolId__totalProtocolFeePaidInBPT', PoolIdTotalShares = 'poolId__totalShares', PoolIdTotalSwapFee = 'poolId__totalSwapFee', PoolIdTotalSwapVolume = 'poolId__totalSwapVolume', @@ -960,6 +1217,7 @@ export enum ManagementOperation_OrderBy { PoolTokenIdManagedBalance = 'poolTokenId__managedBalance', PoolTokenIdName = 'poolTokenId__name', PoolTokenIdOldPriceRate = 'poolTokenId__oldPriceRate', + PoolTokenIdPaidProtocolFees = 'poolTokenId__paidProtocolFees', PoolTokenIdPriceRate = 'poolTokenId__priceRate', PoolTokenIdSymbol = 'poolTokenId__symbol', PoolTokenIdWeight = 'poolTokenId__weight', @@ -984,9 +1242,11 @@ export type Pool = { address: Scalars['Bytes']; alpha?: Maybe; amp?: Maybe; + ampUpdates?: Maybe>; baseToken?: Maybe; beta?: Maybe; c?: Maybe; + circuitBreakers?: Maybe>; createTime: Scalars['Int']; dSq?: Maybe; delta?: Maybe; @@ -998,11 +1258,16 @@ export type Pool = { id: Scalars['ID']; isInRecoveryMode?: Maybe; isPaused?: Maybe; + joinExitEnabled?: Maybe; lambda?: Maybe; + lastJoinExitAmp?: Maybe; lastPostJoinExitInvariant?: Maybe; + latestAmpUpdate?: Maybe; lowerTarget?: Maybe; mainIndex?: Maybe; + managementAumFee?: Maybe; managementFee?: Maybe; + mustAllowlistLPs?: Maybe; name?: Maybe; oracleEnabled: Scalars['Boolean']; owner?: Maybe; @@ -1022,7 +1287,12 @@ export type Pool = { sqrtAlpha?: Maybe; sqrtBeta?: Maybe; strategyType: Scalars['Int']; + /** Indicates if a pool can be swapped against. Combines multiple sources, including offchain curation */ swapEnabled: Scalars['Boolean']; + /** External indication from an offchain permissioned actor */ + swapEnabledCurationSignal?: Maybe; + /** The native swapEnabled boolean. internal to the pool. Only applies to Gyro, LBPs and InvestmentPools */ + swapEnabledInternal?: Maybe; swapFee: Scalars['BigDecimal']; swaps?: Maybe>; swapsCount: Scalars['BigInt']; @@ -1033,7 +1303,11 @@ export type Pool = { tauBetaY?: Maybe; tokens?: Maybe>; tokensList: Array; + totalAumFeeCollectedInBPT?: Maybe; totalLiquidity: Scalars['BigDecimal']; + totalLiquiditySansBPT?: Maybe; + totalProtocolFee?: Maybe; + totalProtocolFeePaidInBPT?: Maybe; totalShares: Scalars['BigDecimal']; totalSwapFee: Scalars['BigDecimal']; totalSwapVolume: Scalars['BigDecimal']; @@ -1051,6 +1325,24 @@ export type Pool = { }; +export type PoolAmpUpdatesArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + + +export type PoolCircuitBreakersArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + + export type PoolHistoricalValuesArgs = { first?: InputMaybe; orderBy?: InputMaybe; @@ -1174,11 +1466,15 @@ export enum PoolContract_OrderBy { PoolId = 'pool__id', PoolIsInRecoveryMode = 'pool__isInRecoveryMode', PoolIsPaused = 'pool__isPaused', + PoolJoinExitEnabled = 'pool__joinExitEnabled', PoolLambda = 'pool__lambda', + PoolLastJoinExitAmp = 'pool__lastJoinExitAmp', PoolLastPostJoinExitInvariant = 'pool__lastPostJoinExitInvariant', PoolLowerTarget = 'pool__lowerTarget', PoolMainIndex = 'pool__mainIndex', + PoolManagementAumFee = 'pool__managementAumFee', PoolManagementFee = 'pool__managementFee', + PoolMustAllowlistLPs = 'pool__mustAllowlistLPs', PoolName = 'pool__name', PoolOracleEnabled = 'pool__oracleEnabled', PoolOwner = 'pool__owner', @@ -1195,6 +1491,8 @@ export enum PoolContract_OrderBy { PoolSqrtBeta = 'pool__sqrtBeta', PoolStrategyType = 'pool__strategyType', PoolSwapEnabled = 'pool__swapEnabled', + PoolSwapEnabledCurationSignal = 'pool__swapEnabledCurationSignal', + PoolSwapEnabledInternal = 'pool__swapEnabledInternal', PoolSwapFee = 'pool__swapFee', PoolSwapsCount = 'pool__swapsCount', PoolSymbol = 'pool__symbol', @@ -1202,7 +1500,11 @@ export enum PoolContract_OrderBy { PoolTauAlphaY = 'pool__tauAlphaY', PoolTauBetaX = 'pool__tauBetaX', PoolTauBetaY = 'pool__tauBetaY', + PoolTotalAumFeeCollectedInBpt = 'pool__totalAumFeeCollectedInBPT', PoolTotalLiquidity = 'pool__totalLiquidity', + PoolTotalLiquiditySansBpt = 'pool__totalLiquiditySansBPT', + PoolTotalProtocolFee = 'pool__totalProtocolFee', + PoolTotalProtocolFeePaidInBpt = 'pool__totalProtocolFeePaidInBPT', PoolTotalShares = 'pool__totalShares', PoolTotalSwapFee = 'pool__totalSwapFee', PoolTotalSwapVolume = 'pool__totalSwapVolume', @@ -1326,11 +1628,15 @@ export enum PoolHistoricalLiquidity_OrderBy { PoolIdId = 'poolId__id', PoolIdIsInRecoveryMode = 'poolId__isInRecoveryMode', PoolIdIsPaused = 'poolId__isPaused', + PoolIdJoinExitEnabled = 'poolId__joinExitEnabled', PoolIdLambda = 'poolId__lambda', + PoolIdLastJoinExitAmp = 'poolId__lastJoinExitAmp', PoolIdLastPostJoinExitInvariant = 'poolId__lastPostJoinExitInvariant', PoolIdLowerTarget = 'poolId__lowerTarget', PoolIdMainIndex = 'poolId__mainIndex', + PoolIdManagementAumFee = 'poolId__managementAumFee', PoolIdManagementFee = 'poolId__managementFee', + PoolIdMustAllowlistLPs = 'poolId__mustAllowlistLPs', PoolIdName = 'poolId__name', PoolIdOracleEnabled = 'poolId__oracleEnabled', PoolIdOwner = 'poolId__owner', @@ -1347,6 +1653,8 @@ export enum PoolHistoricalLiquidity_OrderBy { PoolIdSqrtBeta = 'poolId__sqrtBeta', PoolIdStrategyType = 'poolId__strategyType', PoolIdSwapEnabled = 'poolId__swapEnabled', + PoolIdSwapEnabledCurationSignal = 'poolId__swapEnabledCurationSignal', + PoolIdSwapEnabledInternal = 'poolId__swapEnabledInternal', PoolIdSwapFee = 'poolId__swapFee', PoolIdSwapsCount = 'poolId__swapsCount', PoolIdSymbol = 'poolId__symbol', @@ -1354,7 +1662,11 @@ export enum PoolHistoricalLiquidity_OrderBy { PoolIdTauAlphaY = 'poolId__tauAlphaY', PoolIdTauBetaX = 'poolId__tauBetaX', PoolIdTauBetaY = 'poolId__tauBetaY', + PoolIdTotalAumFeeCollectedInBpt = 'poolId__totalAumFeeCollectedInBPT', PoolIdTotalLiquidity = 'poolId__totalLiquidity', + PoolIdTotalLiquiditySansBpt = 'poolId__totalLiquiditySansBPT', + PoolIdTotalProtocolFee = 'poolId__totalProtocolFee', + PoolIdTotalProtocolFeePaidInBpt = 'poolId__totalProtocolFeePaidInBPT', PoolIdTotalShares = 'poolId__totalShares', PoolIdTotalSwapFee = 'poolId__totalSwapFee', PoolIdTotalSwapVolume = 'poolId__totalSwapVolume', @@ -1466,11 +1778,15 @@ export enum PoolShare_OrderBy { PoolIdId = 'poolId__id', PoolIdIsInRecoveryMode = 'poolId__isInRecoveryMode', PoolIdIsPaused = 'poolId__isPaused', + PoolIdJoinExitEnabled = 'poolId__joinExitEnabled', PoolIdLambda = 'poolId__lambda', + PoolIdLastJoinExitAmp = 'poolId__lastJoinExitAmp', PoolIdLastPostJoinExitInvariant = 'poolId__lastPostJoinExitInvariant', PoolIdLowerTarget = 'poolId__lowerTarget', PoolIdMainIndex = 'poolId__mainIndex', + PoolIdManagementAumFee = 'poolId__managementAumFee', PoolIdManagementFee = 'poolId__managementFee', + PoolIdMustAllowlistLPs = 'poolId__mustAllowlistLPs', PoolIdName = 'poolId__name', PoolIdOracleEnabled = 'poolId__oracleEnabled', PoolIdOwner = 'poolId__owner', @@ -1487,6 +1803,8 @@ export enum PoolShare_OrderBy { PoolIdSqrtBeta = 'poolId__sqrtBeta', PoolIdStrategyType = 'poolId__strategyType', PoolIdSwapEnabled = 'poolId__swapEnabled', + PoolIdSwapEnabledCurationSignal = 'poolId__swapEnabledCurationSignal', + PoolIdSwapEnabledInternal = 'poolId__swapEnabledInternal', PoolIdSwapFee = 'poolId__swapFee', PoolIdSwapsCount = 'poolId__swapsCount', PoolIdSymbol = 'poolId__symbol', @@ -1494,7 +1812,11 @@ export enum PoolShare_OrderBy { PoolIdTauAlphaY = 'poolId__tauAlphaY', PoolIdTauBetaX = 'poolId__tauBetaX', PoolIdTauBetaY = 'poolId__tauBetaY', + PoolIdTotalAumFeeCollectedInBpt = 'poolId__totalAumFeeCollectedInBPT', PoolIdTotalLiquidity = 'poolId__totalLiquidity', + PoolIdTotalLiquiditySansBpt = 'poolId__totalLiquiditySansBPT', + PoolIdTotalProtocolFee = 'poolId__totalProtocolFee', + PoolIdTotalProtocolFeePaidInBpt = 'poolId__totalProtocolFeePaidInBPT', PoolIdTotalShares = 'poolId__totalShares', PoolIdTotalSwapFee = 'poolId__totalSwapFee', PoolIdTotalSwapVolume = 'poolId__totalSwapVolume', @@ -1518,6 +1840,7 @@ export type PoolSnapshot = { id: Scalars['ID']; liquidity: Scalars['BigDecimal']; pool: Pool; + protocolFee?: Maybe; swapFees: Scalars['BigDecimal']; swapVolume: Scalars['BigDecimal']; swapsCount: Scalars['BigInt']; @@ -1581,6 +1904,14 @@ export type PoolSnapshot_Filter = { pool_not_starts_with_nocase?: InputMaybe; pool_starts_with?: InputMaybe; pool_starts_with_nocase?: InputMaybe; + protocolFee?: InputMaybe; + protocolFee_gt?: InputMaybe; + protocolFee_gte?: InputMaybe; + protocolFee_in?: InputMaybe>; + protocolFee_lt?: InputMaybe; + protocolFee_lte?: InputMaybe; + protocolFee_not?: InputMaybe; + protocolFee_not_in?: InputMaybe>; swapFees?: InputMaybe; swapFees_gt?: InputMaybe; swapFees_gte?: InputMaybe; @@ -1645,11 +1976,15 @@ export enum PoolSnapshot_OrderBy { PoolId = 'pool__id', PoolIsInRecoveryMode = 'pool__isInRecoveryMode', PoolIsPaused = 'pool__isPaused', + PoolJoinExitEnabled = 'pool__joinExitEnabled', PoolLambda = 'pool__lambda', + PoolLastJoinExitAmp = 'pool__lastJoinExitAmp', PoolLastPostJoinExitInvariant = 'pool__lastPostJoinExitInvariant', PoolLowerTarget = 'pool__lowerTarget', PoolMainIndex = 'pool__mainIndex', + PoolManagementAumFee = 'pool__managementAumFee', PoolManagementFee = 'pool__managementFee', + PoolMustAllowlistLPs = 'pool__mustAllowlistLPs', PoolName = 'pool__name', PoolOracleEnabled = 'pool__oracleEnabled', PoolOwner = 'pool__owner', @@ -1666,6 +2001,8 @@ export enum PoolSnapshot_OrderBy { PoolSqrtBeta = 'pool__sqrtBeta', PoolStrategyType = 'pool__strategyType', PoolSwapEnabled = 'pool__swapEnabled', + PoolSwapEnabledCurationSignal = 'pool__swapEnabledCurationSignal', + PoolSwapEnabledInternal = 'pool__swapEnabledInternal', PoolSwapFee = 'pool__swapFee', PoolSwapsCount = 'pool__swapsCount', PoolSymbol = 'pool__symbol', @@ -1673,7 +2010,11 @@ export enum PoolSnapshot_OrderBy { PoolTauAlphaY = 'pool__tauAlphaY', PoolTauBetaX = 'pool__tauBetaX', PoolTauBetaY = 'pool__tauBetaY', + PoolTotalAumFeeCollectedInBpt = 'pool__totalAumFeeCollectedInBPT', PoolTotalLiquidity = 'pool__totalLiquidity', + PoolTotalLiquiditySansBpt = 'pool__totalLiquiditySansBPT', + PoolTotalProtocolFee = 'pool__totalProtocolFee', + PoolTotalProtocolFeePaidInBpt = 'pool__totalProtocolFeePaidInBPT', PoolTotalShares = 'pool__totalShares', PoolTotalSwapFee = 'pool__totalSwapFee', PoolTotalSwapVolume = 'pool__totalSwapVolume', @@ -1686,6 +2027,7 @@ export enum PoolSnapshot_OrderBy { PoolW = 'pool__w', PoolWrappedIndex = 'pool__wrappedIndex', PoolZ = 'pool__z', + ProtocolFee = 'protocolFee', SwapFees = 'swapFees', SwapVolume = 'swapVolume', SwapsCount = 'swapsCount', @@ -1699,6 +2041,7 @@ export type PoolToken = { assetManager: Scalars['Bytes']; balance: Scalars['BigDecimal']; cashBalance: Scalars['BigDecimal']; + circuitBreaker?: Maybe; decimals: Scalars['Int']; id: Scalars['ID']; index?: Maybe; @@ -1707,6 +2050,7 @@ export type PoolToken = { managements?: Maybe>; name: Scalars['String']; oldPriceRate?: Maybe; + paidProtocolFees?: Maybe; poolId?: Maybe; priceRate: Scalars['BigDecimal']; symbol: Scalars['String']; @@ -1773,6 +2117,27 @@ export type PoolToken_Filter = { cashBalance_lte?: InputMaybe; cashBalance_not?: InputMaybe; cashBalance_not_in?: InputMaybe>; + circuitBreaker?: InputMaybe; + circuitBreaker_?: InputMaybe; + circuitBreaker_contains?: InputMaybe; + circuitBreaker_contains_nocase?: InputMaybe; + circuitBreaker_ends_with?: InputMaybe; + circuitBreaker_ends_with_nocase?: InputMaybe; + circuitBreaker_gt?: InputMaybe; + circuitBreaker_gte?: InputMaybe; + circuitBreaker_in?: InputMaybe>; + circuitBreaker_lt?: InputMaybe; + circuitBreaker_lte?: InputMaybe; + circuitBreaker_not?: InputMaybe; + circuitBreaker_not_contains?: InputMaybe; + circuitBreaker_not_contains_nocase?: InputMaybe; + circuitBreaker_not_ends_with?: InputMaybe; + circuitBreaker_not_ends_with_nocase?: InputMaybe; + circuitBreaker_not_in?: InputMaybe>; + circuitBreaker_not_starts_with?: InputMaybe; + circuitBreaker_not_starts_with_nocase?: InputMaybe; + circuitBreaker_starts_with?: InputMaybe; + circuitBreaker_starts_with_nocase?: InputMaybe; decimals?: InputMaybe; decimals_gt?: InputMaybe; decimals_gte?: InputMaybe; @@ -1839,6 +2204,14 @@ export type PoolToken_Filter = { oldPriceRate_not?: InputMaybe; oldPriceRate_not_in?: InputMaybe>; or?: InputMaybe>>; + paidProtocolFees?: InputMaybe; + paidProtocolFees_gt?: InputMaybe; + paidProtocolFees_gte?: InputMaybe; + paidProtocolFees_in?: InputMaybe>; + paidProtocolFees_lt?: InputMaybe; + paidProtocolFees_lte?: InputMaybe; + paidProtocolFees_not?: InputMaybe; + paidProtocolFees_not_in?: InputMaybe>; poolId?: InputMaybe; poolId_?: InputMaybe; poolId_contains?: InputMaybe; @@ -1924,6 +2297,11 @@ export enum PoolToken_OrderBy { AssetManager = 'assetManager', Balance = 'balance', CashBalance = 'cashBalance', + CircuitBreaker = 'circuitBreaker', + CircuitBreakerBptPrice = 'circuitBreaker__bptPrice', + CircuitBreakerId = 'circuitBreaker__id', + CircuitBreakerLowerBoundPercentage = 'circuitBreaker__lowerBoundPercentage', + CircuitBreakerUpperBoundPercentage = 'circuitBreaker__upperBoundPercentage', Decimals = 'decimals', Id = 'id', Index = 'index', @@ -1932,6 +2310,7 @@ export enum PoolToken_OrderBy { Managements = 'managements', Name = 'name', OldPriceRate = 'oldPriceRate', + PaidProtocolFees = 'paidProtocolFees', PoolId = 'poolId', PoolIdAddress = 'poolId__address', PoolIdAlpha = 'poolId__alpha', @@ -1949,11 +2328,15 @@ export enum PoolToken_OrderBy { PoolIdId = 'poolId__id', PoolIdIsInRecoveryMode = 'poolId__isInRecoveryMode', PoolIdIsPaused = 'poolId__isPaused', + PoolIdJoinExitEnabled = 'poolId__joinExitEnabled', PoolIdLambda = 'poolId__lambda', + PoolIdLastJoinExitAmp = 'poolId__lastJoinExitAmp', PoolIdLastPostJoinExitInvariant = 'poolId__lastPostJoinExitInvariant', PoolIdLowerTarget = 'poolId__lowerTarget', PoolIdMainIndex = 'poolId__mainIndex', + PoolIdManagementAumFee = 'poolId__managementAumFee', PoolIdManagementFee = 'poolId__managementFee', + PoolIdMustAllowlistLPs = 'poolId__mustAllowlistLPs', PoolIdName = 'poolId__name', PoolIdOracleEnabled = 'poolId__oracleEnabled', PoolIdOwner = 'poolId__owner', @@ -1970,6 +2353,8 @@ export enum PoolToken_OrderBy { PoolIdSqrtBeta = 'poolId__sqrtBeta', PoolIdStrategyType = 'poolId__strategyType', PoolIdSwapEnabled = 'poolId__swapEnabled', + PoolIdSwapEnabledCurationSignal = 'poolId__swapEnabledCurationSignal', + PoolIdSwapEnabledInternal = 'poolId__swapEnabledInternal', PoolIdSwapFee = 'poolId__swapFee', PoolIdSwapsCount = 'poolId__swapsCount', PoolIdSymbol = 'poolId__symbol', @@ -1977,7 +2362,11 @@ export enum PoolToken_OrderBy { PoolIdTauAlphaY = 'poolId__tauAlphaY', PoolIdTauBetaX = 'poolId__tauBetaX', PoolIdTauBetaY = 'poolId__tauBetaY', + PoolIdTotalAumFeeCollectedInBpt = 'poolId__totalAumFeeCollectedInBPT', PoolIdTotalLiquidity = 'poolId__totalLiquidity', + PoolIdTotalLiquiditySansBpt = 'poolId__totalLiquiditySansBPT', + PoolIdTotalProtocolFee = 'poolId__totalProtocolFee', + PoolIdTotalProtocolFeePaidInBpt = 'poolId__totalProtocolFeePaidInBPT', PoolIdTotalShares = 'poolId__totalShares', PoolIdTotalSwapFee = 'poolId__totalSwapFee', PoolIdTotalSwapVolume = 'poolId__totalSwapVolume', @@ -1995,6 +2384,7 @@ export enum PoolToken_OrderBy { Token = 'token', TokenAddress = 'token__address', TokenDecimals = 'token__decimals', + TokenFxOracleDecimals = 'token__fxOracleDecimals', TokenId = 'token__id', TokenLatestFxPrice = 'token__latestFXPrice', TokenLatestUsdPrice = 'token__latestUSDPrice', @@ -2031,6 +2421,7 @@ export type Pool_Filter = { alpha_not?: InputMaybe; alpha_not_in?: InputMaybe>; amp?: InputMaybe; + ampUpdates_?: InputMaybe; amp_gt?: InputMaybe; amp_gte?: InputMaybe; amp_in?: InputMaybe>; @@ -2065,6 +2456,7 @@ export type Pool_Filter = { c_lte?: InputMaybe; c_not?: InputMaybe; c_not_in?: InputMaybe>; + circuitBreakers_?: InputMaybe; createTime?: InputMaybe; createTime_gt?: InputMaybe; createTime_gte?: InputMaybe; @@ -2140,6 +2532,10 @@ export type Pool_Filter = { isPaused_in?: InputMaybe>; isPaused_not?: InputMaybe; isPaused_not_in?: InputMaybe>; + joinExitEnabled?: InputMaybe; + joinExitEnabled_in?: InputMaybe>; + joinExitEnabled_not?: InputMaybe; + joinExitEnabled_not_in?: InputMaybe>; lambda?: InputMaybe; lambda_gt?: InputMaybe; lambda_gte?: InputMaybe; @@ -2148,6 +2544,14 @@ export type Pool_Filter = { lambda_lte?: InputMaybe; lambda_not?: InputMaybe; lambda_not_in?: InputMaybe>; + lastJoinExitAmp?: InputMaybe; + lastJoinExitAmp_gt?: InputMaybe; + lastJoinExitAmp_gte?: InputMaybe; + lastJoinExitAmp_in?: InputMaybe>; + lastJoinExitAmp_lt?: InputMaybe; + lastJoinExitAmp_lte?: InputMaybe; + lastJoinExitAmp_not?: InputMaybe; + lastJoinExitAmp_not_in?: InputMaybe>; lastPostJoinExitInvariant?: InputMaybe; lastPostJoinExitInvariant_gt?: InputMaybe; lastPostJoinExitInvariant_gte?: InputMaybe; @@ -2156,6 +2560,27 @@ export type Pool_Filter = { lastPostJoinExitInvariant_lte?: InputMaybe; lastPostJoinExitInvariant_not?: InputMaybe; lastPostJoinExitInvariant_not_in?: InputMaybe>; + latestAmpUpdate?: InputMaybe; + latestAmpUpdate_?: InputMaybe; + latestAmpUpdate_contains?: InputMaybe; + latestAmpUpdate_contains_nocase?: InputMaybe; + latestAmpUpdate_ends_with?: InputMaybe; + latestAmpUpdate_ends_with_nocase?: InputMaybe; + latestAmpUpdate_gt?: InputMaybe; + latestAmpUpdate_gte?: InputMaybe; + latestAmpUpdate_in?: InputMaybe>; + latestAmpUpdate_lt?: InputMaybe; + latestAmpUpdate_lte?: InputMaybe; + latestAmpUpdate_not?: InputMaybe; + latestAmpUpdate_not_contains?: InputMaybe; + latestAmpUpdate_not_contains_nocase?: InputMaybe; + latestAmpUpdate_not_ends_with?: InputMaybe; + latestAmpUpdate_not_ends_with_nocase?: InputMaybe; + latestAmpUpdate_not_in?: InputMaybe>; + latestAmpUpdate_not_starts_with?: InputMaybe; + latestAmpUpdate_not_starts_with_nocase?: InputMaybe; + latestAmpUpdate_starts_with?: InputMaybe; + latestAmpUpdate_starts_with_nocase?: InputMaybe; lowerTarget?: InputMaybe; lowerTarget_gt?: InputMaybe; lowerTarget_gte?: InputMaybe; @@ -2172,6 +2597,14 @@ export type Pool_Filter = { mainIndex_lte?: InputMaybe; mainIndex_not?: InputMaybe; mainIndex_not_in?: InputMaybe>; + managementAumFee?: InputMaybe; + managementAumFee_gt?: InputMaybe; + managementAumFee_gte?: InputMaybe; + managementAumFee_in?: InputMaybe>; + managementAumFee_lt?: InputMaybe; + managementAumFee_lte?: InputMaybe; + managementAumFee_not?: InputMaybe; + managementAumFee_not_in?: InputMaybe>; managementFee?: InputMaybe; managementFee_gt?: InputMaybe; managementFee_gte?: InputMaybe; @@ -2180,6 +2613,10 @@ export type Pool_Filter = { managementFee_lte?: InputMaybe; managementFee_not?: InputMaybe; managementFee_not_in?: InputMaybe>; + mustAllowlistLPs?: InputMaybe; + mustAllowlistLPs_in?: InputMaybe>; + mustAllowlistLPs_not?: InputMaybe; + mustAllowlistLPs_not_in?: InputMaybe>; name?: InputMaybe; name_contains?: InputMaybe; name_contains_nocase?: InputMaybe; @@ -2350,6 +2787,14 @@ export type Pool_Filter = { strategyType_not?: InputMaybe; strategyType_not_in?: InputMaybe>; swapEnabled?: InputMaybe; + swapEnabledCurationSignal?: InputMaybe; + swapEnabledCurationSignal_in?: InputMaybe>; + swapEnabledCurationSignal_not?: InputMaybe; + swapEnabledCurationSignal_not_in?: InputMaybe>; + swapEnabledInternal?: InputMaybe; + swapEnabledInternal_in?: InputMaybe>; + swapEnabledInternal_not?: InputMaybe; + swapEnabledInternal_not_in?: InputMaybe>; swapEnabled_in?: InputMaybe>; swapEnabled_not?: InputMaybe; swapEnabled_not_in?: InputMaybe>; @@ -2429,7 +2874,23 @@ export type Pool_Filter = { tokensList_not_contains?: InputMaybe>; tokensList_not_contains_nocase?: InputMaybe>; tokens_?: InputMaybe; + totalAumFeeCollectedInBPT?: InputMaybe; + totalAumFeeCollectedInBPT_gt?: InputMaybe; + totalAumFeeCollectedInBPT_gte?: InputMaybe; + totalAumFeeCollectedInBPT_in?: InputMaybe>; + totalAumFeeCollectedInBPT_lt?: InputMaybe; + totalAumFeeCollectedInBPT_lte?: InputMaybe; + totalAumFeeCollectedInBPT_not?: InputMaybe; + totalAumFeeCollectedInBPT_not_in?: InputMaybe>; totalLiquidity?: InputMaybe; + totalLiquiditySansBPT?: InputMaybe; + totalLiquiditySansBPT_gt?: InputMaybe; + totalLiquiditySansBPT_gte?: InputMaybe; + totalLiquiditySansBPT_in?: InputMaybe>; + totalLiquiditySansBPT_lt?: InputMaybe; + totalLiquiditySansBPT_lte?: InputMaybe; + totalLiquiditySansBPT_not?: InputMaybe; + totalLiquiditySansBPT_not_in?: InputMaybe>; totalLiquidity_gt?: InputMaybe; totalLiquidity_gte?: InputMaybe; totalLiquidity_in?: InputMaybe>; @@ -2437,6 +2898,22 @@ export type Pool_Filter = { totalLiquidity_lte?: InputMaybe; totalLiquidity_not?: InputMaybe; totalLiquidity_not_in?: InputMaybe>; + totalProtocolFee?: InputMaybe; + totalProtocolFeePaidInBPT?: InputMaybe; + totalProtocolFeePaidInBPT_gt?: InputMaybe; + totalProtocolFeePaidInBPT_gte?: InputMaybe; + totalProtocolFeePaidInBPT_in?: InputMaybe>; + totalProtocolFeePaidInBPT_lt?: InputMaybe; + totalProtocolFeePaidInBPT_lte?: InputMaybe; + totalProtocolFeePaidInBPT_not?: InputMaybe; + totalProtocolFeePaidInBPT_not_in?: InputMaybe>; + totalProtocolFee_gt?: InputMaybe; + totalProtocolFee_gte?: InputMaybe; + totalProtocolFee_in?: InputMaybe>; + totalProtocolFee_lt?: InputMaybe; + totalProtocolFee_lte?: InputMaybe; + totalProtocolFee_not?: InputMaybe; + totalProtocolFee_not_in?: InputMaybe>; totalShares?: InputMaybe; totalShares_gt?: InputMaybe; totalShares_gte?: InputMaybe; @@ -2563,9 +3040,11 @@ export enum Pool_OrderBy { Address = 'address', Alpha = 'alpha', Amp = 'amp', + AmpUpdates = 'ampUpdates', BaseToken = 'baseToken', Beta = 'beta', C = 'c', + CircuitBreakers = 'circuitBreakers', CreateTime = 'createTime', DSq = 'dSq', Delta = 'delta', @@ -2577,11 +3056,22 @@ export enum Pool_OrderBy { Id = 'id', IsInRecoveryMode = 'isInRecoveryMode', IsPaused = 'isPaused', + JoinExitEnabled = 'joinExitEnabled', Lambda = 'lambda', + LastJoinExitAmp = 'lastJoinExitAmp', LastPostJoinExitInvariant = 'lastPostJoinExitInvariant', + LatestAmpUpdate = 'latestAmpUpdate', + LatestAmpUpdateEndAmp = 'latestAmpUpdate__endAmp', + LatestAmpUpdateEndTimestamp = 'latestAmpUpdate__endTimestamp', + LatestAmpUpdateId = 'latestAmpUpdate__id', + LatestAmpUpdateScheduledTimestamp = 'latestAmpUpdate__scheduledTimestamp', + LatestAmpUpdateStartAmp = 'latestAmpUpdate__startAmp', + LatestAmpUpdateStartTimestamp = 'latestAmpUpdate__startTimestamp', LowerTarget = 'lowerTarget', MainIndex = 'mainIndex', + ManagementAumFee = 'managementAumFee', ManagementFee = 'managementFee', + MustAllowlistLPs = 'mustAllowlistLPs', Name = 'name', OracleEnabled = 'oracleEnabled', Owner = 'owner', @@ -2604,6 +3094,8 @@ export enum Pool_OrderBy { SqrtBeta = 'sqrtBeta', StrategyType = 'strategyType', SwapEnabled = 'swapEnabled', + SwapEnabledCurationSignal = 'swapEnabledCurationSignal', + SwapEnabledInternal = 'swapEnabledInternal', SwapFee = 'swapFee', Swaps = 'swaps', SwapsCount = 'swapsCount', @@ -2614,7 +3106,11 @@ export enum Pool_OrderBy { TauBetaY = 'tauBetaY', Tokens = 'tokens', TokensList = 'tokensList', + TotalAumFeeCollectedInBpt = 'totalAumFeeCollectedInBPT', TotalLiquidity = 'totalLiquidity', + TotalLiquiditySansBpt = 'totalLiquiditySansBPT', + TotalProtocolFee = 'totalProtocolFee', + TotalProtocolFeePaidInBpt = 'totalProtocolFeePaidInBPT', TotalShares = 'totalShares', TotalSwapFee = 'totalSwapFee', TotalSwapVolume = 'totalSwapVolume', @@ -2627,7 +3123,9 @@ export enum Pool_OrderBy { VaultId = 'vaultID', VaultIdId = 'vaultID__id', VaultIdPoolCount = 'vaultID__poolCount', + VaultIdProtocolFeesCollector = 'vaultID__protocolFeesCollector', VaultIdTotalLiquidity = 'vaultID__totalLiquidity', + VaultIdTotalProtocolFee = 'vaultID__totalProtocolFee', VaultIdTotalSwapCount = 'vaultID__totalSwapCount', VaultIdTotalSwapFee = 'vaultID__totalSwapFee', VaultIdTotalSwapVolume = 'vaultID__totalSwapVolume', @@ -2771,11 +3269,15 @@ export enum PriceRateProvider_OrderBy { PoolIdId = 'poolId__id', PoolIdIsInRecoveryMode = 'poolId__isInRecoveryMode', PoolIdIsPaused = 'poolId__isPaused', + PoolIdJoinExitEnabled = 'poolId__joinExitEnabled', PoolIdLambda = 'poolId__lambda', + PoolIdLastJoinExitAmp = 'poolId__lastJoinExitAmp', PoolIdLastPostJoinExitInvariant = 'poolId__lastPostJoinExitInvariant', PoolIdLowerTarget = 'poolId__lowerTarget', PoolIdMainIndex = 'poolId__mainIndex', + PoolIdManagementAumFee = 'poolId__managementAumFee', PoolIdManagementFee = 'poolId__managementFee', + PoolIdMustAllowlistLPs = 'poolId__mustAllowlistLPs', PoolIdName = 'poolId__name', PoolIdOracleEnabled = 'poolId__oracleEnabled', PoolIdOwner = 'poolId__owner', @@ -2792,6 +3294,8 @@ export enum PriceRateProvider_OrderBy { PoolIdSqrtBeta = 'poolId__sqrtBeta', PoolIdStrategyType = 'poolId__strategyType', PoolIdSwapEnabled = 'poolId__swapEnabled', + PoolIdSwapEnabledCurationSignal = 'poolId__swapEnabledCurationSignal', + PoolIdSwapEnabledInternal = 'poolId__swapEnabledInternal', PoolIdSwapFee = 'poolId__swapFee', PoolIdSwapsCount = 'poolId__swapsCount', PoolIdSymbol = 'poolId__symbol', @@ -2799,7 +3303,11 @@ export enum PriceRateProvider_OrderBy { PoolIdTauAlphaY = 'poolId__tauAlphaY', PoolIdTauBetaX = 'poolId__tauBetaX', PoolIdTauBetaY = 'poolId__tauBetaY', + PoolIdTotalAumFeeCollectedInBpt = 'poolId__totalAumFeeCollectedInBPT', PoolIdTotalLiquidity = 'poolId__totalLiquidity', + PoolIdTotalLiquiditySansBpt = 'poolId__totalLiquiditySansBPT', + PoolIdTotalProtocolFee = 'poolId__totalProtocolFee', + PoolIdTotalProtocolFeePaidInBpt = 'poolId__totalProtocolFeePaidInBPT', PoolIdTotalShares = 'poolId__totalShares', PoolIdTotalSwapFee = 'poolId__totalSwapFee', PoolIdTotalSwapVolume = 'poolId__totalSwapVolume', @@ -2825,6 +3333,7 @@ export enum PriceRateProvider_OrderBy { TokenManagedBalance = 'token__managedBalance', TokenName = 'token__name', TokenOldPriceRate = 'token__oldPriceRate', + TokenPaidProtocolFees = 'token__paidProtocolFees', TokenPriceRate = 'token__priceRate', TokenSymbol = 'token__symbol', TokenWeight = 'token__weight' @@ -2886,6 +3395,8 @@ export type Query = { balancerSnapshot?: Maybe; balancerSnapshots: Array; balancers: Array; + circuitBreaker?: Maybe; + circuitBreakers: Array; gradualWeightUpdate?: Maybe; gradualWeightUpdates: Array; joinExit?: Maybe; @@ -2990,6 +3501,24 @@ export type QueryBalancersArgs = { }; +export type QueryCircuitBreakerArgs = { + block?: InputMaybe; + id: Scalars['ID']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryCircuitBreakersArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + export type QueryGradualWeightUpdateArgs = { block?: InputMaybe; id: Scalars['ID']; @@ -3377,6 +3906,8 @@ export type Subscription = { balancerSnapshot?: Maybe; balancerSnapshots: Array; balancers: Array; + circuitBreaker?: Maybe; + circuitBreakers: Array; gradualWeightUpdate?: Maybe; gradualWeightUpdates: Array; joinExit?: Maybe; @@ -3481,6 +4012,24 @@ export type SubscriptionBalancersArgs = { }; +export type SubscriptionCircuitBreakerArgs = { + block?: InputMaybe; + id: Scalars['ID']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionCircuitBreakersArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + export type SubscriptionGradualWeightUpdateArgs = { block?: InputMaybe; id: Scalars['ID']; @@ -3983,11 +4532,15 @@ export enum SwapFeeUpdate_OrderBy { PoolId = 'pool__id', PoolIsInRecoveryMode = 'pool__isInRecoveryMode', PoolIsPaused = 'pool__isPaused', + PoolJoinExitEnabled = 'pool__joinExitEnabled', PoolLambda = 'pool__lambda', + PoolLastJoinExitAmp = 'pool__lastJoinExitAmp', PoolLastPostJoinExitInvariant = 'pool__lastPostJoinExitInvariant', PoolLowerTarget = 'pool__lowerTarget', PoolMainIndex = 'pool__mainIndex', + PoolManagementAumFee = 'pool__managementAumFee', PoolManagementFee = 'pool__managementFee', + PoolMustAllowlistLPs = 'pool__mustAllowlistLPs', PoolName = 'pool__name', PoolOracleEnabled = 'pool__oracleEnabled', PoolOwner = 'pool__owner', @@ -4004,6 +4557,8 @@ export enum SwapFeeUpdate_OrderBy { PoolSqrtBeta = 'pool__sqrtBeta', PoolStrategyType = 'pool__strategyType', PoolSwapEnabled = 'pool__swapEnabled', + PoolSwapEnabledCurationSignal = 'pool__swapEnabledCurationSignal', + PoolSwapEnabledInternal = 'pool__swapEnabledInternal', PoolSwapFee = 'pool__swapFee', PoolSwapsCount = 'pool__swapsCount', PoolSymbol = 'pool__symbol', @@ -4011,7 +4566,11 @@ export enum SwapFeeUpdate_OrderBy { PoolTauAlphaY = 'pool__tauAlphaY', PoolTauBetaX = 'pool__tauBetaX', PoolTauBetaY = 'pool__tauBetaY', + PoolTotalAumFeeCollectedInBpt = 'pool__totalAumFeeCollectedInBPT', PoolTotalLiquidity = 'pool__totalLiquidity', + PoolTotalLiquiditySansBpt = 'pool__totalLiquiditySansBPT', + PoolTotalProtocolFee = 'pool__totalProtocolFee', + PoolTotalProtocolFeePaidInBpt = 'pool__totalProtocolFeePaidInBPT', PoolTotalShares = 'pool__totalShares', PoolTotalSwapFee = 'pool__totalSwapFee', PoolTotalSwapVolume = 'pool__totalSwapVolume', @@ -4218,11 +4777,15 @@ export enum Swap_OrderBy { PoolIdId = 'poolId__id', PoolIdIsInRecoveryMode = 'poolId__isInRecoveryMode', PoolIdIsPaused = 'poolId__isPaused', + PoolIdJoinExitEnabled = 'poolId__joinExitEnabled', PoolIdLambda = 'poolId__lambda', + PoolIdLastJoinExitAmp = 'poolId__lastJoinExitAmp', PoolIdLastPostJoinExitInvariant = 'poolId__lastPostJoinExitInvariant', PoolIdLowerTarget = 'poolId__lowerTarget', PoolIdMainIndex = 'poolId__mainIndex', + PoolIdManagementAumFee = 'poolId__managementAumFee', PoolIdManagementFee = 'poolId__managementFee', + PoolIdMustAllowlistLPs = 'poolId__mustAllowlistLPs', PoolIdName = 'poolId__name', PoolIdOracleEnabled = 'poolId__oracleEnabled', PoolIdOwner = 'poolId__owner', @@ -4239,6 +4802,8 @@ export enum Swap_OrderBy { PoolIdSqrtBeta = 'poolId__sqrtBeta', PoolIdStrategyType = 'poolId__strategyType', PoolIdSwapEnabled = 'poolId__swapEnabled', + PoolIdSwapEnabledCurationSignal = 'poolId__swapEnabledCurationSignal', + PoolIdSwapEnabledInternal = 'poolId__swapEnabledInternal', PoolIdSwapFee = 'poolId__swapFee', PoolIdSwapsCount = 'poolId__swapsCount', PoolIdSymbol = 'poolId__symbol', @@ -4246,7 +4811,11 @@ export enum Swap_OrderBy { PoolIdTauAlphaY = 'poolId__tauAlphaY', PoolIdTauBetaX = 'poolId__tauBetaX', PoolIdTauBetaY = 'poolId__tauBetaY', + PoolIdTotalAumFeeCollectedInBpt = 'poolId__totalAumFeeCollectedInBPT', PoolIdTotalLiquidity = 'poolId__totalLiquidity', + PoolIdTotalLiquiditySansBpt = 'poolId__totalLiquiditySansBPT', + PoolIdTotalProtocolFee = 'poolId__totalProtocolFee', + PoolIdTotalProtocolFeePaidInBpt = 'poolId__totalProtocolFeePaidInBPT', PoolIdTotalShares = 'poolId__totalShares', PoolIdTotalSwapFee = 'poolId__totalSwapFee', PoolIdTotalSwapVolume = 'poolId__totalSwapVolume', @@ -4276,6 +4845,7 @@ export type Token = { __typename?: 'Token'; address: Scalars['String']; decimals: Scalars['Int']; + fxOracleDecimals?: Maybe; id: Scalars['ID']; latestFXPrice?: Maybe; latestPrice?: Maybe; @@ -4413,11 +4983,15 @@ export enum TokenPrice_OrderBy { PoolIdId = 'poolId__id', PoolIdIsInRecoveryMode = 'poolId__isInRecoveryMode', PoolIdIsPaused = 'poolId__isPaused', + PoolIdJoinExitEnabled = 'poolId__joinExitEnabled', PoolIdLambda = 'poolId__lambda', + PoolIdLastJoinExitAmp = 'poolId__lastJoinExitAmp', PoolIdLastPostJoinExitInvariant = 'poolId__lastPostJoinExitInvariant', PoolIdLowerTarget = 'poolId__lowerTarget', PoolIdMainIndex = 'poolId__mainIndex', + PoolIdManagementAumFee = 'poolId__managementAumFee', PoolIdManagementFee = 'poolId__managementFee', + PoolIdMustAllowlistLPs = 'poolId__mustAllowlistLPs', PoolIdName = 'poolId__name', PoolIdOracleEnabled = 'poolId__oracleEnabled', PoolIdOwner = 'poolId__owner', @@ -4434,6 +5008,8 @@ export enum TokenPrice_OrderBy { PoolIdSqrtBeta = 'poolId__sqrtBeta', PoolIdStrategyType = 'poolId__strategyType', PoolIdSwapEnabled = 'poolId__swapEnabled', + PoolIdSwapEnabledCurationSignal = 'poolId__swapEnabledCurationSignal', + PoolIdSwapEnabledInternal = 'poolId__swapEnabledInternal', PoolIdSwapFee = 'poolId__swapFee', PoolIdSwapsCount = 'poolId__swapsCount', PoolIdSymbol = 'poolId__symbol', @@ -4441,7 +5017,11 @@ export enum TokenPrice_OrderBy { PoolIdTauAlphaY = 'poolId__tauAlphaY', PoolIdTauBetaX = 'poolId__tauBetaX', PoolIdTauBetaY = 'poolId__tauBetaY', + PoolIdTotalAumFeeCollectedInBpt = 'poolId__totalAumFeeCollectedInBPT', PoolIdTotalLiquidity = 'poolId__totalLiquidity', + PoolIdTotalLiquiditySansBpt = 'poolId__totalLiquiditySansBPT', + PoolIdTotalProtocolFee = 'poolId__totalProtocolFee', + PoolIdTotalProtocolFeePaidInBpt = 'poolId__totalProtocolFeePaidInBPT', PoolIdTotalShares = 'poolId__totalShares', PoolIdTotalSwapFee = 'poolId__totalSwapFee', PoolIdTotalSwapVolume = 'poolId__totalSwapVolume', @@ -4561,6 +5141,7 @@ export enum TokenSnapshot_OrderBy { Token = 'token', TokenAddress = 'token__address', TokenDecimals = 'token__decimals', + TokenFxOracleDecimals = 'token__fxOracleDecimals', TokenId = 'token__id', TokenLatestFxPrice = 'token__latestFXPrice', TokenLatestUsdPrice = 'token__latestUSDPrice', @@ -4611,6 +5192,14 @@ export type Token_Filter = { decimals_lte?: InputMaybe; decimals_not?: InputMaybe; decimals_not_in?: InputMaybe>; + fxOracleDecimals?: InputMaybe; + fxOracleDecimals_gt?: InputMaybe; + fxOracleDecimals_gte?: InputMaybe; + fxOracleDecimals_in?: InputMaybe>; + fxOracleDecimals_lt?: InputMaybe; + fxOracleDecimals_lte?: InputMaybe; + fxOracleDecimals_not?: InputMaybe; + fxOracleDecimals_not_in?: InputMaybe>; id?: InputMaybe; id_gt?: InputMaybe; id_gte?: InputMaybe; @@ -4771,6 +5360,7 @@ export type Token_Filter = { export enum Token_OrderBy { Address = 'address', Decimals = 'decimals', + FxOracleDecimals = 'fxOracleDecimals', Id = 'id', LatestFxPrice = 'latestFXPrice', LatestPrice = 'latestPrice', @@ -4799,11 +5389,15 @@ export enum Token_OrderBy { PoolId = 'pool__id', PoolIsInRecoveryMode = 'pool__isInRecoveryMode', PoolIsPaused = 'pool__isPaused', + PoolJoinExitEnabled = 'pool__joinExitEnabled', PoolLambda = 'pool__lambda', + PoolLastJoinExitAmp = 'pool__lastJoinExitAmp', PoolLastPostJoinExitInvariant = 'pool__lastPostJoinExitInvariant', PoolLowerTarget = 'pool__lowerTarget', PoolMainIndex = 'pool__mainIndex', + PoolManagementAumFee = 'pool__managementAumFee', PoolManagementFee = 'pool__managementFee', + PoolMustAllowlistLPs = 'pool__mustAllowlistLPs', PoolName = 'pool__name', PoolOracleEnabled = 'pool__oracleEnabled', PoolOwner = 'pool__owner', @@ -4820,6 +5414,8 @@ export enum Token_OrderBy { PoolSqrtBeta = 'pool__sqrtBeta', PoolStrategyType = 'pool__strategyType', PoolSwapEnabled = 'pool__swapEnabled', + PoolSwapEnabledCurationSignal = 'pool__swapEnabledCurationSignal', + PoolSwapEnabledInternal = 'pool__swapEnabledInternal', PoolSwapFee = 'pool__swapFee', PoolSwapsCount = 'pool__swapsCount', PoolSymbol = 'pool__symbol', @@ -4827,7 +5423,11 @@ export enum Token_OrderBy { PoolTauAlphaY = 'pool__tauAlphaY', PoolTauBetaX = 'pool__tauBetaX', PoolTauBetaY = 'pool__tauBetaY', + PoolTotalAumFeeCollectedInBpt = 'pool__totalAumFeeCollectedInBPT', PoolTotalLiquidity = 'pool__totalLiquidity', + PoolTotalLiquiditySansBpt = 'pool__totalLiquiditySansBPT', + PoolTotalProtocolFee = 'pool__totalProtocolFee', + PoolTotalProtocolFeePaidInBpt = 'pool__totalProtocolFeePaidInBPT', PoolTotalShares = 'pool__totalShares', PoolTotalSwapFee = 'pool__totalSwapFee', PoolTotalSwapVolume = 'pool__totalSwapVolume', @@ -5016,6 +5616,7 @@ export enum TradePair_OrderBy { Token0 = 'token0', Token0Address = 'token0__address', Token0Decimals = 'token0__decimals', + Token0FxOracleDecimals = 'token0__fxOracleDecimals', Token0Id = 'token0__id', Token0LatestFxPrice = 'token0__latestFXPrice', Token0LatestUsdPrice = 'token0__latestUSDPrice', @@ -5030,6 +5631,7 @@ export enum TradePair_OrderBy { Token1 = 'token1', Token1Address = 'token1__address', Token1Decimals = 'token1__decimals', + Token1FxOracleDecimals = 'token1__fxOracleDecimals', Token1Id = 'token1__id', Token1LatestFxPrice = 'token1__latestFXPrice', Token1LatestUsdPrice = 'token1__latestUSDPrice', @@ -5085,6 +5687,7 @@ export type UserInternalBalance = { balance: Scalars['BigDecimal']; id: Scalars['ID']; token: Scalars['Bytes']; + tokenInfo?: Maybe; userAddress?: Maybe; }; @@ -5110,6 +5713,27 @@ export type UserInternalBalance_Filter = { id_not_in?: InputMaybe>; or?: InputMaybe>>; token?: InputMaybe; + tokenInfo?: InputMaybe; + tokenInfo_?: InputMaybe; + tokenInfo_contains?: InputMaybe; + tokenInfo_contains_nocase?: InputMaybe; + tokenInfo_ends_with?: InputMaybe; + tokenInfo_ends_with_nocase?: InputMaybe; + tokenInfo_gt?: InputMaybe; + tokenInfo_gte?: InputMaybe; + tokenInfo_in?: InputMaybe>; + tokenInfo_lt?: InputMaybe; + tokenInfo_lte?: InputMaybe; + tokenInfo_not?: InputMaybe; + tokenInfo_not_contains?: InputMaybe; + tokenInfo_not_contains_nocase?: InputMaybe; + tokenInfo_not_ends_with?: InputMaybe; + tokenInfo_not_ends_with_nocase?: InputMaybe; + tokenInfo_not_in?: InputMaybe>; + tokenInfo_not_starts_with?: InputMaybe; + tokenInfo_not_starts_with_nocase?: InputMaybe; + tokenInfo_starts_with?: InputMaybe; + tokenInfo_starts_with_nocase?: InputMaybe; token_contains?: InputMaybe; token_gt?: InputMaybe; token_gte?: InputMaybe; @@ -5146,6 +5770,21 @@ export enum UserInternalBalance_OrderBy { Balance = 'balance', Id = 'id', Token = 'token', + TokenInfo = 'tokenInfo', + TokenInfoAddress = 'tokenInfo__address', + TokenInfoDecimals = 'tokenInfo__decimals', + TokenInfoFxOracleDecimals = 'tokenInfo__fxOracleDecimals', + TokenInfoId = 'tokenInfo__id', + TokenInfoLatestFxPrice = 'tokenInfo__latestFXPrice', + TokenInfoLatestUsdPrice = 'tokenInfo__latestUSDPrice', + TokenInfoLatestUsdPriceTimestamp = 'tokenInfo__latestUSDPriceTimestamp', + TokenInfoName = 'tokenInfo__name', + TokenInfoSymbol = 'tokenInfo__symbol', + TokenInfoTotalBalanceNotional = 'tokenInfo__totalBalanceNotional', + TokenInfoTotalBalanceUsd = 'tokenInfo__totalBalanceUSD', + TokenInfoTotalSwapCount = 'tokenInfo__totalSwapCount', + TokenInfoTotalVolumeNotional = 'tokenInfo__totalVolumeNotional', + TokenInfoTotalVolumeUsd = 'tokenInfo__totalVolumeUSD', UserAddress = 'userAddress', UserAddressId = 'userAddress__id' }