@berachain/graphql 0.5.2 → 0.5.3-beta.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/beep/beep.codegen.d.ts +1014 -670
- package/dist/beep/beep.codegen.d.ts.map +1 -0
- package/dist/bend/whisk.codegen.d.ts +417 -491
- package/dist/bend/whisk.codegen.d.ts.map +1 -0
- package/dist/bend/whisk.codegen.mjs +6 -0
- package/dist/dex/api.codegen.d.ts +334 -356
- package/dist/dex/api.codegen.d.ts.map +1 -0
- package/dist/dex/api.codegen.mjs +3 -0
- package/dist/governance/governance.codegen.d.ts +70 -72
- package/dist/governance/governance.codegen.d.ts.map +1 -0
- package/dist/pol/api.codegen.d.ts +258 -282
- package/dist/pol/api.codegen.d.ts.map +1 -0
- package/dist/pol/api.codegen.mjs +3 -2
- package/dist/pol/subgraph.codegen.d.ts +233 -258
- package/dist/pol/subgraph.codegen.d.ts.map +1 -0
- package/dist/pol/subgraph.codegen.mjs +1 -21
- package/package.json +4 -3
|
@@ -1,28 +1,26 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
type
|
|
4
|
-
type InputMaybe<T> = Maybe<T>;
|
|
5
|
-
type Exact<T extends {
|
|
1
|
+
export type Maybe<T> = T | null;
|
|
2
|
+
export type InputMaybe<T> = Maybe<T>;
|
|
3
|
+
export type Exact<T extends {
|
|
6
4
|
[key: string]: unknown;
|
|
7
5
|
}> = {
|
|
8
6
|
[K in keyof T]: T[K];
|
|
9
7
|
};
|
|
10
|
-
type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
|
|
8
|
+
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
|
|
11
9
|
[SubKey in K]?: Maybe<T[SubKey]>;
|
|
12
10
|
};
|
|
13
|
-
type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
|
|
11
|
+
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
|
|
14
12
|
[SubKey in K]: Maybe<T[SubKey]>;
|
|
15
13
|
};
|
|
16
|
-
type MakeEmpty<T extends {
|
|
14
|
+
export type MakeEmpty<T extends {
|
|
17
15
|
[key: string]: unknown;
|
|
18
16
|
}, K extends keyof T> = {
|
|
19
17
|
[_ in K]?: never;
|
|
20
18
|
};
|
|
21
|
-
type Incremental<T> = T | {
|
|
19
|
+
export type Incremental<T> = T | {
|
|
22
20
|
[P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
|
|
23
21
|
};
|
|
24
22
|
/** All built-in and custom scalars, mapped to their actual values */
|
|
25
|
-
type Scalars = {
|
|
23
|
+
export type Scalars = {
|
|
26
24
|
ID: {
|
|
27
25
|
input: string;
|
|
28
26
|
output: string;
|
|
@@ -72,7 +70,7 @@ type Scalars = {
|
|
|
72
70
|
output: any;
|
|
73
71
|
};
|
|
74
72
|
};
|
|
75
|
-
type BendVaultDynamicData = {
|
|
73
|
+
export type BendVaultDynamicData = {
|
|
76
74
|
__typename?: 'BendVaultDynamicData';
|
|
77
75
|
nativeApy: Scalars['Float']['output'];
|
|
78
76
|
performanceFee: Scalars['Float']['output'];
|
|
@@ -85,42 +83,42 @@ type BendVaultDynamicData = {
|
|
|
85
83
|
totalApy: Scalars['Float']['output'];
|
|
86
84
|
vaultAddress: Scalars['Bytes']['output'];
|
|
87
85
|
};
|
|
88
|
-
type BendVaultResponse = {
|
|
86
|
+
export type BendVaultResponse = {
|
|
89
87
|
__typename?: 'BendVaultResponse';
|
|
90
88
|
dynamicData?: Maybe<BendVaultDynamicData>;
|
|
91
89
|
loanTokenAddress: Scalars['Bytes']['output'];
|
|
92
90
|
vaultAddress: Scalars['Bytes']['output'];
|
|
93
91
|
};
|
|
94
|
-
type GqlBalancePoolAprItem = {
|
|
92
|
+
export type GqlBalancePoolAprItem = {
|
|
95
93
|
__typename?: 'GqlBalancePoolAprItem';
|
|
96
94
|
apr: GqlPoolAprValue;
|
|
97
95
|
id: Scalars['ID']['output'];
|
|
98
96
|
subItems?: Maybe<Array<GqlBalancePoolAprSubItem>>;
|
|
99
97
|
title: Scalars['String']['output'];
|
|
100
98
|
};
|
|
101
|
-
type GqlBalancePoolAprSubItem = {
|
|
99
|
+
export type GqlBalancePoolAprSubItem = {
|
|
102
100
|
__typename?: 'GqlBalancePoolAprSubItem';
|
|
103
101
|
apr: GqlPoolAprValue;
|
|
104
102
|
id: Scalars['ID']['output'];
|
|
105
103
|
title: Scalars['String']['output'];
|
|
106
104
|
};
|
|
107
|
-
declare enum GqlChain {
|
|
105
|
+
export declare enum GqlChain {
|
|
108
106
|
Bepolia = "BEPOLIA",
|
|
109
107
|
Berachain = "BERACHAIN"
|
|
110
108
|
}
|
|
111
|
-
type GqlDefaultRewardAllocation = {
|
|
109
|
+
export type GqlDefaultRewardAllocation = {
|
|
112
110
|
__typename?: 'GqlDefaultRewardAllocation';
|
|
113
111
|
startBlock: Scalars['Int']['output'];
|
|
114
112
|
weights: Array<GqlDefaultRewardAllocationWeight>;
|
|
115
113
|
};
|
|
116
|
-
type GqlDefaultRewardAllocationWeight = {
|
|
114
|
+
export type GqlDefaultRewardAllocationWeight = {
|
|
117
115
|
__typename?: 'GqlDefaultRewardAllocationWeight';
|
|
118
116
|
chain: GqlChain;
|
|
119
117
|
percentageNumerator: Scalars['Int']['output'];
|
|
120
118
|
receiver: Scalars['String']['output'];
|
|
121
119
|
receiverVault?: Maybe<GqlRewardVault>;
|
|
122
120
|
};
|
|
123
|
-
type GqlGlobalInfo = {
|
|
121
|
+
export type GqlGlobalInfo = {
|
|
124
122
|
__typename?: 'GqlGlobalInfo';
|
|
125
123
|
/** @deprecated Use annualizedPoLEmissions instead */
|
|
126
124
|
annualizedBGTEmission: Scalars['String']['output'];
|
|
@@ -151,7 +149,7 @@ type GqlGlobalInfo = {
|
|
|
151
149
|
totalWhitelistedRewardVaults: Scalars['Int']['output'];
|
|
152
150
|
};
|
|
153
151
|
/** Configuration options for SOR V2 */
|
|
154
|
-
type GqlGraphTraversalConfigInput = {
|
|
152
|
+
export type GqlGraphTraversalConfigInput = {
|
|
155
153
|
/**
|
|
156
154
|
* Max number of paths to return (can be less)
|
|
157
155
|
*
|
|
@@ -178,20 +176,20 @@ type GqlGraphTraversalConfigInput = {
|
|
|
178
176
|
maxNonBoostedPathDepth?: InputMaybe<Scalars['Int']['input']>;
|
|
179
177
|
poolIdsToInclude?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
|
|
180
178
|
};
|
|
181
|
-
type GqlHistoricalTokenPrice = {
|
|
179
|
+
export type GqlHistoricalTokenPrice = {
|
|
182
180
|
__typename?: 'GqlHistoricalTokenPrice';
|
|
183
181
|
address: Scalars['Bytes']['output'];
|
|
184
182
|
chain: GqlChain;
|
|
185
183
|
prices: Array<GqlHistoricalTokenPriceEntry>;
|
|
186
184
|
};
|
|
187
|
-
type GqlHistoricalTokenPriceEntry = {
|
|
185
|
+
export type GqlHistoricalTokenPriceEntry = {
|
|
188
186
|
__typename?: 'GqlHistoricalTokenPriceEntry';
|
|
189
187
|
price: Scalars['Float']['output'];
|
|
190
188
|
timestamp: Scalars['String']['output'];
|
|
191
189
|
updatedAt: Scalars['Int']['output'];
|
|
192
190
|
updatedBy?: Maybe<Scalars['String']['output']>;
|
|
193
191
|
};
|
|
194
|
-
type GqlIncentive = {
|
|
192
|
+
export type GqlIncentive = {
|
|
195
193
|
incentiveRate: Scalars['String']['output'];
|
|
196
194
|
incentiveRateUsd: Scalars['String']['output'];
|
|
197
195
|
remainingAmount: Scalars['String']['output'];
|
|
@@ -199,13 +197,13 @@ type GqlIncentive = {
|
|
|
199
197
|
token: GqlToken;
|
|
200
198
|
tokenAddress: Scalars['Bytes']['output'];
|
|
201
199
|
};
|
|
202
|
-
type GqlLatestSyncedBlocks = {
|
|
200
|
+
export type GqlLatestSyncedBlocks = {
|
|
203
201
|
__typename?: 'GqlLatestSyncedBlocks';
|
|
204
202
|
poolSyncBlock: Scalars['BigInt']['output'];
|
|
205
203
|
userWalletSyncBlock: Scalars['BigInt']['output'];
|
|
206
204
|
};
|
|
207
205
|
/** All info on the nested pool if the token is a BPT. It will only support 1 level of nesting. */
|
|
208
|
-
type GqlNestedPool = {
|
|
206
|
+
export type GqlNestedPool = {
|
|
209
207
|
__typename?: 'GqlNestedPool';
|
|
210
208
|
/** Address of the pool. */
|
|
211
209
|
address: Scalars['Bytes']['output'];
|
|
@@ -242,14 +240,44 @@ type GqlNestedPool = {
|
|
|
242
240
|
/** Version of the pool. */
|
|
243
241
|
version: Scalars['Int']['output'];
|
|
244
242
|
};
|
|
245
|
-
type GqlPagination = {
|
|
243
|
+
export type GqlPagination = {
|
|
246
244
|
__typename?: 'GqlPagination';
|
|
247
245
|
currentPage: Scalars['Int']['output'];
|
|
248
246
|
pageSize: Scalars['Int']['output'];
|
|
249
247
|
totalCount: Scalars['Int']['output'];
|
|
250
248
|
totalPages: Scalars['Int']['output'];
|
|
251
249
|
};
|
|
252
|
-
|
|
250
|
+
/** Represents an event that occurs when liquidity is added or removed from a pool. */
|
|
251
|
+
export type GqlPoolAddRemoveEventV3 = GqlPoolEvent & {
|
|
252
|
+
__typename?: 'GqlPoolAddRemoveEventV3';
|
|
253
|
+
/** The block number of the event. */
|
|
254
|
+
blockNumber: Scalars['Int']['output'];
|
|
255
|
+
/** The block timestamp of the event. */
|
|
256
|
+
blockTimestamp: Scalars['Int']['output'];
|
|
257
|
+
/** The chain on which the event occurred. */
|
|
258
|
+
chain: GqlChain;
|
|
259
|
+
/** The unique identifier of the event. */
|
|
260
|
+
id: Scalars['ID']['output'];
|
|
261
|
+
/** The log index of the event. */
|
|
262
|
+
logIndex: Scalars['Int']['output'];
|
|
263
|
+
/** The pool ID associated with the event. */
|
|
264
|
+
poolId: Scalars['String']['output'];
|
|
265
|
+
/** The sender of the event. */
|
|
266
|
+
sender: Scalars['String']['output'];
|
|
267
|
+
/** The timestamp of the event. */
|
|
268
|
+
timestamp: Scalars['Int']['output'];
|
|
269
|
+
/** The tokens involved in the event. Ordered by poolToken index. */
|
|
270
|
+
tokens: Array<GqlPoolEventAmount>;
|
|
271
|
+
/** The transaction hash of the event. */
|
|
272
|
+
tx: Scalars['String']['output'];
|
|
273
|
+
/** The type of the event. */
|
|
274
|
+
type: GqlPoolEventType;
|
|
275
|
+
/** The user address associated with the event. */
|
|
276
|
+
userAddress: Scalars['Bytes']['output'];
|
|
277
|
+
/** The value of the event in USD. */
|
|
278
|
+
valueUSD: Scalars['Float']['output'];
|
|
279
|
+
};
|
|
280
|
+
export type GqlPoolAggregator = {
|
|
253
281
|
__typename?: 'GqlPoolAggregator';
|
|
254
282
|
/** The contract address of the pool. */
|
|
255
283
|
address: Scalars['Bytes']['output'];
|
|
@@ -320,7 +348,7 @@ type GqlPoolAggregator = {
|
|
|
320
348
|
/** Data specific to gyro pools */
|
|
321
349
|
z?: Maybe<Scalars['String']['output']>;
|
|
322
350
|
};
|
|
323
|
-
type GqlPoolApr = {
|
|
351
|
+
export type GqlPoolApr = {
|
|
324
352
|
__typename?: 'GqlPoolApr';
|
|
325
353
|
apr: GqlPoolAprValue;
|
|
326
354
|
hasRewardApr: Scalars['Boolean']['output'];
|
|
@@ -330,7 +358,7 @@ type GqlPoolApr = {
|
|
|
330
358
|
thirdPartyApr: GqlPoolAprValue;
|
|
331
359
|
};
|
|
332
360
|
/** All APRs for a pool */
|
|
333
|
-
type GqlPoolAprItem = {
|
|
361
|
+
export type GqlPoolAprItem = {
|
|
334
362
|
__typename?: 'GqlPoolAprItem';
|
|
335
363
|
/** The APR value in % -> 0.2 = 0.2% */
|
|
336
364
|
apr: Scalars['Float']['output'];
|
|
@@ -349,7 +377,7 @@ type GqlPoolAprItem = {
|
|
|
349
377
|
type: GqlPoolAprItemType;
|
|
350
378
|
};
|
|
351
379
|
/** Enum representing the different types of the APR in a pool. */
|
|
352
|
-
declare enum GqlPoolAprItemType {
|
|
380
|
+
export declare enum GqlPoolAprItemType {
|
|
353
381
|
/** APR that pools earns when BPT is staked on AURA. */
|
|
354
382
|
Aura = "AURA",
|
|
355
383
|
/** Represents the yield from an IB (Interest-Bearing) asset APR in a pool. */
|
|
@@ -375,18 +403,18 @@ declare enum GqlPoolAprItemType {
|
|
|
375
403
|
/** APR that can be earned thourgh voting, i.e. gauge votes */
|
|
376
404
|
Voting = "VOTING"
|
|
377
405
|
}
|
|
378
|
-
type GqlPoolAprRange = {
|
|
406
|
+
export type GqlPoolAprRange = {
|
|
379
407
|
__typename?: 'GqlPoolAprRange';
|
|
380
408
|
max: Scalars['BigDecimal']['output'];
|
|
381
409
|
min: Scalars['BigDecimal']['output'];
|
|
382
410
|
};
|
|
383
|
-
type GqlPoolAprTotal = {
|
|
411
|
+
export type GqlPoolAprTotal = {
|
|
384
412
|
__typename?: 'GqlPoolAprTotal';
|
|
385
413
|
total: Scalars['BigDecimal']['output'];
|
|
386
414
|
};
|
|
387
|
-
type GqlPoolAprValue = GqlPoolAprRange | GqlPoolAprTotal;
|
|
415
|
+
export type GqlPoolAprValue = GqlPoolAprRange | GqlPoolAprTotal;
|
|
388
416
|
/** The base type as returned by poolGetPool (specific pool query) */
|
|
389
|
-
type GqlPoolBase = {
|
|
417
|
+
export type GqlPoolBase = {
|
|
390
418
|
/** The contract address of the pool. */
|
|
391
419
|
address: Scalars['Bytes']['output'];
|
|
392
420
|
/**
|
|
@@ -449,7 +477,7 @@ type GqlPoolBase = {
|
|
|
449
477
|
*/
|
|
450
478
|
withdrawConfig: GqlPoolWithdrawConfig;
|
|
451
479
|
};
|
|
452
|
-
type GqlPoolBatchSwap = {
|
|
480
|
+
export type GqlPoolBatchSwap = {
|
|
453
481
|
__typename?: 'GqlPoolBatchSwap';
|
|
454
482
|
chain: GqlChain;
|
|
455
483
|
id: Scalars['ID']['output'];
|
|
@@ -465,12 +493,12 @@ type GqlPoolBatchSwap = {
|
|
|
465
493
|
userAddress: Scalars['Bytes']['output'];
|
|
466
494
|
valueUSD: Scalars['Float']['output'];
|
|
467
495
|
};
|
|
468
|
-
type GqlPoolBatchSwapPool = {
|
|
496
|
+
export type GqlPoolBatchSwapPool = {
|
|
469
497
|
__typename?: 'GqlPoolBatchSwapPool';
|
|
470
498
|
id: Scalars['ID']['output'];
|
|
471
499
|
tokens: Array<Scalars['String']['output']>;
|
|
472
500
|
};
|
|
473
|
-
type GqlPoolBatchSwapSwap = {
|
|
501
|
+
export type GqlPoolBatchSwapSwap = {
|
|
474
502
|
__typename?: 'GqlPoolBatchSwapSwap';
|
|
475
503
|
id: Scalars['ID']['output'];
|
|
476
504
|
pool: GqlPoolMinimal;
|
|
@@ -483,7 +511,7 @@ type GqlPoolBatchSwapSwap = {
|
|
|
483
511
|
userAddress: Scalars['Bytes']['output'];
|
|
484
512
|
valueUSD: Scalars['Float']['output'];
|
|
485
513
|
};
|
|
486
|
-
type GqlPoolComposableStable = GqlPoolBase & {
|
|
514
|
+
export type GqlPoolComposableStable = GqlPoolBase & {
|
|
487
515
|
__typename?: 'GqlPoolComposableStable';
|
|
488
516
|
address: Scalars['Bytes']['output'];
|
|
489
517
|
allTokens: Array<GqlPoolTokenExpanded>;
|
|
@@ -520,7 +548,7 @@ type GqlPoolComposableStable = GqlPoolBase & {
|
|
|
520
548
|
/** @deprecated Removed without replacement */
|
|
521
549
|
withdrawConfig: GqlPoolWithdrawConfig;
|
|
522
550
|
};
|
|
523
|
-
type GqlPoolComposableStableNested = {
|
|
551
|
+
export type GqlPoolComposableStableNested = {
|
|
524
552
|
__typename?: 'GqlPoolComposableStableNested';
|
|
525
553
|
address: Scalars['Bytes']['output'];
|
|
526
554
|
amp: Scalars['BigInt']['output'];
|
|
@@ -542,7 +570,7 @@ type GqlPoolComposableStableNested = {
|
|
|
542
570
|
type: GqlPoolType;
|
|
543
571
|
version: Scalars['Int']['output'];
|
|
544
572
|
};
|
|
545
|
-
type GqlPoolDynamicData = {
|
|
573
|
+
export type GqlPoolDynamicData = {
|
|
546
574
|
__typename?: 'GqlPoolDynamicData';
|
|
547
575
|
/** Protocol and pool creator fees combined */
|
|
548
576
|
aggregateSwapFee: Scalars['BigDecimal']['output'];
|
|
@@ -593,7 +621,7 @@ type GqlPoolDynamicData = {
|
|
|
593
621
|
yieldCapture24h: Scalars['BigDecimal']['output'];
|
|
594
622
|
yieldCapture48h: Scalars['BigDecimal']['output'];
|
|
595
623
|
};
|
|
596
|
-
type GqlPoolElement = GqlPoolBase & {
|
|
624
|
+
export type GqlPoolElement = GqlPoolBase & {
|
|
597
625
|
__typename?: 'GqlPoolElement';
|
|
598
626
|
address: Scalars['Bytes']['output'];
|
|
599
627
|
allTokens: Array<GqlPoolTokenExpanded>;
|
|
@@ -628,7 +656,7 @@ type GqlPoolElement = GqlPoolBase & {
|
|
|
628
656
|
withdrawConfig: GqlPoolWithdrawConfig;
|
|
629
657
|
};
|
|
630
658
|
/** Represents an event that occurs in a pool. */
|
|
631
|
-
type GqlPoolEvent = {
|
|
659
|
+
export type GqlPoolEvent = {
|
|
632
660
|
/** The block number of the event. */
|
|
633
661
|
blockNumber: Scalars['Int']['output'];
|
|
634
662
|
/** The block timestamp of the event. */
|
|
@@ -654,23 +682,23 @@ type GqlPoolEvent = {
|
|
|
654
682
|
/** The USD value of this event. */
|
|
655
683
|
valueUSD: Scalars['Float']['output'];
|
|
656
684
|
};
|
|
657
|
-
type GqlPoolEventAmount = {
|
|
685
|
+
export type GqlPoolEventAmount = {
|
|
658
686
|
__typename?: 'GqlPoolEventAmount';
|
|
659
687
|
address: Scalars['Bytes']['output'];
|
|
660
688
|
amount: Scalars['String']['output'];
|
|
661
689
|
valueUSD: Scalars['Float']['output'];
|
|
662
690
|
};
|
|
663
|
-
declare enum GqlPoolEventType {
|
|
691
|
+
export declare enum GqlPoolEventType {
|
|
664
692
|
Add = "ADD",
|
|
665
693
|
Remove = "REMOVE",
|
|
666
694
|
Swap = "SWAP"
|
|
667
695
|
}
|
|
668
|
-
declare enum GqlPoolEventsDataRange {
|
|
696
|
+
export declare enum GqlPoolEventsDataRange {
|
|
669
697
|
NinetyDays = "NINETY_DAYS",
|
|
670
698
|
SevenDays = "SEVEN_DAYS",
|
|
671
699
|
ThirtyDays = "THIRTY_DAYS"
|
|
672
700
|
}
|
|
673
|
-
type GqlPoolEventsFilter = {
|
|
701
|
+
export type GqlPoolEventsFilter = {
|
|
674
702
|
chainIn?: InputMaybe<Array<InputMaybe<GqlChain>>>;
|
|
675
703
|
poolIdIn?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
|
|
676
704
|
range?: InputMaybe<GqlPoolEventsDataRange>;
|
|
@@ -681,14 +709,12 @@ type GqlPoolEventsFilter = {
|
|
|
681
709
|
/** USD value of the event */
|
|
682
710
|
valueUSD_gte?: InputMaybe<Scalars['Float']['input']>;
|
|
683
711
|
};
|
|
684
|
-
type GqlPoolFilter = {
|
|
712
|
+
export type GqlPoolFilter = {
|
|
685
713
|
addressIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
686
714
|
addressNotIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
687
715
|
chainIn?: InputMaybe<Array<GqlChain>>;
|
|
688
716
|
chainNotIn?: InputMaybe<Array<GqlChain>>;
|
|
689
717
|
createTime?: InputMaybe<GqlPoolTimePeriod>;
|
|
690
|
-
filterIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
691
|
-
filterNotIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
692
718
|
idIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
693
719
|
idNotIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
694
720
|
minTvl?: InputMaybe<Scalars['Float']['input']>;
|
|
@@ -709,7 +735,7 @@ type GqlPoolFilter = {
|
|
|
709
735
|
tokensNotIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
710
736
|
userAddress?: InputMaybe<Scalars['String']['input']>;
|
|
711
737
|
};
|
|
712
|
-
declare enum GqlPoolFilterCategory {
|
|
738
|
+
export declare enum GqlPoolFilterCategory {
|
|
713
739
|
BlackListed = "BLACK_LISTED",
|
|
714
740
|
Featured = "FEATURED",
|
|
715
741
|
Incentivized = "INCENTIVIZED",
|
|
@@ -722,7 +748,7 @@ declare enum GqlPoolFilterCategory {
|
|
|
722
748
|
PointsSwell = "POINTS_SWELL",
|
|
723
749
|
Superfest = "SUPERFEST"
|
|
724
750
|
}
|
|
725
|
-
type GqlPoolFx = GqlPoolBase & {
|
|
751
|
+
export type GqlPoolFx = GqlPoolBase & {
|
|
726
752
|
__typename?: 'GqlPoolFx';
|
|
727
753
|
address: Scalars['Bytes']['output'];
|
|
728
754
|
allTokens: Array<GqlPoolTokenExpanded>;
|
|
@@ -761,7 +787,7 @@ type GqlPoolFx = GqlPoolBase & {
|
|
|
761
787
|
/** @deprecated Removed without replacement */
|
|
762
788
|
withdrawConfig: GqlPoolWithdrawConfig;
|
|
763
789
|
};
|
|
764
|
-
type GqlPoolGyro = GqlPoolBase & {
|
|
790
|
+
export type GqlPoolGyro = GqlPoolBase & {
|
|
765
791
|
__typename?: 'GqlPoolGyro';
|
|
766
792
|
address: Scalars['Bytes']['output'];
|
|
767
793
|
allTokens: Array<GqlPoolTokenExpanded>;
|
|
@@ -813,19 +839,19 @@ type GqlPoolGyro = GqlPoolBase & {
|
|
|
813
839
|
withdrawConfig: GqlPoolWithdrawConfig;
|
|
814
840
|
z: Scalars['String']['output'];
|
|
815
841
|
};
|
|
816
|
-
type GqlPoolInvestConfig = {
|
|
842
|
+
export type GqlPoolInvestConfig = {
|
|
817
843
|
__typename?: 'GqlPoolInvestConfig';
|
|
818
844
|
options: Array<GqlPoolInvestOption>;
|
|
819
845
|
proportionalEnabled: Scalars['Boolean']['output'];
|
|
820
846
|
singleAssetEnabled: Scalars['Boolean']['output'];
|
|
821
847
|
};
|
|
822
|
-
type GqlPoolInvestOption = {
|
|
848
|
+
export type GqlPoolInvestOption = {
|
|
823
849
|
__typename?: 'GqlPoolInvestOption';
|
|
824
850
|
poolTokenAddress: Scalars['Bytes']['output'];
|
|
825
851
|
poolTokenIndex: Scalars['Int']['output'];
|
|
826
852
|
tokenOptions: Array<GqlPoolToken>;
|
|
827
853
|
};
|
|
828
|
-
type GqlPoolJoinExit = {
|
|
854
|
+
export type GqlPoolJoinExit = {
|
|
829
855
|
__typename?: 'GqlPoolJoinExit';
|
|
830
856
|
amounts: Array<GqlPoolJoinExitAmount>;
|
|
831
857
|
chain: GqlChain;
|
|
@@ -837,20 +863,20 @@ type GqlPoolJoinExit = {
|
|
|
837
863
|
type: GqlPoolJoinExitType;
|
|
838
864
|
valueUSD?: Maybe<Scalars['String']['output']>;
|
|
839
865
|
};
|
|
840
|
-
type GqlPoolJoinExitAmount = {
|
|
866
|
+
export type GqlPoolJoinExitAmount = {
|
|
841
867
|
__typename?: 'GqlPoolJoinExitAmount';
|
|
842
868
|
address: Scalars['Bytes']['output'];
|
|
843
869
|
amount: Scalars['String']['output'];
|
|
844
870
|
};
|
|
845
|
-
type GqlPoolJoinExitFilter = {
|
|
871
|
+
export type GqlPoolJoinExitFilter = {
|
|
846
872
|
chainIn?: InputMaybe<Array<GqlChain>>;
|
|
847
873
|
poolIdIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
848
874
|
};
|
|
849
|
-
declare enum GqlPoolJoinExitType {
|
|
875
|
+
export declare enum GqlPoolJoinExitType {
|
|
850
876
|
Exit = "Exit",
|
|
851
877
|
Join = "Join"
|
|
852
878
|
}
|
|
853
|
-
type GqlPoolLiquidityBootstrapping = GqlPoolBase & {
|
|
879
|
+
export type GqlPoolLiquidityBootstrapping = GqlPoolBase & {
|
|
854
880
|
__typename?: 'GqlPoolLiquidityBootstrapping';
|
|
855
881
|
address: Scalars['Bytes']['output'];
|
|
856
882
|
allTokens: Array<GqlPoolTokenExpanded>;
|
|
@@ -885,7 +911,7 @@ type GqlPoolLiquidityBootstrapping = GqlPoolBase & {
|
|
|
885
911
|
/** @deprecated Removed without replacement */
|
|
886
912
|
withdrawConfig: GqlPoolWithdrawConfig;
|
|
887
913
|
};
|
|
888
|
-
type GqlPoolMetaStable = GqlPoolBase & {
|
|
914
|
+
export type GqlPoolMetaStable = GqlPoolBase & {
|
|
889
915
|
__typename?: 'GqlPoolMetaStable';
|
|
890
916
|
address: Scalars['Bytes']['output'];
|
|
891
917
|
allTokens: Array<GqlPoolTokenExpanded>;
|
|
@@ -918,7 +944,7 @@ type GqlPoolMetaStable = GqlPoolBase & {
|
|
|
918
944
|
withdrawConfig: GqlPoolWithdrawConfig;
|
|
919
945
|
};
|
|
920
946
|
/** The pool schema returned for poolGetPools (pool list query) */
|
|
921
|
-
type GqlPoolMinimal = {
|
|
947
|
+
export type GqlPoolMinimal = {
|
|
922
948
|
__typename?: 'GqlPoolMinimal';
|
|
923
949
|
/** The contract address of the pool. */
|
|
924
950
|
address: Scalars['Bytes']['output'];
|
|
@@ -940,7 +966,10 @@ type GqlPoolMinimal = {
|
|
|
940
966
|
factory?: Maybe<Scalars['Bytes']['output']>;
|
|
941
967
|
/** Whether at least one token in this pool is considered an ERC4626 token. */
|
|
942
968
|
hasErc4626: Scalars['Boolean']['output'];
|
|
943
|
-
/**
|
|
969
|
+
/**
|
|
970
|
+
* Hook assigned to a pool
|
|
971
|
+
* @deprecated Removed without replacement
|
|
972
|
+
*/
|
|
944
973
|
hook?: Maybe<Hook>;
|
|
945
974
|
/** The pool id. This is equal to the address for protocolVersion 3 pools */
|
|
946
975
|
id: Scalars['ID']['output'];
|
|
@@ -970,13 +999,13 @@ type GqlPoolMinimal = {
|
|
|
970
999
|
/** The version of the pool type. */
|
|
971
1000
|
version: Scalars['Int']['output'];
|
|
972
1001
|
};
|
|
973
|
-
type GqlPoolNestedUnion = GqlPoolComposableStableNested;
|
|
974
|
-
declare enum GqlPoolNestingType {
|
|
1002
|
+
export type GqlPoolNestedUnion = GqlPoolComposableStableNested;
|
|
1003
|
+
export declare enum GqlPoolNestingType {
|
|
975
1004
|
HasOnlyPhantomBpt = "HAS_ONLY_PHANTOM_BPT",
|
|
976
1005
|
HasSomePhantomBpt = "HAS_SOME_PHANTOM_BPT",
|
|
977
1006
|
NoNesting = "NO_NESTING"
|
|
978
1007
|
}
|
|
979
|
-
declare enum GqlPoolOrderBy {
|
|
1008
|
+
export declare enum GqlPoolOrderBy {
|
|
980
1009
|
Apr = "apr",
|
|
981
1010
|
/** @deprecated Use polApr instead */
|
|
982
1011
|
BgtApr = "bgtApr",
|
|
@@ -988,11 +1017,11 @@ declare enum GqlPoolOrderBy {
|
|
|
988
1017
|
UserbalanceUsd = "userbalanceUsd",
|
|
989
1018
|
Volume24h = "volume24h"
|
|
990
1019
|
}
|
|
991
|
-
declare enum GqlPoolOrderDirection {
|
|
1020
|
+
export declare enum GqlPoolOrderDirection {
|
|
992
1021
|
Asc = "asc",
|
|
993
1022
|
Desc = "desc"
|
|
994
1023
|
}
|
|
995
|
-
type GqlPoolSnapshot = {
|
|
1024
|
+
export type GqlPoolSnapshot = {
|
|
996
1025
|
__typename?: 'GqlPoolSnapshot';
|
|
997
1026
|
amounts: Array<Scalars['String']['output']>;
|
|
998
1027
|
chain: GqlChain;
|
|
@@ -1011,14 +1040,14 @@ type GqlPoolSnapshot = {
|
|
|
1011
1040
|
totalSwapVolume: Scalars['String']['output'];
|
|
1012
1041
|
volume24h: Scalars['String']['output'];
|
|
1013
1042
|
};
|
|
1014
|
-
declare enum GqlPoolSnapshotDataRange {
|
|
1043
|
+
export declare enum GqlPoolSnapshotDataRange {
|
|
1015
1044
|
AllTime = "ALL_TIME",
|
|
1016
1045
|
NinetyDays = "NINETY_DAYS",
|
|
1017
1046
|
OneHundredEightyDays = "ONE_HUNDRED_EIGHTY_DAYS",
|
|
1018
1047
|
OneYear = "ONE_YEAR",
|
|
1019
1048
|
ThirtyDays = "THIRTY_DAYS"
|
|
1020
1049
|
}
|
|
1021
|
-
type GqlPoolStable = GqlPoolBase & {
|
|
1050
|
+
export type GqlPoolStable = GqlPoolBase & {
|
|
1022
1051
|
__typename?: 'GqlPoolStable';
|
|
1023
1052
|
address: Scalars['Bytes']['output'];
|
|
1024
1053
|
allTokens: Array<GqlPoolTokenExpanded>;
|
|
@@ -1050,7 +1079,7 @@ type GqlPoolStable = GqlPoolBase & {
|
|
|
1050
1079
|
/** @deprecated Removed without replacement */
|
|
1051
1080
|
withdrawConfig: GqlPoolWithdrawConfig;
|
|
1052
1081
|
};
|
|
1053
|
-
type GqlPoolStableComposablePoolData = {
|
|
1082
|
+
export type GqlPoolStableComposablePoolData = {
|
|
1054
1083
|
__typename?: 'GqlPoolStableComposablePoolData';
|
|
1055
1084
|
address: Scalars['Bytes']['output'];
|
|
1056
1085
|
balance: Scalars['String']['output'];
|
|
@@ -1059,7 +1088,7 @@ type GqlPoolStableComposablePoolData = {
|
|
|
1059
1088
|
tokens: Array<GqlPoolToken>;
|
|
1060
1089
|
totalSupply: Scalars['String']['output'];
|
|
1061
1090
|
};
|
|
1062
|
-
type GqlPoolSwap = {
|
|
1091
|
+
export type GqlPoolSwap = {
|
|
1063
1092
|
__typename?: 'GqlPoolSwap';
|
|
1064
1093
|
chain: GqlChain;
|
|
1065
1094
|
id: Scalars['ID']['output'];
|
|
@@ -1073,17 +1102,87 @@ type GqlPoolSwap = {
|
|
|
1073
1102
|
userAddress: Scalars['Bytes']['output'];
|
|
1074
1103
|
valueUSD: Scalars['Float']['output'];
|
|
1075
1104
|
};
|
|
1076
|
-
|
|
1105
|
+
/** Represents an event that occurs when a swap is made in a pool using the CowAmm protocol. */
|
|
1106
|
+
export type GqlPoolSwapEventCowAmm = GqlPoolEvent & {
|
|
1107
|
+
__typename?: 'GqlPoolSwapEventCowAmm';
|
|
1108
|
+
/** The block number of the event. */
|
|
1109
|
+
blockNumber: Scalars['Int']['output'];
|
|
1110
|
+
/** The block timestamp of the event. */
|
|
1111
|
+
blockTimestamp: Scalars['Int']['output'];
|
|
1112
|
+
/** The chain on which the event occurred. */
|
|
1113
|
+
chain: GqlChain;
|
|
1114
|
+
/** The fee that this swap generated. */
|
|
1115
|
+
fee: GqlPoolEventAmount;
|
|
1116
|
+
/** The unique identifier of the event. */
|
|
1117
|
+
id: Scalars['ID']['output'];
|
|
1118
|
+
/** The log index of the event. */
|
|
1119
|
+
logIndex: Scalars['Int']['output'];
|
|
1120
|
+
/** The pool ID associated with the event. */
|
|
1121
|
+
poolId: Scalars['String']['output'];
|
|
1122
|
+
/** The sender of the event. */
|
|
1123
|
+
sender: Scalars['String']['output'];
|
|
1124
|
+
/** The surplus generated by the swap. */
|
|
1125
|
+
surplus: GqlPoolEventAmount;
|
|
1126
|
+
/** The timestamp of the event. */
|
|
1127
|
+
timestamp: Scalars['Int']['output'];
|
|
1128
|
+
/** The token that was swapped in the event. */
|
|
1129
|
+
tokenIn: GqlPoolEventAmount;
|
|
1130
|
+
/** The token that was swapped out in the event. */
|
|
1131
|
+
tokenOut: GqlPoolEventAmount;
|
|
1132
|
+
/** The transaction hash of the event. */
|
|
1133
|
+
tx: Scalars['String']['output'];
|
|
1134
|
+
/** The type of the event. */
|
|
1135
|
+
type: GqlPoolEventType;
|
|
1136
|
+
/** The user address associated with the event. */
|
|
1137
|
+
userAddress: Scalars['Bytes']['output'];
|
|
1138
|
+
/** The value of the event in USD. */
|
|
1139
|
+
valueUSD: Scalars['Float']['output'];
|
|
1140
|
+
};
|
|
1141
|
+
/** Represents an event that occurs when a swap is made in a pool. */
|
|
1142
|
+
export type GqlPoolSwapEventV3 = GqlPoolEvent & {
|
|
1143
|
+
__typename?: 'GqlPoolSwapEventV3';
|
|
1144
|
+
/** The block number of the event. */
|
|
1145
|
+
blockNumber: Scalars['Int']['output'];
|
|
1146
|
+
/** The block timestamp of the event. */
|
|
1147
|
+
blockTimestamp: Scalars['Int']['output'];
|
|
1148
|
+
/** The chain on which the event occurred. */
|
|
1149
|
+
chain: GqlChain;
|
|
1150
|
+
/** The fee that this swap generated. */
|
|
1151
|
+
fee: GqlPoolEventAmount;
|
|
1152
|
+
/** The unique identifier of the event. */
|
|
1153
|
+
id: Scalars['ID']['output'];
|
|
1154
|
+
/** The log index of the event. */
|
|
1155
|
+
logIndex: Scalars['Int']['output'];
|
|
1156
|
+
/** The pool ID associated with the event. */
|
|
1157
|
+
poolId: Scalars['String']['output'];
|
|
1158
|
+
/** The sender of the event. */
|
|
1159
|
+
sender: Scalars['String']['output'];
|
|
1160
|
+
/** The timestamp of the event. */
|
|
1161
|
+
timestamp: Scalars['Int']['output'];
|
|
1162
|
+
/** The token that was swapped in the event. */
|
|
1163
|
+
tokenIn: GqlPoolEventAmount;
|
|
1164
|
+
/** The token that was swapped out in the event. */
|
|
1165
|
+
tokenOut: GqlPoolEventAmount;
|
|
1166
|
+
/** The transaction hash of the event. */
|
|
1167
|
+
tx: Scalars['String']['output'];
|
|
1168
|
+
/** The type of the event. */
|
|
1169
|
+
type: GqlPoolEventType;
|
|
1170
|
+
/** The user address associated with the event. */
|
|
1171
|
+
userAddress: Scalars['Bytes']['output'];
|
|
1172
|
+
/** The value of the event in USD. */
|
|
1173
|
+
valueUSD: Scalars['Float']['output'];
|
|
1174
|
+
};
|
|
1175
|
+
export type GqlPoolSwapFilter = {
|
|
1077
1176
|
chainIn?: InputMaybe<Array<GqlChain>>;
|
|
1078
1177
|
poolIdIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
1079
1178
|
tokenInIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
1080
1179
|
tokenOutIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
1081
1180
|
};
|
|
1082
|
-
type GqlPoolTimePeriod = {
|
|
1181
|
+
export type GqlPoolTimePeriod = {
|
|
1083
1182
|
gt?: InputMaybe<Scalars['Int']['input']>;
|
|
1084
1183
|
lt?: InputMaybe<Scalars['Int']['input']>;
|
|
1085
1184
|
};
|
|
1086
|
-
type GqlPoolToken = GqlPoolTokenBase & {
|
|
1185
|
+
export type GqlPoolToken = GqlPoolTokenBase & {
|
|
1087
1186
|
__typename?: 'GqlPoolToken';
|
|
1088
1187
|
address: Scalars['Bytes']['output'];
|
|
1089
1188
|
balance: Scalars['BigDecimal']['output'];
|
|
@@ -1097,7 +1196,7 @@ type GqlPoolToken = GqlPoolTokenBase & {
|
|
|
1097
1196
|
totalBalance: Scalars['BigDecimal']['output'];
|
|
1098
1197
|
weight?: Maybe<Scalars['BigDecimal']['output']>;
|
|
1099
1198
|
};
|
|
1100
|
-
type GqlPoolTokenBase = {
|
|
1199
|
+
export type GqlPoolTokenBase = {
|
|
1101
1200
|
address: Scalars['Bytes']['output'];
|
|
1102
1201
|
balance: Scalars['BigDecimal']['output'];
|
|
1103
1202
|
decimals: Scalars['Int']['output'];
|
|
@@ -1110,7 +1209,7 @@ type GqlPoolTokenBase = {
|
|
|
1110
1209
|
totalBalance: Scalars['BigDecimal']['output'];
|
|
1111
1210
|
weight?: Maybe<Scalars['BigDecimal']['output']>;
|
|
1112
1211
|
};
|
|
1113
|
-
type GqlPoolTokenComposableStable = GqlPoolTokenBase & {
|
|
1212
|
+
export type GqlPoolTokenComposableStable = GqlPoolTokenBase & {
|
|
1114
1213
|
__typename?: 'GqlPoolTokenComposableStable';
|
|
1115
1214
|
address: Scalars['Bytes']['output'];
|
|
1116
1215
|
balance: Scalars['BigDecimal']['output'];
|
|
@@ -1125,12 +1224,12 @@ type GqlPoolTokenComposableStable = GqlPoolTokenBase & {
|
|
|
1125
1224
|
totalBalance: Scalars['BigDecimal']['output'];
|
|
1126
1225
|
weight?: Maybe<Scalars['BigDecimal']['output']>;
|
|
1127
1226
|
};
|
|
1128
|
-
type GqlPoolTokenComposableStableNestedUnion = GqlPoolToken;
|
|
1227
|
+
export type GqlPoolTokenComposableStableNestedUnion = GqlPoolToken;
|
|
1129
1228
|
/**
|
|
1130
1229
|
* All info on the pool token. It will also include the nested pool if the token is a BPT. It will only support 1 level of nesting.
|
|
1131
1230
|
* A second (unsupported) level of nesting is shown by having hasNestedPool = true but nestedPool = null.
|
|
1132
1231
|
*/
|
|
1133
|
-
type GqlPoolTokenDetail = {
|
|
1232
|
+
export type GqlPoolTokenDetail = {
|
|
1134
1233
|
__typename?: 'GqlPoolTokenDetail';
|
|
1135
1234
|
/** Address of the pool token. */
|
|
1136
1235
|
address: Scalars['Bytes']['output'];
|
|
@@ -1167,7 +1266,7 @@ type GqlPoolTokenDetail = {
|
|
|
1167
1266
|
/** The weight of the token in the pool if it is a weighted pool, null otherwise */
|
|
1168
1267
|
weight?: Maybe<Scalars['BigDecimal']['output']>;
|
|
1169
1268
|
};
|
|
1170
|
-
type GqlPoolTokenDisplay = {
|
|
1269
|
+
export type GqlPoolTokenDisplay = {
|
|
1171
1270
|
__typename?: 'GqlPoolTokenDisplay';
|
|
1172
1271
|
address: Scalars['Bytes']['output'];
|
|
1173
1272
|
id: Scalars['ID']['output'];
|
|
@@ -1176,7 +1275,7 @@ type GqlPoolTokenDisplay = {
|
|
|
1176
1275
|
symbol: Scalars['String']['output'];
|
|
1177
1276
|
weight?: Maybe<Scalars['BigDecimal']['output']>;
|
|
1178
1277
|
};
|
|
1179
|
-
type GqlPoolTokenExpanded = {
|
|
1278
|
+
export type GqlPoolTokenExpanded = {
|
|
1180
1279
|
__typename?: 'GqlPoolTokenExpanded';
|
|
1181
1280
|
address: Scalars['Bytes']['output'];
|
|
1182
1281
|
decimals: Scalars['Int']['output'];
|
|
@@ -1189,9 +1288,9 @@ type GqlPoolTokenExpanded = {
|
|
|
1189
1288
|
symbol: Scalars['String']['output'];
|
|
1190
1289
|
weight?: Maybe<Scalars['String']['output']>;
|
|
1191
1290
|
};
|
|
1192
|
-
type GqlPoolTokenUnion = GqlPoolToken | GqlPoolTokenComposableStable;
|
|
1291
|
+
export type GqlPoolTokenUnion = GqlPoolToken | GqlPoolTokenComposableStable;
|
|
1193
1292
|
/** Supported pool types */
|
|
1194
|
-
declare enum GqlPoolType {
|
|
1293
|
+
export declare enum GqlPoolType {
|
|
1195
1294
|
ComposableStable = "COMPOSABLE_STABLE",
|
|
1196
1295
|
CowAmm = "COW_AMM",
|
|
1197
1296
|
Element = "ELEMENT",
|
|
@@ -1207,9 +1306,9 @@ declare enum GqlPoolType {
|
|
|
1207
1306
|
Unknown = "UNKNOWN",
|
|
1208
1307
|
Weighted = "WEIGHTED"
|
|
1209
1308
|
}
|
|
1210
|
-
type GqlPoolUnion = GqlPoolComposableStable | GqlPoolElement | GqlPoolFx | GqlPoolGyro | GqlPoolLiquidityBootstrapping | GqlPoolMetaStable | GqlPoolStable | GqlPoolWeighted;
|
|
1309
|
+
export type GqlPoolUnion = GqlPoolComposableStable | GqlPoolElement | GqlPoolFx | GqlPoolGyro | GqlPoolLiquidityBootstrapping | GqlPoolMetaStable | GqlPoolStable | GqlPoolWeighted;
|
|
1211
1310
|
/** If a user address was provided in the query, the user balance is populated here */
|
|
1212
|
-
type GqlPoolUserBalance = {
|
|
1311
|
+
export type GqlPoolUserBalance = {
|
|
1213
1312
|
__typename?: 'GqlPoolUserBalance';
|
|
1214
1313
|
/** The staking balance (BPT staked in reward vault) as float. */
|
|
1215
1314
|
stakingBalance: Scalars['AmountHumanReadable']['output'];
|
|
@@ -1224,12 +1323,12 @@ type GqlPoolUserBalance = {
|
|
|
1224
1323
|
/** The wallet balance (BPT in wallet) in USD as float. */
|
|
1225
1324
|
walletBalanceUsd: Scalars['Float']['output'];
|
|
1226
1325
|
};
|
|
1227
|
-
type GqlPoolUserSwapVolume = {
|
|
1326
|
+
export type GqlPoolUserSwapVolume = {
|
|
1228
1327
|
__typename?: 'GqlPoolUserSwapVolume';
|
|
1229
1328
|
swapVolumeUSD: Scalars['BigDecimal']['output'];
|
|
1230
1329
|
userAddress: Scalars['Bytes']['output'];
|
|
1231
1330
|
};
|
|
1232
|
-
type GqlPoolWeighted = GqlPoolBase & {
|
|
1331
|
+
export type GqlPoolWeighted = GqlPoolBase & {
|
|
1233
1332
|
__typename?: 'GqlPoolWeighted';
|
|
1234
1333
|
address: Scalars['Bytes']['output'];
|
|
1235
1334
|
allTokens: Array<GqlPoolTokenExpanded>;
|
|
@@ -1264,20 +1363,20 @@ type GqlPoolWeighted = GqlPoolBase & {
|
|
|
1264
1363
|
/** @deprecated Removed without replacement */
|
|
1265
1364
|
withdrawConfig: GqlPoolWithdrawConfig;
|
|
1266
1365
|
};
|
|
1267
|
-
type GqlPoolWithdrawConfig = {
|
|
1366
|
+
export type GqlPoolWithdrawConfig = {
|
|
1268
1367
|
__typename?: 'GqlPoolWithdrawConfig';
|
|
1269
1368
|
options: Array<GqlPoolWithdrawOption>;
|
|
1270
1369
|
proportionalEnabled: Scalars['Boolean']['output'];
|
|
1271
1370
|
singleAssetEnabled: Scalars['Boolean']['output'];
|
|
1272
1371
|
};
|
|
1273
|
-
type GqlPoolWithdrawOption = {
|
|
1372
|
+
export type GqlPoolWithdrawOption = {
|
|
1274
1373
|
__typename?: 'GqlPoolWithdrawOption';
|
|
1275
1374
|
poolTokenAddress: Scalars['Bytes']['output'];
|
|
1276
1375
|
poolTokenIndex: Scalars['Int']['output'];
|
|
1277
1376
|
tokenOptions: Array<GqlPoolToken>;
|
|
1278
1377
|
};
|
|
1279
1378
|
/** Returns the price impact of the path. If there is an error in the price impact calculation, priceImpact will be undefined but the error string is populated. */
|
|
1280
|
-
type GqlPriceImpact = {
|
|
1379
|
+
export type GqlPriceImpact = {
|
|
1281
1380
|
__typename?: 'GqlPriceImpact';
|
|
1282
1381
|
/** If priceImpact cant be calculated and is returned as undefined, the error string will be populated. */
|
|
1283
1382
|
error?: Maybe<Scalars['String']['output']>;
|
|
@@ -1285,7 +1384,7 @@ type GqlPriceImpact = {
|
|
|
1285
1384
|
priceImpact?: Maybe<Scalars['AmountHumanReadable']['output']>;
|
|
1286
1385
|
};
|
|
1287
1386
|
/** Represents the data of a price rate provider */
|
|
1288
|
-
type GqlPriceRateProviderData = {
|
|
1387
|
+
export type GqlPriceRateProviderData = {
|
|
1289
1388
|
__typename?: 'GqlPriceRateProviderData';
|
|
1290
1389
|
/** The address of the price rate provider */
|
|
1291
1390
|
address: Scalars['Bytes']['output'];
|
|
@@ -1305,14 +1404,14 @@ type GqlPriceRateProviderData = {
|
|
|
1305
1404
|
warnings?: Maybe<Array<Scalars['String']['output']>>;
|
|
1306
1405
|
};
|
|
1307
1406
|
/** Represents an upgradeable component of a price rate provider */
|
|
1308
|
-
type GqlPriceRateProviderUpgradeableComponent = {
|
|
1407
|
+
export type GqlPriceRateProviderUpgradeableComponent = {
|
|
1309
1408
|
__typename?: 'GqlPriceRateProviderUpgradeableComponent';
|
|
1310
1409
|
/** The entry point / proxy of the upgradeable component */
|
|
1311
1410
|
entryPoint: Scalars['String']['output'];
|
|
1312
1411
|
/** Indicates if the implementation of the component has been reviewed */
|
|
1313
1412
|
implementationReviewed: Scalars['String']['output'];
|
|
1314
1413
|
};
|
|
1315
|
-
type GqlProtocolMetricsAggregated = {
|
|
1414
|
+
export type GqlProtocolMetricsAggregated = {
|
|
1316
1415
|
__typename?: 'GqlProtocolMetricsAggregated';
|
|
1317
1416
|
chains: Array<GqlProtocolMetricsChain>;
|
|
1318
1417
|
numLiquidityProviders: Scalars['BigInt']['output'];
|
|
@@ -1324,7 +1423,7 @@ type GqlProtocolMetricsAggregated = {
|
|
|
1324
1423
|
totalSwapVolume: Scalars['BigDecimal']['output'];
|
|
1325
1424
|
yieldCapture24h: Scalars['BigDecimal']['output'];
|
|
1326
1425
|
};
|
|
1327
|
-
type GqlProtocolMetricsChain = {
|
|
1426
|
+
export type GqlProtocolMetricsChain = {
|
|
1328
1427
|
__typename?: 'GqlProtocolMetricsChain';
|
|
1329
1428
|
chainId: Scalars['String']['output'];
|
|
1330
1429
|
numLiquidityProviders: Scalars['BigInt']['output'];
|
|
@@ -1336,7 +1435,7 @@ type GqlProtocolMetricsChain = {
|
|
|
1336
1435
|
totalSwapVolume: Scalars['BigDecimal']['output'];
|
|
1337
1436
|
yieldCapture24h: Scalars['BigDecimal']['output'];
|
|
1338
1437
|
};
|
|
1339
|
-
type GqlRelicSnapshot = {
|
|
1438
|
+
export type GqlRelicSnapshot = {
|
|
1340
1439
|
__typename?: 'GqlRelicSnapshot';
|
|
1341
1440
|
balance: Scalars['String']['output'];
|
|
1342
1441
|
entryTimestamp: Scalars['Int']['output'];
|
|
@@ -1344,7 +1443,7 @@ type GqlRelicSnapshot = {
|
|
|
1344
1443
|
level: Scalars['Int']['output'];
|
|
1345
1444
|
relicId: Scalars['Int']['output'];
|
|
1346
1445
|
};
|
|
1347
|
-
type GqlRewardVault = {
|
|
1446
|
+
export type GqlRewardVault = {
|
|
1348
1447
|
__typename?: 'GqlRewardVault';
|
|
1349
1448
|
activeIncentives: Array<GqlRewardVaultIncentive>;
|
|
1350
1449
|
chain: GqlChain;
|
|
@@ -1358,7 +1457,7 @@ type GqlRewardVault = {
|
|
|
1358
1457
|
whitelistedIncentives: Array<GqlRewardVaultIncentive>;
|
|
1359
1458
|
whitelistedTokens: Array<GqlRewardVaultWhitelistedToken>;
|
|
1360
1459
|
};
|
|
1361
|
-
type GqlRewardVaultDynamicData = {
|
|
1460
|
+
export type GqlRewardVaultDynamicData = {
|
|
1362
1461
|
__typename?: 'GqlRewardVaultDynamicData';
|
|
1363
1462
|
activeIncentivesRateUsd: Scalars['String']['output'];
|
|
1364
1463
|
activeIncentivesValueUsd: Scalars['String']['output'];
|
|
@@ -1384,7 +1483,7 @@ type GqlRewardVaultDynamicData = {
|
|
|
1384
1483
|
tvl?: Maybe<Scalars['Float']['output']>;
|
|
1385
1484
|
vaultAddress: Scalars['Bytes']['output'];
|
|
1386
1485
|
};
|
|
1387
|
-
type GqlRewardVaultFilter = {
|
|
1486
|
+
export type GqlRewardVaultFilter = {
|
|
1388
1487
|
categoriesIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
1389
1488
|
categoriesNotIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
1390
1489
|
chainIn?: InputMaybe<Array<GqlChain>>;
|
|
@@ -1398,7 +1497,7 @@ type GqlRewardVaultFilter = {
|
|
|
1398
1497
|
vaultAddressIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
1399
1498
|
vaultAddressNotIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
1400
1499
|
};
|
|
1401
|
-
type GqlRewardVaultIncentive = GqlIncentive & {
|
|
1500
|
+
export type GqlRewardVaultIncentive = GqlIncentive & {
|
|
1402
1501
|
__typename?: 'GqlRewardVaultIncentive';
|
|
1403
1502
|
active: Scalars['Boolean']['output'];
|
|
1404
1503
|
chain: GqlChain;
|
|
@@ -1411,16 +1510,16 @@ type GqlRewardVaultIncentive = GqlIncentive & {
|
|
|
1411
1510
|
tokenAddress: Scalars['Bytes']['output'];
|
|
1412
1511
|
vaultAddress: Scalars['Bytes']['output'];
|
|
1413
1512
|
};
|
|
1414
|
-
declare enum GqlRewardVaultIncentiveOrderBy {
|
|
1513
|
+
export declare enum GqlRewardVaultIncentiveOrderBy {
|
|
1415
1514
|
AmountRemaining = "amountRemaining",
|
|
1416
1515
|
AmountRemainingUsd = "amountRemainingUsd",
|
|
1417
1516
|
IncentiveRate = "incentiveRate"
|
|
1418
1517
|
}
|
|
1419
|
-
declare enum GqlRewardVaultIncentiveOrderDirection {
|
|
1518
|
+
export declare enum GqlRewardVaultIncentiveOrderDirection {
|
|
1420
1519
|
Asc = "asc",
|
|
1421
1520
|
Desc = "desc"
|
|
1422
1521
|
}
|
|
1423
|
-
type GqlRewardVaultMetadata = {
|
|
1522
|
+
export type GqlRewardVaultMetadata = {
|
|
1424
1523
|
__typename?: 'GqlRewardVaultMetadata';
|
|
1425
1524
|
action: Scalars['String']['output'];
|
|
1426
1525
|
categories: Array<Scalars['String']['output']>;
|
|
@@ -1433,7 +1532,7 @@ type GqlRewardVaultMetadata = {
|
|
|
1433
1532
|
url: Scalars['String']['output'];
|
|
1434
1533
|
vaultAddress: Scalars['Bytes']['output'];
|
|
1435
1534
|
};
|
|
1436
|
-
declare enum GqlRewardVaultOrderBy {
|
|
1535
|
+
export declare enum GqlRewardVaultOrderBy {
|
|
1437
1536
|
ActiveIncentivesRateUsd = "activeIncentivesRateUsd",
|
|
1438
1537
|
ActiveIncentivesValueUsd = "activeIncentivesValueUsd",
|
|
1439
1538
|
AllTimeBgtReceived = "allTimeBGTReceived",
|
|
@@ -1446,11 +1545,11 @@ declare enum GqlRewardVaultOrderBy {
|
|
|
1446
1545
|
ProjectedApr = "projectedApr",
|
|
1447
1546
|
RewardCapturePercentage = "rewardCapturePercentage"
|
|
1448
1547
|
}
|
|
1449
|
-
declare enum GqlRewardVaultOrderDirection {
|
|
1548
|
+
export declare enum GqlRewardVaultOrderDirection {
|
|
1450
1549
|
Asc = "asc",
|
|
1451
1550
|
Desc = "desc"
|
|
1452
1551
|
}
|
|
1453
|
-
type GqlRewardVaultSnapshot = {
|
|
1552
|
+
export type GqlRewardVaultSnapshot = {
|
|
1454
1553
|
__typename?: 'GqlRewardVaultSnapshot';
|
|
1455
1554
|
activeIncentivesValueUsd: Scalars['String']['output'];
|
|
1456
1555
|
apr: Scalars['String']['output'];
|
|
@@ -1463,18 +1562,18 @@ type GqlRewardVaultSnapshot = {
|
|
|
1463
1562
|
tvl: Scalars['String']['output'];
|
|
1464
1563
|
vaultAddress: Scalars['Bytes']['output'];
|
|
1465
1564
|
};
|
|
1466
|
-
declare enum GqlRewardVaultSnapshotDataRange {
|
|
1565
|
+
export declare enum GqlRewardVaultSnapshotDataRange {
|
|
1467
1566
|
AllTime = "ALL_TIME",
|
|
1468
1567
|
NinetyDays = "NINETY_DAYS",
|
|
1469
1568
|
SevenDays = "SEVEN_DAYS",
|
|
1470
1569
|
SixtyDays = "SIXTY_DAYS",
|
|
1471
1570
|
ThirtyDays = "THIRTY_DAYS"
|
|
1472
1571
|
}
|
|
1473
|
-
declare enum GqlRewardVaultSnapshotResolution {
|
|
1572
|
+
export declare enum GqlRewardVaultSnapshotResolution {
|
|
1474
1573
|
Day = "DAY",
|
|
1475
1574
|
Hour = "HOUR"
|
|
1476
1575
|
}
|
|
1477
|
-
type GqlRewardVaultWhitelistedToken = {
|
|
1576
|
+
export type GqlRewardVaultWhitelistedToken = {
|
|
1478
1577
|
__typename?: 'GqlRewardVaultWhitelistedToken';
|
|
1479
1578
|
chain: GqlChain;
|
|
1480
1579
|
token: GqlToken;
|
|
@@ -1482,16 +1581,19 @@ type GqlRewardVaultWhitelistedToken = {
|
|
|
1482
1581
|
vaultAddress: Scalars['Bytes']['output'];
|
|
1483
1582
|
whitelisted: Scalars['Boolean']['output'];
|
|
1484
1583
|
};
|
|
1485
|
-
type GqlSWberaVaultMetadata = {
|
|
1584
|
+
export type GqlSWberaVaultMetadata = {
|
|
1486
1585
|
__typename?: 'GqlSWberaVaultMetadata';
|
|
1487
1586
|
apr: Scalars['String']['output'];
|
|
1488
1587
|
chain: GqlChain;
|
|
1489
1588
|
};
|
|
1490
|
-
declare enum GqlSWberaVaultMetadataResolution {
|
|
1589
|
+
export declare enum GqlSWberaVaultMetadataResolution {
|
|
1590
|
+
EighteenHours = "EIGHTEEN_HOURS",
|
|
1491
1591
|
OneDay = "ONE_DAY",
|
|
1492
|
-
SevenDays = "SEVEN_DAYS"
|
|
1592
|
+
SevenDays = "SEVEN_DAYS",
|
|
1593
|
+
SixHours = "SIX_HOURS",
|
|
1594
|
+
TwelveHours = "TWELVE_HOURS"
|
|
1493
1595
|
}
|
|
1494
|
-
type GqlSWberaVaultSnapshot = {
|
|
1596
|
+
export type GqlSWberaVaultSnapshot = {
|
|
1495
1597
|
__typename?: 'GqlSWberaVaultSnapshot';
|
|
1496
1598
|
apr: Scalars['String']['output'];
|
|
1497
1599
|
chain: GqlChain;
|
|
@@ -1500,7 +1602,7 @@ type GqlSWberaVaultSnapshot = {
|
|
|
1500
1602
|
totalAssets: Scalars['String']['output'];
|
|
1501
1603
|
vaultAddress: Scalars['Bytes']['output'];
|
|
1502
1604
|
};
|
|
1503
|
-
type GqlSorCallData = {
|
|
1605
|
+
export type GqlSorCallData = {
|
|
1504
1606
|
__typename?: 'GqlSorCallData';
|
|
1505
1607
|
/** The call data that needs to be sent to the RPC */
|
|
1506
1608
|
callData: Scalars['String']['output'];
|
|
@@ -1514,7 +1616,7 @@ type GqlSorCallData = {
|
|
|
1514
1616
|
value: Scalars['BigDecimal']['output'];
|
|
1515
1617
|
};
|
|
1516
1618
|
/** The swap paths for a swap */
|
|
1517
|
-
type GqlSorGetSwapPaths = {
|
|
1619
|
+
export type GqlSorGetSwapPaths = {
|
|
1518
1620
|
__typename?: 'GqlSorGetSwapPaths';
|
|
1519
1621
|
/** Transaction data that can be posted to an RPC to execute the swap. */
|
|
1520
1622
|
callData?: Maybe<GqlSorCallData>;
|
|
@@ -1560,7 +1662,7 @@ type GqlSorGetSwapPaths = {
|
|
|
1560
1662
|
*/
|
|
1561
1663
|
vaultVersion: Scalars['Int']['output'];
|
|
1562
1664
|
};
|
|
1563
|
-
type GqlSorGetSwapsResponse = {
|
|
1665
|
+
export type GqlSorGetSwapsResponse = {
|
|
1564
1666
|
__typename?: 'GqlSorGetSwapsResponse';
|
|
1565
1667
|
effectivePrice: Scalars['AmountHumanReadable']['output'];
|
|
1566
1668
|
effectivePriceReversed: Scalars['AmountHumanReadable']['output'];
|
|
@@ -1583,7 +1685,7 @@ type GqlSorGetSwapsResponse = {
|
|
|
1583
1685
|
tokenOutAmount: Scalars['AmountHumanReadable']['output'];
|
|
1584
1686
|
};
|
|
1585
1687
|
/** A path of a swap. A swap can have multiple paths. Used as input to execute the swap via b-sdk */
|
|
1586
|
-
type GqlSorPath = {
|
|
1688
|
+
export type GqlSorPath = {
|
|
1587
1689
|
__typename?: 'GqlSorPath';
|
|
1588
1690
|
/** Input amount of this path in scaled form */
|
|
1589
1691
|
inputAmountRaw: Scalars['String']['output'];
|
|
@@ -1604,7 +1706,7 @@ type GqlSorPath = {
|
|
|
1604
1706
|
vaultVersion: Scalars['Int']['output'];
|
|
1605
1707
|
};
|
|
1606
1708
|
/** A single swap step as used for input to the vault to execute a swap */
|
|
1607
|
-
type GqlSorSwap = {
|
|
1709
|
+
export type GqlSorSwap = {
|
|
1608
1710
|
__typename?: 'GqlSorSwap';
|
|
1609
1711
|
/** Amount to be swapped in this step. 0 for chained swap. */
|
|
1610
1712
|
amount: Scalars['String']['output'];
|
|
@@ -1617,14 +1719,14 @@ type GqlSorSwap = {
|
|
|
1617
1719
|
/** UserData used in this swap, generally uses defaults. */
|
|
1618
1720
|
userData: Scalars['String']['output'];
|
|
1619
1721
|
};
|
|
1620
|
-
type GqlSorSwapOptionsInput = {
|
|
1722
|
+
export type GqlSorSwapOptionsInput = {
|
|
1621
1723
|
forceRefresh?: InputMaybe<Scalars['Boolean']['input']>;
|
|
1622
1724
|
maxPools?: InputMaybe<Scalars['Int']['input']>;
|
|
1623
1725
|
queryBatchSwap?: InputMaybe<Scalars['Boolean']['input']>;
|
|
1624
1726
|
timestamp?: InputMaybe<Scalars['Int']['input']>;
|
|
1625
1727
|
};
|
|
1626
1728
|
/** The swap routes including pool information. Used to display by the UI */
|
|
1627
|
-
type GqlSorSwapRoute = {
|
|
1729
|
+
export type GqlSorSwapRoute = {
|
|
1628
1730
|
__typename?: 'GqlSorSwapRoute';
|
|
1629
1731
|
/** The hops this route takes */
|
|
1630
1732
|
hops: Array<GqlSorSwapRouteHop>;
|
|
@@ -1640,7 +1742,7 @@ type GqlSorSwapRoute = {
|
|
|
1640
1742
|
tokenOutAmount: Scalars['AmountHumanReadable']['output'];
|
|
1641
1743
|
};
|
|
1642
1744
|
/** A hop of a route. A route can have many hops meaning it traverses more than one pool. */
|
|
1643
|
-
type GqlSorSwapRouteHop = {
|
|
1745
|
+
export type GqlSorSwapRouteHop = {
|
|
1644
1746
|
__typename?: 'GqlSorSwapRouteHop';
|
|
1645
1747
|
/** The pool entity of this hop. */
|
|
1646
1748
|
pool: GqlPoolMinimal;
|
|
@@ -1655,12 +1757,12 @@ type GqlSorSwapRouteHop = {
|
|
|
1655
1757
|
/** Amount of the tokenOut in human form */
|
|
1656
1758
|
tokenOutAmount: Scalars['AmountHumanReadable']['output'];
|
|
1657
1759
|
};
|
|
1658
|
-
declare enum GqlSorSwapType {
|
|
1760
|
+
export declare enum GqlSorSwapType {
|
|
1659
1761
|
ExactIn = "EXACT_IN",
|
|
1660
1762
|
ExactOut = "EXACT_OUT"
|
|
1661
1763
|
}
|
|
1662
1764
|
/** Inputs for the call data to create the swap transaction. If this input is given, call data is added to the response. */
|
|
1663
|
-
type GqlSwapCallDataInput = {
|
|
1765
|
+
export type GqlSwapCallDataInput = {
|
|
1664
1766
|
/** How long the swap should be valid, provide a timestamp. "999999999999999999" for infinite. Default: infinite */
|
|
1665
1767
|
deadline?: InputMaybe<Scalars['Int']['input']>;
|
|
1666
1768
|
/** Who receives the output amount. */
|
|
@@ -1671,7 +1773,7 @@ type GqlSwapCallDataInput = {
|
|
|
1671
1773
|
slippagePercentage: Scalars['String']['input'];
|
|
1672
1774
|
};
|
|
1673
1775
|
/** Represents a token */
|
|
1674
|
-
type GqlToken = {
|
|
1776
|
+
export type GqlToken = {
|
|
1675
1777
|
__typename?: 'GqlToken';
|
|
1676
1778
|
/** The address of the token */
|
|
1677
1779
|
address: Scalars['Bytes']['output'];
|
|
@@ -1713,27 +1815,18 @@ type GqlToken = {
|
|
|
1713
1815
|
/** The website URL of the token */
|
|
1714
1816
|
websiteUrl?: Maybe<Scalars['String']['output']>;
|
|
1715
1817
|
};
|
|
1716
|
-
type GqlTokenAmountHumanReadable = {
|
|
1818
|
+
export type GqlTokenAmountHumanReadable = {
|
|
1717
1819
|
address: Scalars['Bytes']['input'];
|
|
1718
1820
|
amount: Scalars['AmountHumanReadable']['input'];
|
|
1719
1821
|
};
|
|
1720
|
-
|
|
1721
|
-
__typename?: 'GqlTokenCandlestickChartDataItem';
|
|
1722
|
-
close: Scalars['AmountHumanReadable']['output'];
|
|
1723
|
-
high: Scalars['AmountHumanReadable']['output'];
|
|
1724
|
-
id: Scalars['ID']['output'];
|
|
1725
|
-
low: Scalars['AmountHumanReadable']['output'];
|
|
1726
|
-
open: Scalars['AmountHumanReadable']['output'];
|
|
1727
|
-
timestamp: Scalars['Int']['output'];
|
|
1728
|
-
};
|
|
1729
|
-
declare enum GqlTokenChartDataRange {
|
|
1822
|
+
export declare enum GqlTokenChartDataRange {
|
|
1730
1823
|
NinetyDay = "NINETY_DAY",
|
|
1731
1824
|
OneHundredEightyDay = "ONE_HUNDRED_EIGHTY_DAY",
|
|
1732
1825
|
OneYear = "ONE_YEAR",
|
|
1733
1826
|
SevenDay = "SEVEN_DAY",
|
|
1734
1827
|
ThirtyDay = "THIRTY_DAY"
|
|
1735
1828
|
}
|
|
1736
|
-
type GqlTokenData = {
|
|
1829
|
+
export type GqlTokenData = {
|
|
1737
1830
|
__typename?: 'GqlTokenData';
|
|
1738
1831
|
description?: Maybe<Scalars['String']['output']>;
|
|
1739
1832
|
/** @deprecated Discord URL is no longer supported */
|
|
@@ -1747,7 +1840,7 @@ type GqlTokenData = {
|
|
|
1747
1840
|
websiteUrl?: Maybe<Scalars['String']['output']>;
|
|
1748
1841
|
};
|
|
1749
1842
|
/** Represents additional data for a token */
|
|
1750
|
-
type GqlTokenDynamicData = {
|
|
1843
|
+
export type GqlTokenDynamicData = {
|
|
1751
1844
|
__typename?: 'GqlTokenDynamicData';
|
|
1752
1845
|
/** The all-time high price of the token */
|
|
1753
1846
|
ath: Scalars['Float']['output'];
|
|
@@ -1780,17 +1873,7 @@ type GqlTokenDynamicData = {
|
|
|
1780
1873
|
/** The timestamp when the data was last updated */
|
|
1781
1874
|
updatedAt: Scalars['String']['output'];
|
|
1782
1875
|
};
|
|
1783
|
-
|
|
1784
|
-
type GqlTokenMutationResult = {
|
|
1785
|
-
__typename?: 'GqlTokenMutationResult';
|
|
1786
|
-
/** The chain that was reloaded. */
|
|
1787
|
-
chain: GqlChain;
|
|
1788
|
-
/** The error message */
|
|
1789
|
-
error?: Maybe<Scalars['String']['output']>;
|
|
1790
|
-
/** Whether it was successful or not. */
|
|
1791
|
-
success: Scalars['Boolean']['output'];
|
|
1792
|
-
};
|
|
1793
|
-
type GqlTokenPrice = {
|
|
1876
|
+
export type GqlTokenPrice = {
|
|
1794
1877
|
__typename?: 'GqlTokenPrice';
|
|
1795
1878
|
address: Scalars['Bytes']['output'];
|
|
1796
1879
|
chain: GqlChain;
|
|
@@ -1798,23 +1881,23 @@ type GqlTokenPrice = {
|
|
|
1798
1881
|
updatedAt: Scalars['Int']['output'];
|
|
1799
1882
|
updatedBy?: Maybe<Scalars['String']['output']>;
|
|
1800
1883
|
};
|
|
1801
|
-
type GqlTokenPriceChartDataItem = {
|
|
1884
|
+
export type GqlTokenPriceChartDataItem = {
|
|
1802
1885
|
__typename?: 'GqlTokenPriceChartDataItem';
|
|
1803
1886
|
id: Scalars['ID']['output'];
|
|
1804
1887
|
price: Scalars['AmountHumanReadable']['output'];
|
|
1805
1888
|
timestamp: Scalars['Int']['output'];
|
|
1806
1889
|
};
|
|
1807
|
-
declare enum GqlTokenType {
|
|
1890
|
+
export declare enum GqlTokenType {
|
|
1808
1891
|
Bpt = "BPT",
|
|
1809
1892
|
PhantomBpt = "PHANTOM_BPT",
|
|
1810
1893
|
WhiteListed = "WHITE_LISTED"
|
|
1811
1894
|
}
|
|
1812
|
-
type GqlUserSwapVolumeFilter = {
|
|
1895
|
+
export type GqlUserSwapVolumeFilter = {
|
|
1813
1896
|
poolIdIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
1814
1897
|
tokenInIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
1815
1898
|
tokenOutIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
1816
1899
|
};
|
|
1817
|
-
type GqlUserVaultDeposit = {
|
|
1900
|
+
export type GqlUserVaultDeposit = {
|
|
1818
1901
|
__typename?: 'GqlUserVaultDeposit';
|
|
1819
1902
|
amount: Scalars['String']['output'];
|
|
1820
1903
|
chain: GqlChain;
|
|
@@ -1822,7 +1905,7 @@ type GqlUserVaultDeposit = {
|
|
|
1822
1905
|
vault?: Maybe<GqlRewardVault>;
|
|
1823
1906
|
vaultAddress: Scalars['Bytes']['output'];
|
|
1824
1907
|
};
|
|
1825
|
-
type GqlUserVaultDepositMinimal = {
|
|
1908
|
+
export type GqlUserVaultDepositMinimal = {
|
|
1826
1909
|
__typename?: 'GqlUserVaultDepositMinimal';
|
|
1827
1910
|
amount: Scalars['String']['output'];
|
|
1828
1911
|
chain: GqlChain;
|
|
@@ -1830,14 +1913,14 @@ type GqlUserVaultDepositMinimal = {
|
|
|
1830
1913
|
userAddress: Scalars['Bytes']['output'];
|
|
1831
1914
|
vaultAddress: Scalars['Bytes']['output'];
|
|
1832
1915
|
};
|
|
1833
|
-
declare enum GqlUserVaultDepositOrderBy {
|
|
1916
|
+
export declare enum GqlUserVaultDepositOrderBy {
|
|
1834
1917
|
Amount = "amount"
|
|
1835
1918
|
}
|
|
1836
|
-
declare enum GqlUserVaultDepositOrderDirection {
|
|
1919
|
+
export declare enum GqlUserVaultDepositOrderDirection {
|
|
1837
1920
|
Asc = "asc",
|
|
1838
1921
|
Desc = "desc"
|
|
1839
1922
|
}
|
|
1840
|
-
type GqlValidator = {
|
|
1923
|
+
export type GqlValidator = {
|
|
1841
1924
|
__typename?: 'GqlValidator';
|
|
1842
1925
|
chain: GqlChain;
|
|
1843
1926
|
dynamicData?: Maybe<GqlValidatorDynamicData>;
|
|
@@ -1854,7 +1937,7 @@ type GqlValidator = {
|
|
|
1854
1937
|
rewardAllocator?: Maybe<Scalars['Bytes']['output']>;
|
|
1855
1938
|
valStats?: Maybe<GqlValidatorStats>;
|
|
1856
1939
|
};
|
|
1857
|
-
type GqlValidatorBlockUptime = {
|
|
1940
|
+
export type GqlValidatorBlockUptime = {
|
|
1858
1941
|
__typename?: 'GqlValidatorBlockUptime';
|
|
1859
1942
|
blockNumber: Scalars['Int']['output'];
|
|
1860
1943
|
blockTimestamp: Scalars['Int']['output'];
|
|
@@ -1865,13 +1948,13 @@ type GqlValidatorBlockUptime = {
|
|
|
1865
1948
|
status: GqlValidatorBlockUptimeStatus;
|
|
1866
1949
|
validatorId: Scalars['Bytes']['output'];
|
|
1867
1950
|
};
|
|
1868
|
-
declare enum GqlValidatorBlockUptimeStatus {
|
|
1951
|
+
export declare enum GqlValidatorBlockUptimeStatus {
|
|
1869
1952
|
Inactive = "INACTIVE",
|
|
1870
1953
|
Offline = "OFFLINE",
|
|
1871
1954
|
Proposed = "PROPOSED",
|
|
1872
1955
|
Signed = "SIGNED"
|
|
1873
1956
|
}
|
|
1874
|
-
type GqlValidatorBoost = {
|
|
1957
|
+
export type GqlValidatorBoost = {
|
|
1875
1958
|
__typename?: 'GqlValidatorBoost';
|
|
1876
1959
|
activeBoostAmount: Scalars['String']['output'];
|
|
1877
1960
|
chain: GqlChain;
|
|
@@ -1884,18 +1967,18 @@ type GqlValidatorBoost = {
|
|
|
1884
1967
|
validator?: Maybe<GqlValidatorInList>;
|
|
1885
1968
|
validatorId: Scalars['Bytes']['output'];
|
|
1886
1969
|
};
|
|
1887
|
-
declare enum GqlValidatorBoostOrderBy {
|
|
1970
|
+
export declare enum GqlValidatorBoostOrderBy {
|
|
1888
1971
|
ActiveBoostAmount = "activeBoostAmount",
|
|
1889
1972
|
LatestBlock = "latestBlock",
|
|
1890
1973
|
LatestBlockTime = "latestBlockTime",
|
|
1891
1974
|
QueuedBoostAmount = "queuedBoostAmount",
|
|
1892
1975
|
QueuedDropBoostAmount = "queuedDropBoostAmount"
|
|
1893
1976
|
}
|
|
1894
|
-
declare enum GqlValidatorBoostOrderDirection {
|
|
1977
|
+
export declare enum GqlValidatorBoostOrderDirection {
|
|
1895
1978
|
Asc = "asc",
|
|
1896
1979
|
Desc = "desc"
|
|
1897
1980
|
}
|
|
1898
|
-
type GqlValidatorDynamicData = {
|
|
1981
|
+
export type GqlValidatorDynamicData = {
|
|
1899
1982
|
__typename?: 'GqlValidatorDynamicData';
|
|
1900
1983
|
activeBoostAmount: Scalars['String']['output'];
|
|
1901
1984
|
activeBoostAmountRank: Scalars['Int']['output'];
|
|
@@ -1932,7 +2015,7 @@ type GqlValidatorDynamicData = {
|
|
|
1932
2015
|
validator?: Maybe<GqlValidator>;
|
|
1933
2016
|
validatorId: Scalars['Bytes']['output'];
|
|
1934
2017
|
};
|
|
1935
|
-
type GqlValidatorFilter = {
|
|
2018
|
+
export type GqlValidatorFilter = {
|
|
1936
2019
|
OR?: InputMaybe<Array<GqlValidatorFilter>>;
|
|
1937
2020
|
chainIn?: InputMaybe<Array<GqlChain>>;
|
|
1938
2021
|
chainNotIn?: InputMaybe<Array<GqlChain>>;
|
|
@@ -1947,7 +2030,7 @@ type GqlValidatorFilter = {
|
|
|
1947
2030
|
rewardAllocatorNotIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
1948
2031
|
vaultAddress?: InputMaybe<Scalars['String']['input']>;
|
|
1949
2032
|
};
|
|
1950
|
-
type GqlValidatorInList = {
|
|
2033
|
+
export type GqlValidatorInList = {
|
|
1951
2034
|
__typename?: 'GqlValidatorInList';
|
|
1952
2035
|
dynamicData?: Maybe<GqlValidatorDynamicData>;
|
|
1953
2036
|
id: Scalars['Bytes']['output'];
|
|
@@ -1956,7 +2039,7 @@ type GqlValidatorInList = {
|
|
|
1956
2039
|
pubkey: Scalars['Bytes']['output'];
|
|
1957
2040
|
rewardAllocator?: Maybe<Scalars['Bytes']['output']>;
|
|
1958
2041
|
};
|
|
1959
|
-
type GqlValidatorIncentive = GqlIncentive & {
|
|
2042
|
+
export type GqlValidatorIncentive = GqlIncentive & {
|
|
1960
2043
|
__typename?: 'GqlValidatorIncentive';
|
|
1961
2044
|
chain: GqlChain;
|
|
1962
2045
|
incentiveRate: Scalars['String']['output'];
|
|
@@ -1967,7 +2050,7 @@ type GqlValidatorIncentive = GqlIncentive & {
|
|
|
1967
2050
|
tokenAddress: Scalars['Bytes']['output'];
|
|
1968
2051
|
validatorId: Scalars['Bytes']['output'];
|
|
1969
2052
|
};
|
|
1970
|
-
type GqlValidatorMetadata = {
|
|
2053
|
+
export type GqlValidatorMetadata = {
|
|
1971
2054
|
__typename?: 'GqlValidatorMetadata';
|
|
1972
2055
|
chain: GqlChain;
|
|
1973
2056
|
description: Scalars['String']['output'];
|
|
@@ -1977,7 +2060,7 @@ type GqlValidatorMetadata = {
|
|
|
1977
2060
|
validatorId: Scalars['Bytes']['output'];
|
|
1978
2061
|
website: Scalars['String']['output'];
|
|
1979
2062
|
};
|
|
1980
|
-
declare enum GqlValidatorOrderBy {
|
|
2063
|
+
export declare enum GqlValidatorOrderBy {
|
|
1981
2064
|
ActiveBoostAmount = "activeBoostAmount",
|
|
1982
2065
|
AllTimeDistributedBgtAmount = "allTimeDistributedBGTAmount",
|
|
1983
2066
|
AllTimeEarnedBgtAmount = "allTimeEarnedBGTAmount",
|
|
@@ -1995,11 +2078,11 @@ declare enum GqlValidatorOrderBy {
|
|
|
1995
2078
|
UsersActiveBoostCount = "usersActiveBoostCount",
|
|
1996
2079
|
UsersQueuedBoostCount = "usersQueuedBoostCount"
|
|
1997
2080
|
}
|
|
1998
|
-
declare enum GqlValidatorOrderDirection {
|
|
2081
|
+
export declare enum GqlValidatorOrderDirection {
|
|
1999
2082
|
Asc = "asc",
|
|
2000
2083
|
Desc = "desc"
|
|
2001
2084
|
}
|
|
2002
|
-
type GqlValidatorRewardAllocationWeight = {
|
|
2085
|
+
export type GqlValidatorRewardAllocationWeight = {
|
|
2003
2086
|
__typename?: 'GqlValidatorRewardAllocationWeight';
|
|
2004
2087
|
chain: GqlChain;
|
|
2005
2088
|
/**
|
|
@@ -2020,19 +2103,19 @@ type GqlValidatorRewardAllocationWeight = {
|
|
|
2020
2103
|
validator?: Maybe<GqlValidator>;
|
|
2021
2104
|
validatorId: Scalars['Bytes']['output'];
|
|
2022
2105
|
};
|
|
2023
|
-
type GqlValidatorStats = {
|
|
2106
|
+
export type GqlValidatorStats = {
|
|
2024
2107
|
__typename?: 'GqlValidatorStats';
|
|
2025
2108
|
activeBoostAmountPercentage: Scalars['String']['output'];
|
|
2026
2109
|
stakedBeraAmountPercentage: Scalars['String']['output'];
|
|
2027
2110
|
};
|
|
2028
|
-
declare enum GqlVaultSnapshotDataRange {
|
|
2111
|
+
export declare enum GqlVaultSnapshotDataRange {
|
|
2029
2112
|
NinetyDays = "NINETY_DAYS",
|
|
2030
2113
|
SevenDays = "SEVEN_DAYS",
|
|
2031
2114
|
SixtyDays = "SIXTY_DAYS",
|
|
2032
2115
|
ThirtyDays = "THIRTY_DAYS"
|
|
2033
2116
|
}
|
|
2034
2117
|
/** Hook data */
|
|
2035
|
-
type Hook = {
|
|
2118
|
+
export type Hook = {
|
|
2036
2119
|
__typename?: 'Hook';
|
|
2037
2120
|
address: Scalars['Bytes']['output'];
|
|
2038
2121
|
chain: GqlChain;
|
|
@@ -2053,43 +2136,43 @@ type Hook = {
|
|
|
2053
2136
|
shouldCallComputeDynamicSwapFee: Scalars['Boolean']['output'];
|
|
2054
2137
|
};
|
|
2055
2138
|
/** Collection of hook specific data. Percentage format is 0.01 -> 0.01%. */
|
|
2056
|
-
type HookData = {
|
|
2139
|
+
export type HookData = {
|
|
2057
2140
|
__typename?: 'HookData';
|
|
2058
2141
|
addLiquidityFeePercentage?: Maybe<Scalars['String']['output']>;
|
|
2059
2142
|
removeLiquidityFeePercentage?: Maybe<Scalars['String']['output']>;
|
|
2060
2143
|
swapFeePercentage?: Maybe<Scalars['String']['output']>;
|
|
2061
2144
|
};
|
|
2062
|
-
type PaginatedRewardVaultIncentivesResponse = {
|
|
2145
|
+
export type PaginatedRewardVaultIncentivesResponse = {
|
|
2063
2146
|
__typename?: 'PaginatedRewardVaultIncentivesResponse';
|
|
2064
2147
|
incentives: Array<GqlRewardVaultIncentive>;
|
|
2065
2148
|
pagination: GqlPagination;
|
|
2066
2149
|
};
|
|
2067
|
-
type PaginatedRewardVaultsResponse = {
|
|
2150
|
+
export type PaginatedRewardVaultsResponse = {
|
|
2068
2151
|
__typename?: 'PaginatedRewardVaultsResponse';
|
|
2069
2152
|
pagination: GqlPagination;
|
|
2070
2153
|
vaults: Array<GqlRewardVault>;
|
|
2071
2154
|
};
|
|
2072
|
-
type PaginatedUserVaultDepositsResponse = {
|
|
2155
|
+
export type PaginatedUserVaultDepositsResponse = {
|
|
2073
2156
|
__typename?: 'PaginatedUserVaultDepositsResponse';
|
|
2074
2157
|
deposits: Array<GqlUserVaultDeposit>;
|
|
2075
2158
|
pagination: GqlPagination;
|
|
2076
2159
|
};
|
|
2077
|
-
type PaginatedValidatorBlockUptimesResponse = {
|
|
2160
|
+
export type PaginatedValidatorBlockUptimesResponse = {
|
|
2078
2161
|
__typename?: 'PaginatedValidatorBlockUptimesResponse';
|
|
2079
2162
|
pagination: GqlPagination;
|
|
2080
2163
|
uptimes: Array<GqlValidatorBlockUptime>;
|
|
2081
2164
|
};
|
|
2082
|
-
type PaginatedValidatorBoostsResponse = {
|
|
2165
|
+
export type PaginatedValidatorBoostsResponse = {
|
|
2083
2166
|
__typename?: 'PaginatedValidatorBoostsResponse';
|
|
2084
2167
|
boosts: Array<GqlValidatorBoost>;
|
|
2085
2168
|
pagination: GqlPagination;
|
|
2086
2169
|
};
|
|
2087
|
-
type PaginatedValidatorsResponse = {
|
|
2170
|
+
export type PaginatedValidatorsResponse = {
|
|
2088
2171
|
__typename?: 'PaginatedValidatorsResponse';
|
|
2089
2172
|
pagination: GqlPagination;
|
|
2090
2173
|
validators: Array<GqlValidator>;
|
|
2091
2174
|
};
|
|
2092
|
-
type Query = {
|
|
2175
|
+
export type Query = {
|
|
2093
2176
|
__typename?: 'Query';
|
|
2094
2177
|
bendVault?: Maybe<BendVaultResponse>;
|
|
2095
2178
|
bendVaults: Array<BendVaultResponse>;
|
|
@@ -2101,8 +2184,6 @@ type Query = {
|
|
|
2101
2184
|
blocksGetBlocksPerSecond: Scalars['Float']['output'];
|
|
2102
2185
|
/** @deprecated This query will be removed at the end of April 2026. */
|
|
2103
2186
|
blocksGetBlocksPerYear: Scalars['Float']['output'];
|
|
2104
|
-
/** Returns list of hooks. */
|
|
2105
|
-
hooks?: Maybe<Array<Hook>>;
|
|
2106
2187
|
latestSyncedBlocks: GqlLatestSyncedBlocks;
|
|
2107
2188
|
polGetActiveIncentives: PaginatedRewardVaultIncentivesResponse;
|
|
2108
2189
|
polGetGlobalInfo?: Maybe<GqlGlobalInfo>;
|
|
@@ -2158,13 +2239,10 @@ type Query = {
|
|
|
2158
2239
|
/** Returns dynamic data of a set of tokens such as price, market cap, etc. */
|
|
2159
2240
|
tokenGetTokensDynamicData: Array<GqlTokenDynamicData>;
|
|
2160
2241
|
};
|
|
2161
|
-
type QueryBendVaultArgs = {
|
|
2242
|
+
export type QueryBendVaultArgs = {
|
|
2162
2243
|
vaultAddress: Scalars['Bytes']['input'];
|
|
2163
2244
|
};
|
|
2164
|
-
type
|
|
2165
|
-
chain?: InputMaybe<GqlChain>;
|
|
2166
|
-
};
|
|
2167
|
-
type QueryPolGetActiveIncentivesArgs = {
|
|
2245
|
+
export type QueryPolGetActiveIncentivesArgs = {
|
|
2168
2246
|
chain: GqlChain;
|
|
2169
2247
|
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2170
2248
|
orderBy?: InputMaybe<GqlRewardVaultIncentiveOrderBy>;
|
|
@@ -2172,20 +2250,20 @@ type QueryPolGetActiveIncentivesArgs = {
|
|
|
2172
2250
|
search?: InputMaybe<Scalars['String']['input']>;
|
|
2173
2251
|
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
2174
2252
|
};
|
|
2175
|
-
type QueryPolGetGlobalInfoArgs = {
|
|
2253
|
+
export type QueryPolGetGlobalInfoArgs = {
|
|
2176
2254
|
chain: GqlChain;
|
|
2177
2255
|
};
|
|
2178
|
-
type QueryPolGetRewardVaultArgs = {
|
|
2256
|
+
export type QueryPolGetRewardVaultArgs = {
|
|
2179
2257
|
chain: GqlChain;
|
|
2180
2258
|
vaultAddress: Scalars['String']['input'];
|
|
2181
2259
|
};
|
|
2182
|
-
type QueryPolGetRewardVaultSnapshotsArgs = {
|
|
2260
|
+
export type QueryPolGetRewardVaultSnapshotsArgs = {
|
|
2183
2261
|
chain: GqlChain;
|
|
2184
2262
|
range?: InputMaybe<GqlRewardVaultSnapshotDataRange>;
|
|
2185
2263
|
resolution?: InputMaybe<GqlRewardVaultSnapshotResolution>;
|
|
2186
2264
|
vaultAddress: Scalars['String']['input'];
|
|
2187
2265
|
};
|
|
2188
|
-
type QueryPolGetRewardVaultsArgs = {
|
|
2266
|
+
export type QueryPolGetRewardVaultsArgs = {
|
|
2189
2267
|
chain?: InputMaybe<GqlChain>;
|
|
2190
2268
|
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2191
2269
|
orderBy?: InputMaybe<GqlRewardVaultOrderBy>;
|
|
@@ -2194,20 +2272,20 @@ type QueryPolGetRewardVaultsArgs = {
|
|
|
2194
2272
|
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
2195
2273
|
where?: InputMaybe<GqlRewardVaultFilter>;
|
|
2196
2274
|
};
|
|
2197
|
-
type QueryPolGetSWberaVaultMetadataArgs = {
|
|
2275
|
+
export type QueryPolGetSWberaVaultMetadataArgs = {
|
|
2198
2276
|
chain: GqlChain;
|
|
2199
2277
|
resolution?: InputMaybe<GqlSWberaVaultMetadataResolution>;
|
|
2200
2278
|
};
|
|
2201
|
-
type QueryPolGetSWberaVaultSnapshotsArgs = {
|
|
2279
|
+
export type QueryPolGetSWberaVaultSnapshotsArgs = {
|
|
2202
2280
|
chain: GqlChain;
|
|
2203
2281
|
range?: InputMaybe<GqlVaultSnapshotDataRange>;
|
|
2204
2282
|
};
|
|
2205
|
-
type QueryPolGetTopVaultDepositsArgs = {
|
|
2283
|
+
export type QueryPolGetTopVaultDepositsArgs = {
|
|
2206
2284
|
chain: GqlChain;
|
|
2207
2285
|
top?: InputMaybe<Scalars['Int']['input']>;
|
|
2208
2286
|
vaultAddress: Scalars['String']['input'];
|
|
2209
2287
|
};
|
|
2210
|
-
type QueryPolGetUserVaultDepositsArgs = {
|
|
2288
|
+
export type QueryPolGetUserVaultDepositsArgs = {
|
|
2211
2289
|
chain: GqlChain;
|
|
2212
2290
|
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2213
2291
|
orderBy?: InputMaybe<GqlUserVaultDepositOrderBy>;
|
|
@@ -2215,17 +2293,17 @@ type QueryPolGetUserVaultDepositsArgs = {
|
|
|
2215
2293
|
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
2216
2294
|
userAddress: Scalars['String']['input'];
|
|
2217
2295
|
};
|
|
2218
|
-
type QueryPolGetValidatorArgs = {
|
|
2296
|
+
export type QueryPolGetValidatorArgs = {
|
|
2219
2297
|
chain: GqlChain;
|
|
2220
2298
|
operator?: InputMaybe<Scalars['String']['input']>;
|
|
2221
2299
|
validatorId?: InputMaybe<Scalars['String']['input']>;
|
|
2222
2300
|
validatorPubkey?: InputMaybe<Scalars['String']['input']>;
|
|
2223
2301
|
};
|
|
2224
|
-
type QueryPolGetValidatorBlockUptimesArgs = {
|
|
2302
|
+
export type QueryPolGetValidatorBlockUptimesArgs = {
|
|
2225
2303
|
chain: GqlChain;
|
|
2226
2304
|
validatorId: Scalars['String']['input'];
|
|
2227
2305
|
};
|
|
2228
|
-
type QueryPolGetValidatorBoostsArgs = {
|
|
2306
|
+
export type QueryPolGetValidatorBoostsArgs = {
|
|
2229
2307
|
chain: GqlChain;
|
|
2230
2308
|
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2231
2309
|
orderBy?: InputMaybe<GqlValidatorBoostOrderBy>;
|
|
@@ -2233,7 +2311,7 @@ type QueryPolGetValidatorBoostsArgs = {
|
|
|
2233
2311
|
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
2234
2312
|
userAddress: Scalars['String']['input'];
|
|
2235
2313
|
};
|
|
2236
|
-
type QueryPolGetValidatorsArgs = {
|
|
2314
|
+
export type QueryPolGetValidatorsArgs = {
|
|
2237
2315
|
chain?: InputMaybe<GqlChain>;
|
|
2238
2316
|
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2239
2317
|
orderBy?: InputMaybe<GqlValidatorOrderBy>;
|
|
@@ -2242,31 +2320,31 @@ type QueryPolGetValidatorsArgs = {
|
|
|
2242
2320
|
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
2243
2321
|
where?: InputMaybe<GqlValidatorFilter>;
|
|
2244
2322
|
};
|
|
2245
|
-
type QueryPoolEventsArgs = {
|
|
2323
|
+
export type QueryPoolEventsArgs = {
|
|
2246
2324
|
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2247
2325
|
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
2248
2326
|
where?: InputMaybe<GqlPoolEventsFilter>;
|
|
2249
2327
|
};
|
|
2250
|
-
type QueryPoolGetAggregatorPoolsArgs = {
|
|
2328
|
+
export type QueryPoolGetAggregatorPoolsArgs = {
|
|
2251
2329
|
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2252
2330
|
orderBy?: InputMaybe<GqlPoolOrderBy>;
|
|
2253
2331
|
orderDirection?: InputMaybe<GqlPoolOrderDirection>;
|
|
2254
2332
|
skip?: InputMaybe<Scalars['Int']['input']>;
|
|
2255
2333
|
where?: InputMaybe<GqlPoolFilter>;
|
|
2256
2334
|
};
|
|
2257
|
-
type QueryPoolGetEventsArgs = {
|
|
2335
|
+
export type QueryPoolGetEventsArgs = {
|
|
2258
2336
|
chain: GqlChain;
|
|
2259
2337
|
poolId: Scalars['String']['input'];
|
|
2260
2338
|
range: GqlPoolEventsDataRange;
|
|
2261
2339
|
typeIn: Array<GqlPoolEventType>;
|
|
2262
2340
|
userAddress?: InputMaybe<Scalars['String']['input']>;
|
|
2263
2341
|
};
|
|
2264
|
-
type QueryPoolGetPoolArgs = {
|
|
2342
|
+
export type QueryPoolGetPoolArgs = {
|
|
2265
2343
|
chain?: InputMaybe<GqlChain>;
|
|
2266
2344
|
id: Scalars['String']['input'];
|
|
2267
2345
|
userAddress?: InputMaybe<Scalars['String']['input']>;
|
|
2268
2346
|
};
|
|
2269
|
-
type QueryPoolGetPoolsArgs = {
|
|
2347
|
+
export type QueryPoolGetPoolsArgs = {
|
|
2270
2348
|
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2271
2349
|
orderBy?: InputMaybe<GqlPoolOrderBy>;
|
|
2272
2350
|
orderDirection?: InputMaybe<GqlPoolOrderDirection>;
|
|
@@ -2274,7 +2352,7 @@ type QueryPoolGetPoolsArgs = {
|
|
|
2274
2352
|
textSearch?: InputMaybe<Scalars['String']['input']>;
|
|
2275
2353
|
where?: InputMaybe<GqlPoolFilter>;
|
|
2276
2354
|
};
|
|
2277
|
-
type QueryPoolGetPoolsCountArgs = {
|
|
2355
|
+
export type QueryPoolGetPoolsCountArgs = {
|
|
2278
2356
|
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2279
2357
|
orderBy?: InputMaybe<GqlPoolOrderBy>;
|
|
2280
2358
|
orderDirection?: InputMaybe<GqlPoolOrderDirection>;
|
|
@@ -2282,18 +2360,18 @@ type QueryPoolGetPoolsCountArgs = {
|
|
|
2282
2360
|
textSearch?: InputMaybe<Scalars['String']['input']>;
|
|
2283
2361
|
where?: InputMaybe<GqlPoolFilter>;
|
|
2284
2362
|
};
|
|
2285
|
-
type QueryPoolGetSnapshotsArgs = {
|
|
2363
|
+
export type QueryPoolGetSnapshotsArgs = {
|
|
2286
2364
|
chain?: InputMaybe<GqlChain>;
|
|
2287
2365
|
id: Scalars['String']['input'];
|
|
2288
2366
|
range: GqlPoolSnapshotDataRange;
|
|
2289
2367
|
};
|
|
2290
|
-
type QueryProtocolMetricsAggregatedArgs = {
|
|
2368
|
+
export type QueryProtocolMetricsAggregatedArgs = {
|
|
2291
2369
|
chains?: InputMaybe<Array<GqlChain>>;
|
|
2292
2370
|
};
|
|
2293
|
-
type QueryProtocolMetricsChainArgs = {
|
|
2371
|
+
export type QueryProtocolMetricsChainArgs = {
|
|
2294
2372
|
chain?: InputMaybe<GqlChain>;
|
|
2295
2373
|
};
|
|
2296
|
-
type QuerySorGetSwapPathsArgs = {
|
|
2374
|
+
export type QuerySorGetSwapPathsArgs = {
|
|
2297
2375
|
callDataInput?: InputMaybe<GqlSwapCallDataInput>;
|
|
2298
2376
|
chain: GqlChain;
|
|
2299
2377
|
queryBatchSwap?: InputMaybe<Scalars['Boolean']['input']>;
|
|
@@ -2303,7 +2381,7 @@ type QuerySorGetSwapPathsArgs = {
|
|
|
2303
2381
|
tokenOut: Scalars['String']['input'];
|
|
2304
2382
|
useProtocolVersion?: InputMaybe<Scalars['Int']['input']>;
|
|
2305
2383
|
};
|
|
2306
|
-
type QuerySorGetSwapsArgs = {
|
|
2384
|
+
export type QuerySorGetSwapsArgs = {
|
|
2307
2385
|
chain?: InputMaybe<GqlChain>;
|
|
2308
2386
|
swapAmount: Scalars['BigDecimal']['input'];
|
|
2309
2387
|
swapOptions: GqlSorSwapOptionsInput;
|
|
@@ -2311,47 +2389,47 @@ type QuerySorGetSwapsArgs = {
|
|
|
2311
2389
|
tokenIn: Scalars['String']['input'];
|
|
2312
2390
|
tokenOut: Scalars['String']['input'];
|
|
2313
2391
|
};
|
|
2314
|
-
type QueryTokenGetCurrentPriceArgs = {
|
|
2392
|
+
export type QueryTokenGetCurrentPriceArgs = {
|
|
2315
2393
|
address: Scalars['String']['input'];
|
|
2316
2394
|
chain: GqlChain;
|
|
2317
2395
|
};
|
|
2318
|
-
type QueryTokenGetCurrentPricesArgs = {
|
|
2396
|
+
export type QueryTokenGetCurrentPricesArgs = {
|
|
2319
2397
|
addressIn: Array<Scalars['String']['input']>;
|
|
2320
2398
|
chains: Array<GqlChain>;
|
|
2321
2399
|
};
|
|
2322
|
-
type QueryTokenGetHistoricalPricesArgs = {
|
|
2400
|
+
export type QueryTokenGetHistoricalPricesArgs = {
|
|
2323
2401
|
addresses: Array<Scalars['String']['input']>;
|
|
2324
2402
|
chain: GqlChain;
|
|
2325
2403
|
range: GqlTokenChartDataRange;
|
|
2326
2404
|
};
|
|
2327
|
-
type QueryTokenGetTokenArgs = {
|
|
2405
|
+
export type QueryTokenGetTokenArgs = {
|
|
2328
2406
|
address: Scalars['String']['input'];
|
|
2329
2407
|
chain: GqlChain;
|
|
2330
2408
|
};
|
|
2331
|
-
type QueryTokenGetTokenDynamicDataArgs = {
|
|
2409
|
+
export type QueryTokenGetTokenDynamicDataArgs = {
|
|
2332
2410
|
address: Scalars['String']['input'];
|
|
2333
2411
|
chain?: InputMaybe<GqlChain>;
|
|
2334
2412
|
};
|
|
2335
|
-
type QueryTokenGetTokensArgs = {
|
|
2413
|
+
export type QueryTokenGetTokensArgs = {
|
|
2336
2414
|
addressIn?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
2337
2415
|
chains: Array<GqlChain>;
|
|
2338
2416
|
};
|
|
2339
|
-
type QueryTokenGetTokensDynamicDataArgs = {
|
|
2417
|
+
export type QueryTokenGetTokensDynamicDataArgs = {
|
|
2340
2418
|
addresses: Array<Scalars['String']['input']>;
|
|
2341
2419
|
chain?: InputMaybe<GqlChain>;
|
|
2342
2420
|
};
|
|
2343
|
-
type Token = {
|
|
2421
|
+
export type Token = {
|
|
2344
2422
|
__typename?: 'Token';
|
|
2345
2423
|
address: Scalars['Bytes']['output'];
|
|
2346
2424
|
decimals: Scalars['Int']['output'];
|
|
2347
2425
|
};
|
|
2348
|
-
type UserBalanceFragment = {
|
|
2426
|
+
export type UserBalanceFragment = {
|
|
2349
2427
|
__typename?: 'GqlPoolUserBalance';
|
|
2350
2428
|
totalBalanceUsd: number;
|
|
2351
2429
|
walletBalance: any;
|
|
2352
2430
|
walletBalanceUsd: number;
|
|
2353
2431
|
};
|
|
2354
|
-
type RewardVaultFragment = {
|
|
2432
|
+
export type RewardVaultFragment = {
|
|
2355
2433
|
__typename?: 'GqlRewardVault';
|
|
2356
2434
|
isVaultWhitelisted: boolean;
|
|
2357
2435
|
vaultAddress: `0x${string}`;
|
|
@@ -2363,7 +2441,7 @@ type RewardVaultFragment = {
|
|
|
2363
2441
|
rewardCapturePercentage: number;
|
|
2364
2442
|
} | null;
|
|
2365
2443
|
};
|
|
2366
|
-
type DynamicDataFragment = {
|
|
2444
|
+
export type DynamicDataFragment = {
|
|
2367
2445
|
__typename?: 'GqlPoolDynamicData';
|
|
2368
2446
|
totalShares: string;
|
|
2369
2447
|
fees24h: string;
|
|
@@ -2379,7 +2457,7 @@ type DynamicDataFragment = {
|
|
|
2379
2457
|
id: string;
|
|
2380
2458
|
}>;
|
|
2381
2459
|
};
|
|
2382
|
-
type MinimalPoolInListFragment = {
|
|
2460
|
+
export type MinimalPoolInListFragment = {
|
|
2383
2461
|
__typename?: 'GqlPoolMinimal';
|
|
2384
2462
|
id: string;
|
|
2385
2463
|
name: string;
|
|
@@ -2821,8 +2899,8 @@ type MinimalPool_GqlPoolWeighted_Fragment = {
|
|
|
2821
2899
|
} | null;
|
|
2822
2900
|
} | null;
|
|
2823
2901
|
};
|
|
2824
|
-
type MinimalPoolFragment = MinimalPool_GqlPoolComposableStable_Fragment | MinimalPool_GqlPoolElement_Fragment | MinimalPool_GqlPoolFx_Fragment | MinimalPool_GqlPoolGyro_Fragment | MinimalPool_GqlPoolLiquidityBootstrapping_Fragment | MinimalPool_GqlPoolMetaStable_Fragment | MinimalPool_GqlPoolStable_Fragment | MinimalPool_GqlPoolWeighted_Fragment;
|
|
2825
|
-
type GetPoolsQueryVariables = Exact<{
|
|
2902
|
+
export type MinimalPoolFragment = MinimalPool_GqlPoolComposableStable_Fragment | MinimalPool_GqlPoolElement_Fragment | MinimalPool_GqlPoolFx_Fragment | MinimalPool_GqlPoolGyro_Fragment | MinimalPool_GqlPoolLiquidityBootstrapping_Fragment | MinimalPool_GqlPoolMetaStable_Fragment | MinimalPool_GqlPoolStable_Fragment | MinimalPool_GqlPoolWeighted_Fragment;
|
|
2903
|
+
export type GetPoolsQueryVariables = Exact<{
|
|
2826
2904
|
textSearch?: InputMaybe<Scalars['String']['input']>;
|
|
2827
2905
|
first?: InputMaybe<Scalars['Int']['input']>;
|
|
2828
2906
|
userAddress?: InputMaybe<Scalars['String']['input']>;
|
|
@@ -2832,7 +2910,7 @@ type GetPoolsQueryVariables = Exact<{
|
|
|
2832
2910
|
orderDirection?: InputMaybe<GqlPoolOrderDirection>;
|
|
2833
2911
|
blacklistedPoolIds?: InputMaybe<Array<Scalars['String']['input']> | Scalars['String']['input']>;
|
|
2834
2912
|
}>;
|
|
2835
|
-
type GetPoolsQuery = {
|
|
2913
|
+
export type GetPoolsQuery = {
|
|
2836
2914
|
__typename?: 'Query';
|
|
2837
2915
|
count: number;
|
|
2838
2916
|
poolGetPools: Array<{
|
|
@@ -2886,12 +2964,12 @@ type GetPoolsQuery = {
|
|
|
2886
2964
|
} | null;
|
|
2887
2965
|
}>;
|
|
2888
2966
|
};
|
|
2889
|
-
type GetPoolQueryVariables = Exact<{
|
|
2967
|
+
export type GetPoolQueryVariables = Exact<{
|
|
2890
2968
|
id: Scalars['String']['input'];
|
|
2891
2969
|
userAddress?: InputMaybe<Scalars['String']['input']>;
|
|
2892
2970
|
chain: GqlChain;
|
|
2893
2971
|
}>;
|
|
2894
|
-
type GetPoolQuery = {
|
|
2972
|
+
export type GetPoolQuery = {
|
|
2895
2973
|
__typename?: 'Query';
|
|
2896
2974
|
poolGetPool: {
|
|
2897
2975
|
__typename?: 'GqlPoolComposableStable';
|
|
@@ -3279,7 +3357,7 @@ type GetPoolQuery = {
|
|
|
3279
3357
|
} | null;
|
|
3280
3358
|
};
|
|
3281
3359
|
};
|
|
3282
|
-
type PoolHistoricalDataFragment = {
|
|
3360
|
+
export type PoolHistoricalDataFragment = {
|
|
3283
3361
|
__typename?: 'GqlPoolSnapshot';
|
|
3284
3362
|
id: string;
|
|
3285
3363
|
volume24h: string;
|
|
@@ -3289,11 +3367,11 @@ type PoolHistoricalDataFragment = {
|
|
|
3289
3367
|
fees24h: string;
|
|
3290
3368
|
totalSwapFee: string;
|
|
3291
3369
|
};
|
|
3292
|
-
type GetPoolHistoricalDataQueryVariables = Exact<{
|
|
3370
|
+
export type GetPoolHistoricalDataQueryVariables = Exact<{
|
|
3293
3371
|
poolId: Scalars['String']['input'];
|
|
3294
3372
|
chain: GqlChain;
|
|
3295
3373
|
}>;
|
|
3296
|
-
type GetPoolHistoricalDataQuery = {
|
|
3374
|
+
export type GetPoolHistoricalDataQuery = {
|
|
3297
3375
|
__typename?: 'Query';
|
|
3298
3376
|
poolGetSnapshots: Array<{
|
|
3299
3377
|
__typename?: 'GqlPoolSnapshot';
|
|
@@ -3306,7 +3384,7 @@ type GetPoolHistoricalDataQuery = {
|
|
|
3306
3384
|
totalSwapFee: string;
|
|
3307
3385
|
}>;
|
|
3308
3386
|
};
|
|
3309
|
-
type GqlPoolSwapEventCowAmmFragment = {
|
|
3387
|
+
export type GqlPoolSwapEventCowAmmFragment = {
|
|
3310
3388
|
__typename?: 'GqlPoolSwapEventCowAmm';
|
|
3311
3389
|
tokenIn: {
|
|
3312
3390
|
__typename?: 'GqlPoolEventAmount';
|
|
@@ -3319,7 +3397,7 @@ type GqlPoolSwapEventCowAmmFragment = {
|
|
|
3319
3397
|
amount: string;
|
|
3320
3398
|
};
|
|
3321
3399
|
};
|
|
3322
|
-
type GqlPoolSwapEventV3Fragment = {
|
|
3400
|
+
export type GqlPoolSwapEventV3Fragment = {
|
|
3323
3401
|
__typename?: 'GqlPoolSwapEventV3';
|
|
3324
3402
|
tokenIn: {
|
|
3325
3403
|
__typename?: 'GqlPoolEventAmount';
|
|
@@ -3332,7 +3410,7 @@ type GqlPoolSwapEventV3Fragment = {
|
|
|
3332
3410
|
amount: string;
|
|
3333
3411
|
};
|
|
3334
3412
|
};
|
|
3335
|
-
type GqlPoolAddRemoveEventV3Fragment = {
|
|
3413
|
+
export type GqlPoolAddRemoveEventV3Fragment = {
|
|
3336
3414
|
__typename?: 'GqlPoolAddRemoveEventV3';
|
|
3337
3415
|
tokens: Array<{
|
|
3338
3416
|
__typename?: 'GqlPoolEventAmount';
|
|
@@ -3392,13 +3470,13 @@ type PoolEvent_GqlPoolSwapEventV3_Fragment = {
|
|
|
3392
3470
|
amount: string;
|
|
3393
3471
|
};
|
|
3394
3472
|
};
|
|
3395
|
-
type PoolEventFragment = PoolEvent_GqlPoolAddRemoveEventV3_Fragment | PoolEvent_GqlPoolSwapEventCowAmm_Fragment | PoolEvent_GqlPoolSwapEventV3_Fragment;
|
|
3396
|
-
type GetPoolEventsQueryVariables = Exact<{
|
|
3473
|
+
export type PoolEventFragment = PoolEvent_GqlPoolAddRemoveEventV3_Fragment | PoolEvent_GqlPoolSwapEventCowAmm_Fragment | PoolEvent_GqlPoolSwapEventV3_Fragment;
|
|
3474
|
+
export type GetPoolEventsQueryVariables = Exact<{
|
|
3397
3475
|
poolId: Scalars['String']['input'];
|
|
3398
3476
|
typeIn: Array<GqlPoolEventType> | GqlPoolEventType;
|
|
3399
3477
|
chain: GqlChain;
|
|
3400
3478
|
}>;
|
|
3401
|
-
type GetPoolEventsQuery = {
|
|
3479
|
+
export type GetPoolEventsQuery = {
|
|
3402
3480
|
__typename?: 'Query';
|
|
3403
3481
|
poolGetEvents: Array<{
|
|
3404
3482
|
__typename?: 'GqlPoolAddRemoveEventV3';
|
|
@@ -3451,11 +3529,11 @@ type GetPoolEventsQuery = {
|
|
|
3451
3529
|
};
|
|
3452
3530
|
}>;
|
|
3453
3531
|
};
|
|
3454
|
-
type GetTokenCurrentPricesQueryVariables = Exact<{
|
|
3532
|
+
export type GetTokenCurrentPricesQueryVariables = Exact<{
|
|
3455
3533
|
chains: Array<GqlChain> | GqlChain;
|
|
3456
3534
|
addressIn: Array<Scalars['String']['input']> | Scalars['String']['input'];
|
|
3457
3535
|
}>;
|
|
3458
|
-
type GetTokenCurrentPricesQuery = {
|
|
3536
|
+
export type GetTokenCurrentPricesQuery = {
|
|
3459
3537
|
__typename?: 'Query';
|
|
3460
3538
|
tokenGetCurrentPrices: Array<{
|
|
3461
3539
|
__typename?: 'GqlTokenPrice';
|
|
@@ -3466,10 +3544,10 @@ type GetTokenCurrentPricesQuery = {
|
|
|
3466
3544
|
updatedBy?: string | null;
|
|
3467
3545
|
}>;
|
|
3468
3546
|
};
|
|
3469
|
-
type GetGlobalLiquidityAndSwapVolumeQueryVariables = Exact<{
|
|
3547
|
+
export type GetGlobalLiquidityAndSwapVolumeQueryVariables = Exact<{
|
|
3470
3548
|
chain: GqlChain;
|
|
3471
3549
|
}>;
|
|
3472
|
-
type GetGlobalLiquidityAndSwapVolumeQuery = {
|
|
3550
|
+
export type GetGlobalLiquidityAndSwapVolumeQuery = {
|
|
3473
3551
|
__typename?: 'Query';
|
|
3474
3552
|
protocolMetricsAggregated: {
|
|
3475
3553
|
__typename?: 'GqlProtocolMetricsAggregated';
|
|
@@ -3477,127 +3555,27 @@ type GetGlobalLiquidityAndSwapVolumeQuery = {
|
|
|
3477
3555
|
totalLiquidity: string;
|
|
3478
3556
|
};
|
|
3479
3557
|
};
|
|
3480
|
-
declare const DynamicData:
|
|
3481
|
-
declare const UserBalance:
|
|
3482
|
-
declare const RewardVault:
|
|
3483
|
-
declare const MinimalPoolInList:
|
|
3484
|
-
declare const MinimalPool:
|
|
3485
|
-
declare const PoolHistoricalData:
|
|
3486
|
-
|
|
3487
|
-
|
|
3488
|
-
|
|
3489
|
-
|
|
3490
|
-
|
|
3491
|
-
|
|
3492
|
-
|
|
3493
|
-
|
|
3494
|
-
|
|
3495
|
-
|
|
3496
|
-
|
|
3497
|
-
/** The unique identifier of the event. */
|
|
3498
|
-
id: Scalars['ID']['output'];
|
|
3499
|
-
/** The log index of the event. */
|
|
3500
|
-
logIndex: Scalars['Int']['output'];
|
|
3501
|
-
/** The pool ID associated with the event. */
|
|
3502
|
-
poolId: Scalars['String']['output'];
|
|
3503
|
-
/** The sender of the event. */
|
|
3504
|
-
sender: Scalars['String']['output'];
|
|
3505
|
-
/** The surplus generated by the swap. */
|
|
3506
|
-
surplus: GqlPoolEventAmount;
|
|
3507
|
-
/** The timestamp of the event. */
|
|
3508
|
-
timestamp: Scalars['Int']['output'];
|
|
3509
|
-
/** The token that was swapped in the event. */
|
|
3510
|
-
tokenIn: GqlPoolEventAmount;
|
|
3511
|
-
/** The token that was swapped out in the event. */
|
|
3512
|
-
tokenOut: GqlPoolEventAmount;
|
|
3513
|
-
/** The transaction hash of the event. */
|
|
3514
|
-
tx: Scalars['String']['output'];
|
|
3515
|
-
/** The type of the event. */
|
|
3516
|
-
type: GqlPoolEventType;
|
|
3517
|
-
/** The user address associated with the event. */
|
|
3518
|
-
userAddress: Scalars['Bytes']['output'];
|
|
3519
|
-
/** The value of the event in USD. */
|
|
3520
|
-
valueUSD: Scalars['Float']['output'];
|
|
3521
|
-
};
|
|
3522
|
-
declare const GqlPoolSwapEventCowAmm: _apollo_client.DocumentNode;
|
|
3523
|
-
/** Represents an event that occurs when a swap is made in a pool. */
|
|
3524
|
-
type GqlPoolSwapEventV3 = GqlPoolEvent & {
|
|
3525
|
-
__typename?: 'GqlPoolSwapEventV3';
|
|
3526
|
-
/** The block number of the event. */
|
|
3527
|
-
blockNumber: Scalars['Int']['output'];
|
|
3528
|
-
/** The block timestamp of the event. */
|
|
3529
|
-
blockTimestamp: Scalars['Int']['output'];
|
|
3530
|
-
/** The chain on which the event occurred. */
|
|
3531
|
-
chain: GqlChain;
|
|
3532
|
-
/** The fee that this swap generated. */
|
|
3533
|
-
fee: GqlPoolEventAmount;
|
|
3534
|
-
/** The unique identifier of the event. */
|
|
3535
|
-
id: Scalars['ID']['output'];
|
|
3536
|
-
/** The log index of the event. */
|
|
3537
|
-
logIndex: Scalars['Int']['output'];
|
|
3538
|
-
/** The pool ID associated with the event. */
|
|
3539
|
-
poolId: Scalars['String']['output'];
|
|
3540
|
-
/** The sender of the event. */
|
|
3541
|
-
sender: Scalars['String']['output'];
|
|
3542
|
-
/** The timestamp of the event. */
|
|
3543
|
-
timestamp: Scalars['Int']['output'];
|
|
3544
|
-
/** The token that was swapped in the event. */
|
|
3545
|
-
tokenIn: GqlPoolEventAmount;
|
|
3546
|
-
/** The token that was swapped out in the event. */
|
|
3547
|
-
tokenOut: GqlPoolEventAmount;
|
|
3548
|
-
/** The transaction hash of the event. */
|
|
3549
|
-
tx: Scalars['String']['output'];
|
|
3550
|
-
/** The type of the event. */
|
|
3551
|
-
type: GqlPoolEventType;
|
|
3552
|
-
/** The user address associated with the event. */
|
|
3553
|
-
userAddress: Scalars['Bytes']['output'];
|
|
3554
|
-
/** The value of the event in USD. */
|
|
3555
|
-
valueUSD: Scalars['Float']['output'];
|
|
3556
|
-
};
|
|
3557
|
-
declare const GqlPoolSwapEventV3: _apollo_client.DocumentNode;
|
|
3558
|
-
/** Represents an event that occurs when liquidity is added or removed from a pool. */
|
|
3559
|
-
type GqlPoolAddRemoveEventV3 = GqlPoolEvent & {
|
|
3560
|
-
__typename?: 'GqlPoolAddRemoveEventV3';
|
|
3561
|
-
/** The block number of the event. */
|
|
3562
|
-
blockNumber: Scalars['Int']['output'];
|
|
3563
|
-
/** The block timestamp of the event. */
|
|
3564
|
-
blockTimestamp: Scalars['Int']['output'];
|
|
3565
|
-
/** The chain on which the event occurred. */
|
|
3566
|
-
chain: GqlChain;
|
|
3567
|
-
/** The unique identifier of the event. */
|
|
3568
|
-
id: Scalars['ID']['output'];
|
|
3569
|
-
/** The log index of the event. */
|
|
3570
|
-
logIndex: Scalars['Int']['output'];
|
|
3571
|
-
/** The pool ID associated with the event. */
|
|
3572
|
-
poolId: Scalars['String']['output'];
|
|
3573
|
-
/** The sender of the event. */
|
|
3574
|
-
sender: Scalars['String']['output'];
|
|
3575
|
-
/** The timestamp of the event. */
|
|
3576
|
-
timestamp: Scalars['Int']['output'];
|
|
3577
|
-
/** The tokens involved in the event. Ordered by poolToken index. */
|
|
3578
|
-
tokens: Array<GqlPoolEventAmount>;
|
|
3579
|
-
/** The transaction hash of the event. */
|
|
3580
|
-
tx: Scalars['String']['output'];
|
|
3581
|
-
/** The type of the event. */
|
|
3582
|
-
type: GqlPoolEventType;
|
|
3583
|
-
/** The user address associated with the event. */
|
|
3584
|
-
userAddress: Scalars['Bytes']['output'];
|
|
3585
|
-
/** The value of the event in USD. */
|
|
3586
|
-
valueUSD: Scalars['Float']['output'];
|
|
3587
|
-
};
|
|
3588
|
-
declare const GqlPoolAddRemoveEventV3: _apollo_client.DocumentNode;
|
|
3589
|
-
declare const PoolEvent: _apollo_client.DocumentNode;
|
|
3590
|
-
declare const GetPools: _apollo_client.DocumentNode;
|
|
3591
|
-
declare const GetPool: _apollo_client.DocumentNode;
|
|
3592
|
-
declare const GetPoolHistoricalData: _apollo_client.DocumentNode;
|
|
3593
|
-
declare const GetPoolEvents: _apollo_client.DocumentNode;
|
|
3594
|
-
declare const GetTokenCurrentPrices: _apollo_client.DocumentNode;
|
|
3595
|
-
declare const GetGlobalLiquidityAndSwapVolume: _apollo_client.DocumentNode;
|
|
3596
|
-
interface PossibleTypesResultData {
|
|
3558
|
+
export declare const DynamicData: import("@apollo/client").DocumentNode;
|
|
3559
|
+
export declare const UserBalance: import("@apollo/client").DocumentNode;
|
|
3560
|
+
export declare const RewardVault: import("@apollo/client").DocumentNode;
|
|
3561
|
+
export declare const MinimalPoolInList: import("@apollo/client").DocumentNode;
|
|
3562
|
+
export declare const MinimalPool: import("@apollo/client").DocumentNode;
|
|
3563
|
+
export declare const PoolHistoricalData: import("@apollo/client").DocumentNode;
|
|
3564
|
+
export declare const GqlPoolSwapEventCowAmm: import("@apollo/client").DocumentNode;
|
|
3565
|
+
export declare const GqlPoolSwapEventV3: import("@apollo/client").DocumentNode;
|
|
3566
|
+
export declare const GqlPoolAddRemoveEventV3: import("@apollo/client").DocumentNode;
|
|
3567
|
+
export declare const PoolEvent: import("@apollo/client").DocumentNode;
|
|
3568
|
+
export declare const GetPools: import("@apollo/client").DocumentNode;
|
|
3569
|
+
export declare const GetPool: import("@apollo/client").DocumentNode;
|
|
3570
|
+
export declare const GetPoolHistoricalData: import("@apollo/client").DocumentNode;
|
|
3571
|
+
export declare const GetPoolEvents: import("@apollo/client").DocumentNode;
|
|
3572
|
+
export declare const GetTokenCurrentPrices: import("@apollo/client").DocumentNode;
|
|
3573
|
+
export declare const GetGlobalLiquidityAndSwapVolume: import("@apollo/client").DocumentNode;
|
|
3574
|
+
export interface PossibleTypesResultData {
|
|
3597
3575
|
possibleTypes: {
|
|
3598
3576
|
[key: string]: string[];
|
|
3599
3577
|
};
|
|
3600
3578
|
}
|
|
3601
3579
|
declare const result: PossibleTypesResultData;
|
|
3602
|
-
|
|
3603
|
-
|
|
3580
|
+
export default result;
|
|
3581
|
+
//# sourceMappingURL=api.codegen.d.ts.map
|