timelock-sdk 0.0.61 → 0.0.63
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/client.cjs +80 -8
- package/dist/client.cjs.map +1 -1
- package/dist/client.d.cts +985 -119
- package/dist/client.d.ts +993 -127
- package/dist/client.js +80 -9
- package/dist/client.js.map +1 -1
- package/dist/{index-CE9Z8aoZ.d.ts → index-BIkdgG3y.d.ts} +92 -92
- package/dist/package.d.ts +1 -1
- package/package.json +1 -1
package/dist/client.d.cts
CHANGED
|
@@ -6,7 +6,7 @@ import React, { ReactNode } from "react";
|
|
|
6
6
|
import "graphql";
|
|
7
7
|
import { GraphQLClient, RequestOptions } from "graphql-request";
|
|
8
8
|
import * as _wagmi_core0 from "@wagmi/core";
|
|
9
|
-
import * as
|
|
9
|
+
import * as _tanstack_query_core0 from "@tanstack/query-core";
|
|
10
10
|
import * as _tanstack_react_query0 from "@tanstack/react-query";
|
|
11
11
|
import { NonUndefinedGuard } from "@tanstack/react-query";
|
|
12
12
|
import * as wagmi0 from "wagmi";
|
|
@@ -67,24 +67,30 @@ type GetActiveUserOptionsQuery = {
|
|
|
67
67
|
__typename: 'UserOption';
|
|
68
68
|
id: string;
|
|
69
69
|
optionId: any;
|
|
70
|
-
ownerAddr: string;
|
|
71
70
|
optionType: any;
|
|
72
71
|
strikeTick: number;
|
|
73
72
|
entryTick: number;
|
|
74
73
|
startTick: number;
|
|
75
74
|
strikePrice: any;
|
|
76
75
|
entryPrice: any;
|
|
77
|
-
expiresAt:
|
|
78
|
-
createdAt:
|
|
76
|
+
expiresAt: any;
|
|
77
|
+
createdAt: any;
|
|
79
78
|
premium: any;
|
|
80
79
|
protocolFee: any;
|
|
81
80
|
realizedPayout: any;
|
|
82
|
-
marketAddr: string;
|
|
83
81
|
liquiditiesAtOpen: Array<string>;
|
|
84
82
|
liquiditiesCurrent: Array<string>;
|
|
85
83
|
positionSizeAtOpen: any;
|
|
86
84
|
positionSizeCurrent: any;
|
|
87
85
|
fullyExercised: boolean;
|
|
86
|
+
owner?: {
|
|
87
|
+
__typename: 'TimelockMarketUser';
|
|
88
|
+
address: string;
|
|
89
|
+
} | null;
|
|
90
|
+
market?: {
|
|
91
|
+
__typename: 'TimelockMarket';
|
|
92
|
+
address: string;
|
|
93
|
+
} | null;
|
|
88
94
|
exerciseEvents: Array<{
|
|
89
95
|
__typename: 'ExerciseOptionEvent';
|
|
90
96
|
transactionHash: string;
|
|
@@ -104,24 +110,30 @@ type GetClosedUserOptionsQuery = {
|
|
|
104
110
|
__typename: 'UserOption';
|
|
105
111
|
id: string;
|
|
106
112
|
optionId: any;
|
|
107
|
-
ownerAddr: string;
|
|
108
113
|
optionType: any;
|
|
109
114
|
strikeTick: number;
|
|
110
115
|
entryTick: number;
|
|
111
116
|
startTick: number;
|
|
112
117
|
strikePrice: any;
|
|
113
118
|
entryPrice: any;
|
|
114
|
-
expiresAt:
|
|
115
|
-
createdAt:
|
|
119
|
+
expiresAt: any;
|
|
120
|
+
createdAt: any;
|
|
116
121
|
premium: any;
|
|
117
122
|
protocolFee: any;
|
|
118
123
|
realizedPayout: any;
|
|
119
|
-
marketAddr: string;
|
|
120
124
|
liquiditiesAtOpen: Array<string>;
|
|
121
125
|
liquiditiesCurrent: Array<string>;
|
|
122
126
|
positionSizeAtOpen: any;
|
|
123
127
|
positionSizeCurrent: any;
|
|
124
128
|
fullyExercised: boolean;
|
|
129
|
+
owner?: {
|
|
130
|
+
__typename: 'TimelockMarketUser';
|
|
131
|
+
address: string;
|
|
132
|
+
} | null;
|
|
133
|
+
market?: {
|
|
134
|
+
__typename: 'TimelockMarket';
|
|
135
|
+
address: string;
|
|
136
|
+
} | null;
|
|
125
137
|
exerciseEvents: Array<{
|
|
126
138
|
__typename: 'ExerciseOptionEvent';
|
|
127
139
|
transactionHash: string;
|
|
@@ -140,6 +152,7 @@ type GetMarketDataQuery = {
|
|
|
140
152
|
TimelockMarket: Array<{
|
|
141
153
|
__typename: 'TimelockMarket';
|
|
142
154
|
id: string;
|
|
155
|
+
address: string;
|
|
143
156
|
optionsCount: any;
|
|
144
157
|
tradersCount: any;
|
|
145
158
|
vault: string;
|
|
@@ -156,11 +169,32 @@ type GetMarketDataQuery = {
|
|
|
156
169
|
payoutAssetName: string;
|
|
157
170
|
}>;
|
|
158
171
|
};
|
|
172
|
+
type GetUserMarketOperatorsQueryVariables = Exact<{
|
|
173
|
+
userAddr: Scalars['String']['input'];
|
|
174
|
+
marketAddr: Scalars['String']['input'];
|
|
175
|
+
}>;
|
|
176
|
+
type GetUserMarketOperatorsQuery = {
|
|
177
|
+
__typename: 'query_root';
|
|
178
|
+
UserMarketOperator: Array<{
|
|
179
|
+
__typename: 'UserMarketOperator';
|
|
180
|
+
id: string;
|
|
181
|
+
canExtend: boolean;
|
|
182
|
+
canExercise: boolean;
|
|
183
|
+
canTransfer: boolean;
|
|
184
|
+
canMint: boolean;
|
|
185
|
+
spendingApproval: any;
|
|
186
|
+
operator?: {
|
|
187
|
+
__typename: 'MarketOperator';
|
|
188
|
+
address: string;
|
|
189
|
+
} | null;
|
|
190
|
+
}>;
|
|
191
|
+
};
|
|
159
192
|
type SdkFunctionWrapper = <T>(action: (requestHeaders?: Record<string, string>) => Promise<T>, operationName: string, operationType?: string, variables?: any) => Promise<T>;
|
|
160
193
|
declare function getSdk(client: GraphQLClient, withWrapper?: SdkFunctionWrapper): {
|
|
161
194
|
GetActiveUserOptions(variables: GetActiveUserOptionsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetActiveUserOptionsQuery>;
|
|
162
195
|
GetClosedUserOptions(variables: GetClosedUserOptionsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetClosedUserOptionsQuery>;
|
|
163
196
|
GetMarketData(variables: GetMarketDataQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetMarketDataQuery>;
|
|
197
|
+
GetUserMarketOperators(variables: GetUserMarketOperatorsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetUserMarketOperatorsQuery>;
|
|
164
198
|
};
|
|
165
199
|
//#endregion
|
|
166
200
|
//#region src/providers/TimelockMarketProvider.d.ts
|
|
@@ -208,9 +242,10 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
208
242
|
isRefetching: boolean;
|
|
209
243
|
isStale: boolean;
|
|
210
244
|
isEnabled: boolean;
|
|
211
|
-
refetch: (options?:
|
|
245
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
212
246
|
optionId: bigint;
|
|
213
247
|
marketAddr: Address;
|
|
248
|
+
ownerAddr: Address;
|
|
214
249
|
optionType: "CALL" | "PUT";
|
|
215
250
|
createdAt: Date;
|
|
216
251
|
expiresAt: Date;
|
|
@@ -225,11 +260,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
225
260
|
entryPrice: bigint;
|
|
226
261
|
__typename: "UserOption";
|
|
227
262
|
id: string;
|
|
228
|
-
ownerAddr: string;
|
|
229
263
|
strikeTick: number;
|
|
230
264
|
entryTick: number;
|
|
231
265
|
startTick: number;
|
|
232
266
|
fullyExercised: boolean;
|
|
267
|
+
owner?: {
|
|
268
|
+
__typename: "TimelockMarketUser";
|
|
269
|
+
address: string;
|
|
270
|
+
} | null;
|
|
271
|
+
market?: {
|
|
272
|
+
__typename: "TimelockMarket";
|
|
273
|
+
address: string;
|
|
274
|
+
} | null;
|
|
233
275
|
exerciseEvents: Array<{
|
|
234
276
|
__typename: "ExerciseOptionEvent";
|
|
235
277
|
transactionHash: string;
|
|
@@ -239,10 +281,11 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
239
281
|
transactionHash: string;
|
|
240
282
|
} | null;
|
|
241
283
|
}[], Error>>;
|
|
242
|
-
fetchStatus:
|
|
284
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
243
285
|
promise: Promise<{
|
|
244
286
|
optionId: bigint;
|
|
245
287
|
marketAddr: Address;
|
|
288
|
+
ownerAddr: Address;
|
|
246
289
|
optionType: "CALL" | "PUT";
|
|
247
290
|
createdAt: Date;
|
|
248
291
|
expiresAt: Date;
|
|
@@ -257,11 +300,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
257
300
|
entryPrice: bigint;
|
|
258
301
|
__typename: "UserOption";
|
|
259
302
|
id: string;
|
|
260
|
-
ownerAddr: string;
|
|
261
303
|
strikeTick: number;
|
|
262
304
|
entryTick: number;
|
|
263
305
|
startTick: number;
|
|
264
306
|
fullyExercised: boolean;
|
|
307
|
+
owner?: {
|
|
308
|
+
__typename: "TimelockMarketUser";
|
|
309
|
+
address: string;
|
|
310
|
+
} | null;
|
|
311
|
+
market?: {
|
|
312
|
+
__typename: "TimelockMarket";
|
|
313
|
+
address: string;
|
|
314
|
+
} | null;
|
|
265
315
|
exerciseEvents: Array<{
|
|
266
316
|
__typename: "ExerciseOptionEvent";
|
|
267
317
|
transactionHash: string;
|
|
@@ -274,6 +324,7 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
274
324
|
data: {
|
|
275
325
|
optionId: bigint;
|
|
276
326
|
marketAddr: Address;
|
|
327
|
+
ownerAddr: Address;
|
|
277
328
|
optionType: "CALL" | "PUT";
|
|
278
329
|
createdAt: Date;
|
|
279
330
|
expiresAt: Date;
|
|
@@ -288,11 +339,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
288
339
|
entryPrice: bigint;
|
|
289
340
|
__typename: "UserOption";
|
|
290
341
|
id: string;
|
|
291
|
-
ownerAddr: string;
|
|
292
342
|
strikeTick: number;
|
|
293
343
|
entryTick: number;
|
|
294
344
|
startTick: number;
|
|
295
345
|
fullyExercised: boolean;
|
|
346
|
+
owner?: {
|
|
347
|
+
__typename: "TimelockMarketUser";
|
|
348
|
+
address: string;
|
|
349
|
+
} | null;
|
|
350
|
+
market?: {
|
|
351
|
+
__typename: "TimelockMarket";
|
|
352
|
+
address: string;
|
|
353
|
+
} | null;
|
|
296
354
|
exerciseEvents: Array<{
|
|
297
355
|
__typename: "ExerciseOptionEvent";
|
|
298
356
|
transactionHash: string;
|
|
@@ -325,9 +383,10 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
325
383
|
isRefetching: boolean;
|
|
326
384
|
isStale: boolean;
|
|
327
385
|
isEnabled: boolean;
|
|
328
|
-
refetch: (options?:
|
|
386
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
329
387
|
optionId: bigint;
|
|
330
388
|
marketAddr: Address;
|
|
389
|
+
ownerAddr: Address;
|
|
331
390
|
optionType: "CALL" | "PUT";
|
|
332
391
|
createdAt: Date;
|
|
333
392
|
expiresAt: Date;
|
|
@@ -342,11 +401,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
342
401
|
entryPrice: bigint;
|
|
343
402
|
__typename: "UserOption";
|
|
344
403
|
id: string;
|
|
345
|
-
ownerAddr: string;
|
|
346
404
|
strikeTick: number;
|
|
347
405
|
entryTick: number;
|
|
348
406
|
startTick: number;
|
|
349
407
|
fullyExercised: boolean;
|
|
408
|
+
owner?: {
|
|
409
|
+
__typename: "TimelockMarketUser";
|
|
410
|
+
address: string;
|
|
411
|
+
} | null;
|
|
412
|
+
market?: {
|
|
413
|
+
__typename: "TimelockMarket";
|
|
414
|
+
address: string;
|
|
415
|
+
} | null;
|
|
350
416
|
exerciseEvents: Array<{
|
|
351
417
|
__typename: "ExerciseOptionEvent";
|
|
352
418
|
transactionHash: string;
|
|
@@ -356,10 +422,11 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
356
422
|
transactionHash: string;
|
|
357
423
|
} | null;
|
|
358
424
|
}[], Error>>;
|
|
359
|
-
fetchStatus:
|
|
425
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
360
426
|
promise: Promise<{
|
|
361
427
|
optionId: bigint;
|
|
362
428
|
marketAddr: Address;
|
|
429
|
+
ownerAddr: Address;
|
|
363
430
|
optionType: "CALL" | "PUT";
|
|
364
431
|
createdAt: Date;
|
|
365
432
|
expiresAt: Date;
|
|
@@ -374,11 +441,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
374
441
|
entryPrice: bigint;
|
|
375
442
|
__typename: "UserOption";
|
|
376
443
|
id: string;
|
|
377
|
-
ownerAddr: string;
|
|
378
444
|
strikeTick: number;
|
|
379
445
|
entryTick: number;
|
|
380
446
|
startTick: number;
|
|
381
447
|
fullyExercised: boolean;
|
|
448
|
+
owner?: {
|
|
449
|
+
__typename: "TimelockMarketUser";
|
|
450
|
+
address: string;
|
|
451
|
+
} | null;
|
|
452
|
+
market?: {
|
|
453
|
+
__typename: "TimelockMarket";
|
|
454
|
+
address: string;
|
|
455
|
+
} | null;
|
|
382
456
|
exerciseEvents: Array<{
|
|
383
457
|
__typename: "ExerciseOptionEvent";
|
|
384
458
|
transactionHash: string;
|
|
@@ -391,6 +465,7 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
391
465
|
data: {
|
|
392
466
|
optionId: bigint;
|
|
393
467
|
marketAddr: Address;
|
|
468
|
+
ownerAddr: Address;
|
|
394
469
|
optionType: "CALL" | "PUT";
|
|
395
470
|
createdAt: Date;
|
|
396
471
|
expiresAt: Date;
|
|
@@ -405,11 +480,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
405
480
|
entryPrice: bigint;
|
|
406
481
|
__typename: "UserOption";
|
|
407
482
|
id: string;
|
|
408
|
-
ownerAddr: string;
|
|
409
483
|
strikeTick: number;
|
|
410
484
|
entryTick: number;
|
|
411
485
|
startTick: number;
|
|
412
486
|
fullyExercised: boolean;
|
|
487
|
+
owner?: {
|
|
488
|
+
__typename: "TimelockMarketUser";
|
|
489
|
+
address: string;
|
|
490
|
+
} | null;
|
|
491
|
+
market?: {
|
|
492
|
+
__typename: "TimelockMarket";
|
|
493
|
+
address: string;
|
|
494
|
+
} | null;
|
|
413
495
|
exerciseEvents: Array<{
|
|
414
496
|
__typename: "ExerciseOptionEvent";
|
|
415
497
|
transactionHash: string;
|
|
@@ -442,9 +524,10 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
442
524
|
isRefetching: boolean;
|
|
443
525
|
isStale: boolean;
|
|
444
526
|
isEnabled: boolean;
|
|
445
|
-
refetch: (options?:
|
|
527
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
446
528
|
optionId: bigint;
|
|
447
529
|
marketAddr: Address;
|
|
530
|
+
ownerAddr: Address;
|
|
448
531
|
optionType: "CALL" | "PUT";
|
|
449
532
|
createdAt: Date;
|
|
450
533
|
expiresAt: Date;
|
|
@@ -459,11 +542,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
459
542
|
entryPrice: bigint;
|
|
460
543
|
__typename: "UserOption";
|
|
461
544
|
id: string;
|
|
462
|
-
ownerAddr: string;
|
|
463
545
|
strikeTick: number;
|
|
464
546
|
entryTick: number;
|
|
465
547
|
startTick: number;
|
|
466
548
|
fullyExercised: boolean;
|
|
549
|
+
owner?: {
|
|
550
|
+
__typename: "TimelockMarketUser";
|
|
551
|
+
address: string;
|
|
552
|
+
} | null;
|
|
553
|
+
market?: {
|
|
554
|
+
__typename: "TimelockMarket";
|
|
555
|
+
address: string;
|
|
556
|
+
} | null;
|
|
467
557
|
exerciseEvents: Array<{
|
|
468
558
|
__typename: "ExerciseOptionEvent";
|
|
469
559
|
transactionHash: string;
|
|
@@ -473,10 +563,11 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
473
563
|
transactionHash: string;
|
|
474
564
|
} | null;
|
|
475
565
|
}[], Error>>;
|
|
476
|
-
fetchStatus:
|
|
566
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
477
567
|
promise: Promise<{
|
|
478
568
|
optionId: bigint;
|
|
479
569
|
marketAddr: Address;
|
|
570
|
+
ownerAddr: Address;
|
|
480
571
|
optionType: "CALL" | "PUT";
|
|
481
572
|
createdAt: Date;
|
|
482
573
|
expiresAt: Date;
|
|
@@ -491,11 +582,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
491
582
|
entryPrice: bigint;
|
|
492
583
|
__typename: "UserOption";
|
|
493
584
|
id: string;
|
|
494
|
-
ownerAddr: string;
|
|
495
585
|
strikeTick: number;
|
|
496
586
|
entryTick: number;
|
|
497
587
|
startTick: number;
|
|
498
588
|
fullyExercised: boolean;
|
|
589
|
+
owner?: {
|
|
590
|
+
__typename: "TimelockMarketUser";
|
|
591
|
+
address: string;
|
|
592
|
+
} | null;
|
|
593
|
+
market?: {
|
|
594
|
+
__typename: "TimelockMarket";
|
|
595
|
+
address: string;
|
|
596
|
+
} | null;
|
|
499
597
|
exerciseEvents: Array<{
|
|
500
598
|
__typename: "ExerciseOptionEvent";
|
|
501
599
|
transactionHash: string;
|
|
@@ -508,6 +606,7 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
508
606
|
data: {
|
|
509
607
|
optionId: bigint;
|
|
510
608
|
marketAddr: Address;
|
|
609
|
+
ownerAddr: Address;
|
|
511
610
|
optionType: "CALL" | "PUT";
|
|
512
611
|
createdAt: Date;
|
|
513
612
|
expiresAt: Date;
|
|
@@ -522,11 +621,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
522
621
|
entryPrice: bigint;
|
|
523
622
|
__typename: "UserOption";
|
|
524
623
|
id: string;
|
|
525
|
-
ownerAddr: string;
|
|
526
624
|
strikeTick: number;
|
|
527
625
|
entryTick: number;
|
|
528
626
|
startTick: number;
|
|
529
627
|
fullyExercised: boolean;
|
|
628
|
+
owner?: {
|
|
629
|
+
__typename: "TimelockMarketUser";
|
|
630
|
+
address: string;
|
|
631
|
+
} | null;
|
|
632
|
+
market?: {
|
|
633
|
+
__typename: "TimelockMarket";
|
|
634
|
+
address: string;
|
|
635
|
+
} | null;
|
|
530
636
|
exerciseEvents: Array<{
|
|
531
637
|
__typename: "ExerciseOptionEvent";
|
|
532
638
|
transactionHash: string;
|
|
@@ -559,9 +665,10 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
559
665
|
isRefetching: boolean;
|
|
560
666
|
isStale: boolean;
|
|
561
667
|
isEnabled: boolean;
|
|
562
|
-
refetch: (options?:
|
|
668
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
563
669
|
optionId: bigint;
|
|
564
670
|
marketAddr: Address;
|
|
671
|
+
ownerAddr: Address;
|
|
565
672
|
optionType: "CALL" | "PUT";
|
|
566
673
|
createdAt: Date;
|
|
567
674
|
expiresAt: Date;
|
|
@@ -576,11 +683,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
576
683
|
entryPrice: bigint;
|
|
577
684
|
__typename: "UserOption";
|
|
578
685
|
id: string;
|
|
579
|
-
ownerAddr: string;
|
|
580
686
|
strikeTick: number;
|
|
581
687
|
entryTick: number;
|
|
582
688
|
startTick: number;
|
|
583
689
|
fullyExercised: boolean;
|
|
690
|
+
owner?: {
|
|
691
|
+
__typename: "TimelockMarketUser";
|
|
692
|
+
address: string;
|
|
693
|
+
} | null;
|
|
694
|
+
market?: {
|
|
695
|
+
__typename: "TimelockMarket";
|
|
696
|
+
address: string;
|
|
697
|
+
} | null;
|
|
584
698
|
exerciseEvents: Array<{
|
|
585
699
|
__typename: "ExerciseOptionEvent";
|
|
586
700
|
transactionHash: string;
|
|
@@ -590,10 +704,11 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
590
704
|
transactionHash: string;
|
|
591
705
|
} | null;
|
|
592
706
|
}[], Error>>;
|
|
593
|
-
fetchStatus:
|
|
707
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
594
708
|
promise: Promise<{
|
|
595
709
|
optionId: bigint;
|
|
596
710
|
marketAddr: Address;
|
|
711
|
+
ownerAddr: Address;
|
|
597
712
|
optionType: "CALL" | "PUT";
|
|
598
713
|
createdAt: Date;
|
|
599
714
|
expiresAt: Date;
|
|
@@ -608,11 +723,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
608
723
|
entryPrice: bigint;
|
|
609
724
|
__typename: "UserOption";
|
|
610
725
|
id: string;
|
|
611
|
-
ownerAddr: string;
|
|
612
726
|
strikeTick: number;
|
|
613
727
|
entryTick: number;
|
|
614
728
|
startTick: number;
|
|
615
729
|
fullyExercised: boolean;
|
|
730
|
+
owner?: {
|
|
731
|
+
__typename: "TimelockMarketUser";
|
|
732
|
+
address: string;
|
|
733
|
+
} | null;
|
|
734
|
+
market?: {
|
|
735
|
+
__typename: "TimelockMarket";
|
|
736
|
+
address: string;
|
|
737
|
+
} | null;
|
|
616
738
|
exerciseEvents: Array<{
|
|
617
739
|
__typename: "ExerciseOptionEvent";
|
|
618
740
|
transactionHash: string;
|
|
@@ -625,6 +747,7 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
625
747
|
data: {
|
|
626
748
|
optionId: bigint;
|
|
627
749
|
marketAddr: Address;
|
|
750
|
+
ownerAddr: Address;
|
|
628
751
|
optionType: "CALL" | "PUT";
|
|
629
752
|
createdAt: Date;
|
|
630
753
|
expiresAt: Date;
|
|
@@ -639,11 +762,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
639
762
|
entryPrice: bigint;
|
|
640
763
|
__typename: "UserOption";
|
|
641
764
|
id: string;
|
|
642
|
-
ownerAddr: string;
|
|
643
765
|
strikeTick: number;
|
|
644
766
|
entryTick: number;
|
|
645
767
|
startTick: number;
|
|
646
768
|
fullyExercised: boolean;
|
|
769
|
+
owner?: {
|
|
770
|
+
__typename: "TimelockMarketUser";
|
|
771
|
+
address: string;
|
|
772
|
+
} | null;
|
|
773
|
+
market?: {
|
|
774
|
+
__typename: "TimelockMarket";
|
|
775
|
+
address: string;
|
|
776
|
+
} | null;
|
|
647
777
|
exerciseEvents: Array<{
|
|
648
778
|
__typename: "ExerciseOptionEvent";
|
|
649
779
|
transactionHash: string;
|
|
@@ -676,9 +806,10 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
676
806
|
isRefetching: boolean;
|
|
677
807
|
isStale: boolean;
|
|
678
808
|
isEnabled: boolean;
|
|
679
|
-
refetch: (options?:
|
|
809
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
680
810
|
optionId: bigint;
|
|
681
811
|
marketAddr: Address;
|
|
812
|
+
ownerAddr: Address;
|
|
682
813
|
optionType: "CALL" | "PUT";
|
|
683
814
|
createdAt: Date;
|
|
684
815
|
expiresAt: Date;
|
|
@@ -693,11 +824,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
693
824
|
entryPrice: bigint;
|
|
694
825
|
__typename: "UserOption";
|
|
695
826
|
id: string;
|
|
696
|
-
ownerAddr: string;
|
|
697
827
|
strikeTick: number;
|
|
698
828
|
entryTick: number;
|
|
699
829
|
startTick: number;
|
|
700
830
|
fullyExercised: boolean;
|
|
831
|
+
owner?: {
|
|
832
|
+
__typename: "TimelockMarketUser";
|
|
833
|
+
address: string;
|
|
834
|
+
} | null;
|
|
835
|
+
market?: {
|
|
836
|
+
__typename: "TimelockMarket";
|
|
837
|
+
address: string;
|
|
838
|
+
} | null;
|
|
701
839
|
exerciseEvents: Array<{
|
|
702
840
|
__typename: "ExerciseOptionEvent";
|
|
703
841
|
transactionHash: string;
|
|
@@ -707,10 +845,11 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
707
845
|
transactionHash: string;
|
|
708
846
|
} | null;
|
|
709
847
|
}[], Error>>;
|
|
710
|
-
fetchStatus:
|
|
848
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
711
849
|
promise: Promise<{
|
|
712
850
|
optionId: bigint;
|
|
713
851
|
marketAddr: Address;
|
|
852
|
+
ownerAddr: Address;
|
|
714
853
|
optionType: "CALL" | "PUT";
|
|
715
854
|
createdAt: Date;
|
|
716
855
|
expiresAt: Date;
|
|
@@ -725,11 +864,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
725
864
|
entryPrice: bigint;
|
|
726
865
|
__typename: "UserOption";
|
|
727
866
|
id: string;
|
|
728
|
-
ownerAddr: string;
|
|
729
867
|
strikeTick: number;
|
|
730
868
|
entryTick: number;
|
|
731
869
|
startTick: number;
|
|
732
870
|
fullyExercised: boolean;
|
|
871
|
+
owner?: {
|
|
872
|
+
__typename: "TimelockMarketUser";
|
|
873
|
+
address: string;
|
|
874
|
+
} | null;
|
|
875
|
+
market?: {
|
|
876
|
+
__typename: "TimelockMarket";
|
|
877
|
+
address: string;
|
|
878
|
+
} | null;
|
|
733
879
|
exerciseEvents: Array<{
|
|
734
880
|
__typename: "ExerciseOptionEvent";
|
|
735
881
|
transactionHash: string;
|
|
@@ -742,6 +888,7 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
742
888
|
data: {
|
|
743
889
|
optionId: bigint;
|
|
744
890
|
marketAddr: Address;
|
|
891
|
+
ownerAddr: Address;
|
|
745
892
|
optionType: "CALL" | "PUT";
|
|
746
893
|
createdAt: Date;
|
|
747
894
|
expiresAt: Date;
|
|
@@ -756,11 +903,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
756
903
|
entryPrice: bigint;
|
|
757
904
|
__typename: "UserOption";
|
|
758
905
|
id: string;
|
|
759
|
-
ownerAddr: string;
|
|
760
906
|
strikeTick: number;
|
|
761
907
|
entryTick: number;
|
|
762
908
|
startTick: number;
|
|
763
909
|
fullyExercised: boolean;
|
|
910
|
+
owner?: {
|
|
911
|
+
__typename: "TimelockMarketUser";
|
|
912
|
+
address: string;
|
|
913
|
+
} | null;
|
|
914
|
+
market?: {
|
|
915
|
+
__typename: "TimelockMarket";
|
|
916
|
+
address: string;
|
|
917
|
+
} | null;
|
|
764
918
|
exerciseEvents: Array<{
|
|
765
919
|
__typename: "ExerciseOptionEvent";
|
|
766
920
|
transactionHash: string;
|
|
@@ -793,9 +947,10 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
793
947
|
isRefetching: boolean;
|
|
794
948
|
isStale: boolean;
|
|
795
949
|
isEnabled: boolean;
|
|
796
|
-
refetch: (options?:
|
|
950
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
797
951
|
optionId: bigint;
|
|
798
952
|
marketAddr: Address;
|
|
953
|
+
ownerAddr: Address;
|
|
799
954
|
optionType: "CALL" | "PUT";
|
|
800
955
|
createdAt: Date;
|
|
801
956
|
expiresAt: Date;
|
|
@@ -810,11 +965,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
810
965
|
entryPrice: bigint;
|
|
811
966
|
__typename: "UserOption";
|
|
812
967
|
id: string;
|
|
813
|
-
ownerAddr: string;
|
|
814
968
|
strikeTick: number;
|
|
815
969
|
entryTick: number;
|
|
816
970
|
startTick: number;
|
|
817
971
|
fullyExercised: boolean;
|
|
972
|
+
owner?: {
|
|
973
|
+
__typename: "TimelockMarketUser";
|
|
974
|
+
address: string;
|
|
975
|
+
} | null;
|
|
976
|
+
market?: {
|
|
977
|
+
__typename: "TimelockMarket";
|
|
978
|
+
address: string;
|
|
979
|
+
} | null;
|
|
818
980
|
exerciseEvents: Array<{
|
|
819
981
|
__typename: "ExerciseOptionEvent";
|
|
820
982
|
transactionHash: string;
|
|
@@ -824,10 +986,11 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
824
986
|
transactionHash: string;
|
|
825
987
|
} | null;
|
|
826
988
|
}[], Error>>;
|
|
827
|
-
fetchStatus:
|
|
989
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
828
990
|
promise: Promise<{
|
|
829
991
|
optionId: bigint;
|
|
830
992
|
marketAddr: Address;
|
|
993
|
+
ownerAddr: Address;
|
|
831
994
|
optionType: "CALL" | "PUT";
|
|
832
995
|
createdAt: Date;
|
|
833
996
|
expiresAt: Date;
|
|
@@ -842,11 +1005,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
842
1005
|
entryPrice: bigint;
|
|
843
1006
|
__typename: "UserOption";
|
|
844
1007
|
id: string;
|
|
845
|
-
ownerAddr: string;
|
|
846
1008
|
strikeTick: number;
|
|
847
1009
|
entryTick: number;
|
|
848
1010
|
startTick: number;
|
|
849
1011
|
fullyExercised: boolean;
|
|
1012
|
+
owner?: {
|
|
1013
|
+
__typename: "TimelockMarketUser";
|
|
1014
|
+
address: string;
|
|
1015
|
+
} | null;
|
|
1016
|
+
market?: {
|
|
1017
|
+
__typename: "TimelockMarket";
|
|
1018
|
+
address: string;
|
|
1019
|
+
} | null;
|
|
850
1020
|
exerciseEvents: Array<{
|
|
851
1021
|
__typename: "ExerciseOptionEvent";
|
|
852
1022
|
transactionHash: string;
|
|
@@ -859,6 +1029,7 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
859
1029
|
data: {
|
|
860
1030
|
optionId: bigint;
|
|
861
1031
|
marketAddr: Address;
|
|
1032
|
+
ownerAddr: Address;
|
|
862
1033
|
optionType: "CALL" | "PUT";
|
|
863
1034
|
createdAt: Date;
|
|
864
1035
|
expiresAt: Date;
|
|
@@ -873,11 +1044,18 @@ declare const useUserOptions: (user?: Address, active?: boolean) => {
|
|
|
873
1044
|
entryPrice: bigint;
|
|
874
1045
|
__typename: "UserOption";
|
|
875
1046
|
id: string;
|
|
876
|
-
ownerAddr: string;
|
|
877
1047
|
strikeTick: number;
|
|
878
1048
|
entryTick: number;
|
|
879
1049
|
startTick: number;
|
|
880
1050
|
fullyExercised: boolean;
|
|
1051
|
+
owner?: {
|
|
1052
|
+
__typename: "TimelockMarketUser";
|
|
1053
|
+
address: string;
|
|
1054
|
+
} | null;
|
|
1055
|
+
market?: {
|
|
1056
|
+
__typename: "TimelockMarket";
|
|
1057
|
+
address: string;
|
|
1058
|
+
} | null;
|
|
881
1059
|
exerciseEvents: Array<{
|
|
882
1060
|
__typename: "ExerciseOptionEvent";
|
|
883
1061
|
transactionHash: string;
|
|
@@ -911,9 +1089,10 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
911
1089
|
isRefetching: boolean;
|
|
912
1090
|
isStale: boolean;
|
|
913
1091
|
isEnabled: boolean;
|
|
914
|
-
refetch: (options?:
|
|
1092
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
915
1093
|
optionId: bigint;
|
|
916
1094
|
marketAddr: Address;
|
|
1095
|
+
ownerAddr: Address;
|
|
917
1096
|
optionType: "CALL" | "PUT";
|
|
918
1097
|
createdAt: Date;
|
|
919
1098
|
expiresAt: Date;
|
|
@@ -928,11 +1107,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
928
1107
|
entryPrice: bigint;
|
|
929
1108
|
__typename: "UserOption";
|
|
930
1109
|
id: string;
|
|
931
|
-
ownerAddr: string;
|
|
932
1110
|
strikeTick: number;
|
|
933
1111
|
entryTick: number;
|
|
934
1112
|
startTick: number;
|
|
935
1113
|
fullyExercised: boolean;
|
|
1114
|
+
owner?: {
|
|
1115
|
+
__typename: "TimelockMarketUser";
|
|
1116
|
+
address: string;
|
|
1117
|
+
} | null;
|
|
1118
|
+
market?: {
|
|
1119
|
+
__typename: "TimelockMarket";
|
|
1120
|
+
address: string;
|
|
1121
|
+
} | null;
|
|
936
1122
|
exerciseEvents: Array<{
|
|
937
1123
|
__typename: "ExerciseOptionEvent";
|
|
938
1124
|
transactionHash: string;
|
|
@@ -942,10 +1128,11 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
942
1128
|
transactionHash: string;
|
|
943
1129
|
} | null;
|
|
944
1130
|
}[], Error>>;
|
|
945
|
-
fetchStatus:
|
|
1131
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
946
1132
|
promise: Promise<{
|
|
947
1133
|
optionId: bigint;
|
|
948
1134
|
marketAddr: Address;
|
|
1135
|
+
ownerAddr: Address;
|
|
949
1136
|
optionType: "CALL" | "PUT";
|
|
950
1137
|
createdAt: Date;
|
|
951
1138
|
expiresAt: Date;
|
|
@@ -960,11 +1147,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
960
1147
|
entryPrice: bigint;
|
|
961
1148
|
__typename: "UserOption";
|
|
962
1149
|
id: string;
|
|
963
|
-
ownerAddr: string;
|
|
964
1150
|
strikeTick: number;
|
|
965
1151
|
entryTick: number;
|
|
966
1152
|
startTick: number;
|
|
967
1153
|
fullyExercised: boolean;
|
|
1154
|
+
owner?: {
|
|
1155
|
+
__typename: "TimelockMarketUser";
|
|
1156
|
+
address: string;
|
|
1157
|
+
} | null;
|
|
1158
|
+
market?: {
|
|
1159
|
+
__typename: "TimelockMarket";
|
|
1160
|
+
address: string;
|
|
1161
|
+
} | null;
|
|
968
1162
|
exerciseEvents: Array<{
|
|
969
1163
|
__typename: "ExerciseOptionEvent";
|
|
970
1164
|
transactionHash: string;
|
|
@@ -977,6 +1171,7 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
977
1171
|
data: {
|
|
978
1172
|
optionId: bigint;
|
|
979
1173
|
marketAddr: Address;
|
|
1174
|
+
ownerAddr: Address;
|
|
980
1175
|
optionType: "CALL" | "PUT";
|
|
981
1176
|
createdAt: Date;
|
|
982
1177
|
expiresAt: Date;
|
|
@@ -991,11 +1186,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
991
1186
|
entryPrice: bigint;
|
|
992
1187
|
__typename: "UserOption";
|
|
993
1188
|
id: string;
|
|
994
|
-
ownerAddr: string;
|
|
995
1189
|
strikeTick: number;
|
|
996
1190
|
entryTick: number;
|
|
997
1191
|
startTick: number;
|
|
998
1192
|
fullyExercised: boolean;
|
|
1193
|
+
owner?: {
|
|
1194
|
+
__typename: "TimelockMarketUser";
|
|
1195
|
+
address: string;
|
|
1196
|
+
} | null;
|
|
1197
|
+
market?: {
|
|
1198
|
+
__typename: "TimelockMarket";
|
|
1199
|
+
address: string;
|
|
1200
|
+
} | null;
|
|
999
1201
|
exerciseEvents: Array<{
|
|
1000
1202
|
__typename: "ExerciseOptionEvent";
|
|
1001
1203
|
transactionHash: string;
|
|
@@ -1028,9 +1230,10 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1028
1230
|
isRefetching: boolean;
|
|
1029
1231
|
isStale: boolean;
|
|
1030
1232
|
isEnabled: boolean;
|
|
1031
|
-
refetch: (options?:
|
|
1233
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
1032
1234
|
optionId: bigint;
|
|
1033
1235
|
marketAddr: Address;
|
|
1236
|
+
ownerAddr: Address;
|
|
1034
1237
|
optionType: "CALL" | "PUT";
|
|
1035
1238
|
createdAt: Date;
|
|
1036
1239
|
expiresAt: Date;
|
|
@@ -1045,11 +1248,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1045
1248
|
entryPrice: bigint;
|
|
1046
1249
|
__typename: "UserOption";
|
|
1047
1250
|
id: string;
|
|
1048
|
-
ownerAddr: string;
|
|
1049
1251
|
strikeTick: number;
|
|
1050
1252
|
entryTick: number;
|
|
1051
1253
|
startTick: number;
|
|
1052
1254
|
fullyExercised: boolean;
|
|
1255
|
+
owner?: {
|
|
1256
|
+
__typename: "TimelockMarketUser";
|
|
1257
|
+
address: string;
|
|
1258
|
+
} | null;
|
|
1259
|
+
market?: {
|
|
1260
|
+
__typename: "TimelockMarket";
|
|
1261
|
+
address: string;
|
|
1262
|
+
} | null;
|
|
1053
1263
|
exerciseEvents: Array<{
|
|
1054
1264
|
__typename: "ExerciseOptionEvent";
|
|
1055
1265
|
transactionHash: string;
|
|
@@ -1059,10 +1269,11 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1059
1269
|
transactionHash: string;
|
|
1060
1270
|
} | null;
|
|
1061
1271
|
}[], Error>>;
|
|
1062
|
-
fetchStatus:
|
|
1272
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
1063
1273
|
promise: Promise<{
|
|
1064
1274
|
optionId: bigint;
|
|
1065
1275
|
marketAddr: Address;
|
|
1276
|
+
ownerAddr: Address;
|
|
1066
1277
|
optionType: "CALL" | "PUT";
|
|
1067
1278
|
createdAt: Date;
|
|
1068
1279
|
expiresAt: Date;
|
|
@@ -1077,11 +1288,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1077
1288
|
entryPrice: bigint;
|
|
1078
1289
|
__typename: "UserOption";
|
|
1079
1290
|
id: string;
|
|
1080
|
-
ownerAddr: string;
|
|
1081
1291
|
strikeTick: number;
|
|
1082
1292
|
entryTick: number;
|
|
1083
1293
|
startTick: number;
|
|
1084
1294
|
fullyExercised: boolean;
|
|
1295
|
+
owner?: {
|
|
1296
|
+
__typename: "TimelockMarketUser";
|
|
1297
|
+
address: string;
|
|
1298
|
+
} | null;
|
|
1299
|
+
market?: {
|
|
1300
|
+
__typename: "TimelockMarket";
|
|
1301
|
+
address: string;
|
|
1302
|
+
} | null;
|
|
1085
1303
|
exerciseEvents: Array<{
|
|
1086
1304
|
__typename: "ExerciseOptionEvent";
|
|
1087
1305
|
transactionHash: string;
|
|
@@ -1094,6 +1312,7 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1094
1312
|
data: {
|
|
1095
1313
|
optionId: bigint;
|
|
1096
1314
|
marketAddr: Address;
|
|
1315
|
+
ownerAddr: Address;
|
|
1097
1316
|
optionType: "CALL" | "PUT";
|
|
1098
1317
|
createdAt: Date;
|
|
1099
1318
|
expiresAt: Date;
|
|
@@ -1108,11 +1327,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1108
1327
|
entryPrice: bigint;
|
|
1109
1328
|
__typename: "UserOption";
|
|
1110
1329
|
id: string;
|
|
1111
|
-
ownerAddr: string;
|
|
1112
1330
|
strikeTick: number;
|
|
1113
1331
|
entryTick: number;
|
|
1114
1332
|
startTick: number;
|
|
1115
1333
|
fullyExercised: boolean;
|
|
1334
|
+
owner?: {
|
|
1335
|
+
__typename: "TimelockMarketUser";
|
|
1336
|
+
address: string;
|
|
1337
|
+
} | null;
|
|
1338
|
+
market?: {
|
|
1339
|
+
__typename: "TimelockMarket";
|
|
1340
|
+
address: string;
|
|
1341
|
+
} | null;
|
|
1116
1342
|
exerciseEvents: Array<{
|
|
1117
1343
|
__typename: "ExerciseOptionEvent";
|
|
1118
1344
|
transactionHash: string;
|
|
@@ -1145,9 +1371,10 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1145
1371
|
isRefetching: boolean;
|
|
1146
1372
|
isStale: boolean;
|
|
1147
1373
|
isEnabled: boolean;
|
|
1148
|
-
refetch: (options?:
|
|
1374
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
1149
1375
|
optionId: bigint;
|
|
1150
1376
|
marketAddr: Address;
|
|
1377
|
+
ownerAddr: Address;
|
|
1151
1378
|
optionType: "CALL" | "PUT";
|
|
1152
1379
|
createdAt: Date;
|
|
1153
1380
|
expiresAt: Date;
|
|
@@ -1162,11 +1389,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1162
1389
|
entryPrice: bigint;
|
|
1163
1390
|
__typename: "UserOption";
|
|
1164
1391
|
id: string;
|
|
1165
|
-
ownerAddr: string;
|
|
1166
1392
|
strikeTick: number;
|
|
1167
1393
|
entryTick: number;
|
|
1168
1394
|
startTick: number;
|
|
1169
1395
|
fullyExercised: boolean;
|
|
1396
|
+
owner?: {
|
|
1397
|
+
__typename: "TimelockMarketUser";
|
|
1398
|
+
address: string;
|
|
1399
|
+
} | null;
|
|
1400
|
+
market?: {
|
|
1401
|
+
__typename: "TimelockMarket";
|
|
1402
|
+
address: string;
|
|
1403
|
+
} | null;
|
|
1170
1404
|
exerciseEvents: Array<{
|
|
1171
1405
|
__typename: "ExerciseOptionEvent";
|
|
1172
1406
|
transactionHash: string;
|
|
@@ -1176,10 +1410,11 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1176
1410
|
transactionHash: string;
|
|
1177
1411
|
} | null;
|
|
1178
1412
|
}[], Error>>;
|
|
1179
|
-
fetchStatus:
|
|
1413
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
1180
1414
|
promise: Promise<{
|
|
1181
1415
|
optionId: bigint;
|
|
1182
1416
|
marketAddr: Address;
|
|
1417
|
+
ownerAddr: Address;
|
|
1183
1418
|
optionType: "CALL" | "PUT";
|
|
1184
1419
|
createdAt: Date;
|
|
1185
1420
|
expiresAt: Date;
|
|
@@ -1194,11 +1429,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1194
1429
|
entryPrice: bigint;
|
|
1195
1430
|
__typename: "UserOption";
|
|
1196
1431
|
id: string;
|
|
1197
|
-
ownerAddr: string;
|
|
1198
1432
|
strikeTick: number;
|
|
1199
1433
|
entryTick: number;
|
|
1200
1434
|
startTick: number;
|
|
1201
1435
|
fullyExercised: boolean;
|
|
1436
|
+
owner?: {
|
|
1437
|
+
__typename: "TimelockMarketUser";
|
|
1438
|
+
address: string;
|
|
1439
|
+
} | null;
|
|
1440
|
+
market?: {
|
|
1441
|
+
__typename: "TimelockMarket";
|
|
1442
|
+
address: string;
|
|
1443
|
+
} | null;
|
|
1202
1444
|
exerciseEvents: Array<{
|
|
1203
1445
|
__typename: "ExerciseOptionEvent";
|
|
1204
1446
|
transactionHash: string;
|
|
@@ -1211,6 +1453,7 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1211
1453
|
data: {
|
|
1212
1454
|
optionId: bigint;
|
|
1213
1455
|
marketAddr: Address;
|
|
1456
|
+
ownerAddr: Address;
|
|
1214
1457
|
optionType: "CALL" | "PUT";
|
|
1215
1458
|
createdAt: Date;
|
|
1216
1459
|
expiresAt: Date;
|
|
@@ -1225,11 +1468,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1225
1468
|
entryPrice: bigint;
|
|
1226
1469
|
__typename: "UserOption";
|
|
1227
1470
|
id: string;
|
|
1228
|
-
ownerAddr: string;
|
|
1229
1471
|
strikeTick: number;
|
|
1230
1472
|
entryTick: number;
|
|
1231
1473
|
startTick: number;
|
|
1232
1474
|
fullyExercised: boolean;
|
|
1475
|
+
owner?: {
|
|
1476
|
+
__typename: "TimelockMarketUser";
|
|
1477
|
+
address: string;
|
|
1478
|
+
} | null;
|
|
1479
|
+
market?: {
|
|
1480
|
+
__typename: "TimelockMarket";
|
|
1481
|
+
address: string;
|
|
1482
|
+
} | null;
|
|
1233
1483
|
exerciseEvents: Array<{
|
|
1234
1484
|
__typename: "ExerciseOptionEvent";
|
|
1235
1485
|
transactionHash: string;
|
|
@@ -1262,9 +1512,10 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1262
1512
|
isRefetching: boolean;
|
|
1263
1513
|
isStale: boolean;
|
|
1264
1514
|
isEnabled: boolean;
|
|
1265
|
-
refetch: (options?:
|
|
1515
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
1266
1516
|
optionId: bigint;
|
|
1267
1517
|
marketAddr: Address;
|
|
1518
|
+
ownerAddr: Address;
|
|
1268
1519
|
optionType: "CALL" | "PUT";
|
|
1269
1520
|
createdAt: Date;
|
|
1270
1521
|
expiresAt: Date;
|
|
@@ -1279,11 +1530,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1279
1530
|
entryPrice: bigint;
|
|
1280
1531
|
__typename: "UserOption";
|
|
1281
1532
|
id: string;
|
|
1282
|
-
ownerAddr: string;
|
|
1283
1533
|
strikeTick: number;
|
|
1284
1534
|
entryTick: number;
|
|
1285
1535
|
startTick: number;
|
|
1286
1536
|
fullyExercised: boolean;
|
|
1537
|
+
owner?: {
|
|
1538
|
+
__typename: "TimelockMarketUser";
|
|
1539
|
+
address: string;
|
|
1540
|
+
} | null;
|
|
1541
|
+
market?: {
|
|
1542
|
+
__typename: "TimelockMarket";
|
|
1543
|
+
address: string;
|
|
1544
|
+
} | null;
|
|
1287
1545
|
exerciseEvents: Array<{
|
|
1288
1546
|
__typename: "ExerciseOptionEvent";
|
|
1289
1547
|
transactionHash: string;
|
|
@@ -1293,10 +1551,11 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1293
1551
|
transactionHash: string;
|
|
1294
1552
|
} | null;
|
|
1295
1553
|
}[], Error>>;
|
|
1296
|
-
fetchStatus:
|
|
1554
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
1297
1555
|
promise: Promise<{
|
|
1298
1556
|
optionId: bigint;
|
|
1299
1557
|
marketAddr: Address;
|
|
1558
|
+
ownerAddr: Address;
|
|
1300
1559
|
optionType: "CALL" | "PUT";
|
|
1301
1560
|
createdAt: Date;
|
|
1302
1561
|
expiresAt: Date;
|
|
@@ -1311,11 +1570,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1311
1570
|
entryPrice: bigint;
|
|
1312
1571
|
__typename: "UserOption";
|
|
1313
1572
|
id: string;
|
|
1314
|
-
ownerAddr: string;
|
|
1315
1573
|
strikeTick: number;
|
|
1316
1574
|
entryTick: number;
|
|
1317
1575
|
startTick: number;
|
|
1318
1576
|
fullyExercised: boolean;
|
|
1577
|
+
owner?: {
|
|
1578
|
+
__typename: "TimelockMarketUser";
|
|
1579
|
+
address: string;
|
|
1580
|
+
} | null;
|
|
1581
|
+
market?: {
|
|
1582
|
+
__typename: "TimelockMarket";
|
|
1583
|
+
address: string;
|
|
1584
|
+
} | null;
|
|
1319
1585
|
exerciseEvents: Array<{
|
|
1320
1586
|
__typename: "ExerciseOptionEvent";
|
|
1321
1587
|
transactionHash: string;
|
|
@@ -1328,6 +1594,7 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1328
1594
|
data: {
|
|
1329
1595
|
optionId: bigint;
|
|
1330
1596
|
marketAddr: Address;
|
|
1597
|
+
ownerAddr: Address;
|
|
1331
1598
|
optionType: "CALL" | "PUT";
|
|
1332
1599
|
createdAt: Date;
|
|
1333
1600
|
expiresAt: Date;
|
|
@@ -1342,11 +1609,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1342
1609
|
entryPrice: bigint;
|
|
1343
1610
|
__typename: "UserOption";
|
|
1344
1611
|
id: string;
|
|
1345
|
-
ownerAddr: string;
|
|
1346
1612
|
strikeTick: number;
|
|
1347
1613
|
entryTick: number;
|
|
1348
1614
|
startTick: number;
|
|
1349
1615
|
fullyExercised: boolean;
|
|
1616
|
+
owner?: {
|
|
1617
|
+
__typename: "TimelockMarketUser";
|
|
1618
|
+
address: string;
|
|
1619
|
+
} | null;
|
|
1620
|
+
market?: {
|
|
1621
|
+
__typename: "TimelockMarket";
|
|
1622
|
+
address: string;
|
|
1623
|
+
} | null;
|
|
1350
1624
|
exerciseEvents: Array<{
|
|
1351
1625
|
__typename: "ExerciseOptionEvent";
|
|
1352
1626
|
transactionHash: string;
|
|
@@ -1379,9 +1653,10 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1379
1653
|
isRefetching: boolean;
|
|
1380
1654
|
isStale: boolean;
|
|
1381
1655
|
isEnabled: boolean;
|
|
1382
|
-
refetch: (options?:
|
|
1656
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
1383
1657
|
optionId: bigint;
|
|
1384
1658
|
marketAddr: Address;
|
|
1659
|
+
ownerAddr: Address;
|
|
1385
1660
|
optionType: "CALL" | "PUT";
|
|
1386
1661
|
createdAt: Date;
|
|
1387
1662
|
expiresAt: Date;
|
|
@@ -1396,11 +1671,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1396
1671
|
entryPrice: bigint;
|
|
1397
1672
|
__typename: "UserOption";
|
|
1398
1673
|
id: string;
|
|
1399
|
-
ownerAddr: string;
|
|
1400
1674
|
strikeTick: number;
|
|
1401
1675
|
entryTick: number;
|
|
1402
1676
|
startTick: number;
|
|
1403
1677
|
fullyExercised: boolean;
|
|
1678
|
+
owner?: {
|
|
1679
|
+
__typename: "TimelockMarketUser";
|
|
1680
|
+
address: string;
|
|
1681
|
+
} | null;
|
|
1682
|
+
market?: {
|
|
1683
|
+
__typename: "TimelockMarket";
|
|
1684
|
+
address: string;
|
|
1685
|
+
} | null;
|
|
1404
1686
|
exerciseEvents: Array<{
|
|
1405
1687
|
__typename: "ExerciseOptionEvent";
|
|
1406
1688
|
transactionHash: string;
|
|
@@ -1410,10 +1692,11 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1410
1692
|
transactionHash: string;
|
|
1411
1693
|
} | null;
|
|
1412
1694
|
}[], Error>>;
|
|
1413
|
-
fetchStatus:
|
|
1695
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
1414
1696
|
promise: Promise<{
|
|
1415
1697
|
optionId: bigint;
|
|
1416
1698
|
marketAddr: Address;
|
|
1699
|
+
ownerAddr: Address;
|
|
1417
1700
|
optionType: "CALL" | "PUT";
|
|
1418
1701
|
createdAt: Date;
|
|
1419
1702
|
expiresAt: Date;
|
|
@@ -1428,11 +1711,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1428
1711
|
entryPrice: bigint;
|
|
1429
1712
|
__typename: "UserOption";
|
|
1430
1713
|
id: string;
|
|
1431
|
-
ownerAddr: string;
|
|
1432
1714
|
strikeTick: number;
|
|
1433
1715
|
entryTick: number;
|
|
1434
1716
|
startTick: number;
|
|
1435
1717
|
fullyExercised: boolean;
|
|
1718
|
+
owner?: {
|
|
1719
|
+
__typename: "TimelockMarketUser";
|
|
1720
|
+
address: string;
|
|
1721
|
+
} | null;
|
|
1722
|
+
market?: {
|
|
1723
|
+
__typename: "TimelockMarket";
|
|
1724
|
+
address: string;
|
|
1725
|
+
} | null;
|
|
1436
1726
|
exerciseEvents: Array<{
|
|
1437
1727
|
__typename: "ExerciseOptionEvent";
|
|
1438
1728
|
transactionHash: string;
|
|
@@ -1445,6 +1735,7 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1445
1735
|
data: {
|
|
1446
1736
|
optionId: bigint;
|
|
1447
1737
|
marketAddr: Address;
|
|
1738
|
+
ownerAddr: Address;
|
|
1448
1739
|
optionType: "CALL" | "PUT";
|
|
1449
1740
|
createdAt: Date;
|
|
1450
1741
|
expiresAt: Date;
|
|
@@ -1459,11 +1750,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1459
1750
|
entryPrice: bigint;
|
|
1460
1751
|
__typename: "UserOption";
|
|
1461
1752
|
id: string;
|
|
1462
|
-
ownerAddr: string;
|
|
1463
1753
|
strikeTick: number;
|
|
1464
1754
|
entryTick: number;
|
|
1465
1755
|
startTick: number;
|
|
1466
1756
|
fullyExercised: boolean;
|
|
1757
|
+
owner?: {
|
|
1758
|
+
__typename: "TimelockMarketUser";
|
|
1759
|
+
address: string;
|
|
1760
|
+
} | null;
|
|
1761
|
+
market?: {
|
|
1762
|
+
__typename: "TimelockMarket";
|
|
1763
|
+
address: string;
|
|
1764
|
+
} | null;
|
|
1467
1765
|
exerciseEvents: Array<{
|
|
1468
1766
|
__typename: "ExerciseOptionEvent";
|
|
1469
1767
|
transactionHash: string;
|
|
@@ -1496,9 +1794,10 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1496
1794
|
isRefetching: boolean;
|
|
1497
1795
|
isStale: boolean;
|
|
1498
1796
|
isEnabled: boolean;
|
|
1499
|
-
refetch: (options?:
|
|
1797
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
1500
1798
|
optionId: bigint;
|
|
1501
1799
|
marketAddr: Address;
|
|
1800
|
+
ownerAddr: Address;
|
|
1502
1801
|
optionType: "CALL" | "PUT";
|
|
1503
1802
|
createdAt: Date;
|
|
1504
1803
|
expiresAt: Date;
|
|
@@ -1513,11 +1812,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1513
1812
|
entryPrice: bigint;
|
|
1514
1813
|
__typename: "UserOption";
|
|
1515
1814
|
id: string;
|
|
1516
|
-
ownerAddr: string;
|
|
1517
1815
|
strikeTick: number;
|
|
1518
1816
|
entryTick: number;
|
|
1519
1817
|
startTick: number;
|
|
1520
1818
|
fullyExercised: boolean;
|
|
1819
|
+
owner?: {
|
|
1820
|
+
__typename: "TimelockMarketUser";
|
|
1821
|
+
address: string;
|
|
1822
|
+
} | null;
|
|
1823
|
+
market?: {
|
|
1824
|
+
__typename: "TimelockMarket";
|
|
1825
|
+
address: string;
|
|
1826
|
+
} | null;
|
|
1521
1827
|
exerciseEvents: Array<{
|
|
1522
1828
|
__typename: "ExerciseOptionEvent";
|
|
1523
1829
|
transactionHash: string;
|
|
@@ -1527,10 +1833,11 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1527
1833
|
transactionHash: string;
|
|
1528
1834
|
} | null;
|
|
1529
1835
|
}[], Error>>;
|
|
1530
|
-
fetchStatus:
|
|
1836
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
1531
1837
|
promise: Promise<{
|
|
1532
1838
|
optionId: bigint;
|
|
1533
1839
|
marketAddr: Address;
|
|
1840
|
+
ownerAddr: Address;
|
|
1534
1841
|
optionType: "CALL" | "PUT";
|
|
1535
1842
|
createdAt: Date;
|
|
1536
1843
|
expiresAt: Date;
|
|
@@ -1545,11 +1852,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1545
1852
|
entryPrice: bigint;
|
|
1546
1853
|
__typename: "UserOption";
|
|
1547
1854
|
id: string;
|
|
1548
|
-
ownerAddr: string;
|
|
1549
1855
|
strikeTick: number;
|
|
1550
1856
|
entryTick: number;
|
|
1551
1857
|
startTick: number;
|
|
1552
1858
|
fullyExercised: boolean;
|
|
1859
|
+
owner?: {
|
|
1860
|
+
__typename: "TimelockMarketUser";
|
|
1861
|
+
address: string;
|
|
1862
|
+
} | null;
|
|
1863
|
+
market?: {
|
|
1864
|
+
__typename: "TimelockMarket";
|
|
1865
|
+
address: string;
|
|
1866
|
+
} | null;
|
|
1553
1867
|
exerciseEvents: Array<{
|
|
1554
1868
|
__typename: "ExerciseOptionEvent";
|
|
1555
1869
|
transactionHash: string;
|
|
@@ -1562,6 +1876,7 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1562
1876
|
data: {
|
|
1563
1877
|
optionId: bigint;
|
|
1564
1878
|
marketAddr: Address;
|
|
1879
|
+
ownerAddr: Address;
|
|
1565
1880
|
optionType: "CALL" | "PUT";
|
|
1566
1881
|
createdAt: Date;
|
|
1567
1882
|
expiresAt: Date;
|
|
@@ -1576,11 +1891,18 @@ declare const useActiveUserOptions: (user?: Address) => {
|
|
|
1576
1891
|
entryPrice: bigint;
|
|
1577
1892
|
__typename: "UserOption";
|
|
1578
1893
|
id: string;
|
|
1579
|
-
ownerAddr: string;
|
|
1580
1894
|
strikeTick: number;
|
|
1581
1895
|
entryTick: number;
|
|
1582
1896
|
startTick: number;
|
|
1583
1897
|
fullyExercised: boolean;
|
|
1898
|
+
owner?: {
|
|
1899
|
+
__typename: "TimelockMarketUser";
|
|
1900
|
+
address: string;
|
|
1901
|
+
} | null;
|
|
1902
|
+
market?: {
|
|
1903
|
+
__typename: "TimelockMarket";
|
|
1904
|
+
address: string;
|
|
1905
|
+
} | null;
|
|
1584
1906
|
exerciseEvents: Array<{
|
|
1585
1907
|
__typename: "ExerciseOptionEvent";
|
|
1586
1908
|
transactionHash: string;
|
|
@@ -1614,9 +1936,10 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1614
1936
|
isRefetching: boolean;
|
|
1615
1937
|
isStale: boolean;
|
|
1616
1938
|
isEnabled: boolean;
|
|
1617
|
-
refetch: (options?:
|
|
1939
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
1618
1940
|
optionId: bigint;
|
|
1619
1941
|
marketAddr: Address;
|
|
1942
|
+
ownerAddr: Address;
|
|
1620
1943
|
optionType: "CALL" | "PUT";
|
|
1621
1944
|
createdAt: Date;
|
|
1622
1945
|
expiresAt: Date;
|
|
@@ -1631,11 +1954,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1631
1954
|
entryPrice: bigint;
|
|
1632
1955
|
__typename: "UserOption";
|
|
1633
1956
|
id: string;
|
|
1634
|
-
ownerAddr: string;
|
|
1635
1957
|
strikeTick: number;
|
|
1636
1958
|
entryTick: number;
|
|
1637
1959
|
startTick: number;
|
|
1638
1960
|
fullyExercised: boolean;
|
|
1961
|
+
owner?: {
|
|
1962
|
+
__typename: "TimelockMarketUser";
|
|
1963
|
+
address: string;
|
|
1964
|
+
} | null;
|
|
1965
|
+
market?: {
|
|
1966
|
+
__typename: "TimelockMarket";
|
|
1967
|
+
address: string;
|
|
1968
|
+
} | null;
|
|
1639
1969
|
exerciseEvents: Array<{
|
|
1640
1970
|
__typename: "ExerciseOptionEvent";
|
|
1641
1971
|
transactionHash: string;
|
|
@@ -1645,10 +1975,11 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1645
1975
|
transactionHash: string;
|
|
1646
1976
|
} | null;
|
|
1647
1977
|
}[], Error>>;
|
|
1648
|
-
fetchStatus:
|
|
1978
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
1649
1979
|
promise: Promise<{
|
|
1650
1980
|
optionId: bigint;
|
|
1651
1981
|
marketAddr: Address;
|
|
1982
|
+
ownerAddr: Address;
|
|
1652
1983
|
optionType: "CALL" | "PUT";
|
|
1653
1984
|
createdAt: Date;
|
|
1654
1985
|
expiresAt: Date;
|
|
@@ -1663,11 +1994,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1663
1994
|
entryPrice: bigint;
|
|
1664
1995
|
__typename: "UserOption";
|
|
1665
1996
|
id: string;
|
|
1666
|
-
ownerAddr: string;
|
|
1667
1997
|
strikeTick: number;
|
|
1668
1998
|
entryTick: number;
|
|
1669
1999
|
startTick: number;
|
|
1670
2000
|
fullyExercised: boolean;
|
|
2001
|
+
owner?: {
|
|
2002
|
+
__typename: "TimelockMarketUser";
|
|
2003
|
+
address: string;
|
|
2004
|
+
} | null;
|
|
2005
|
+
market?: {
|
|
2006
|
+
__typename: "TimelockMarket";
|
|
2007
|
+
address: string;
|
|
2008
|
+
} | null;
|
|
1671
2009
|
exerciseEvents: Array<{
|
|
1672
2010
|
__typename: "ExerciseOptionEvent";
|
|
1673
2011
|
transactionHash: string;
|
|
@@ -1680,6 +2018,7 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1680
2018
|
data: {
|
|
1681
2019
|
optionId: bigint;
|
|
1682
2020
|
marketAddr: Address;
|
|
2021
|
+
ownerAddr: Address;
|
|
1683
2022
|
optionType: "CALL" | "PUT";
|
|
1684
2023
|
createdAt: Date;
|
|
1685
2024
|
expiresAt: Date;
|
|
@@ -1694,11 +2033,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1694
2033
|
entryPrice: bigint;
|
|
1695
2034
|
__typename: "UserOption";
|
|
1696
2035
|
id: string;
|
|
1697
|
-
ownerAddr: string;
|
|
1698
2036
|
strikeTick: number;
|
|
1699
2037
|
entryTick: number;
|
|
1700
2038
|
startTick: number;
|
|
1701
2039
|
fullyExercised: boolean;
|
|
2040
|
+
owner?: {
|
|
2041
|
+
__typename: "TimelockMarketUser";
|
|
2042
|
+
address: string;
|
|
2043
|
+
} | null;
|
|
2044
|
+
market?: {
|
|
2045
|
+
__typename: "TimelockMarket";
|
|
2046
|
+
address: string;
|
|
2047
|
+
} | null;
|
|
1702
2048
|
exerciseEvents: Array<{
|
|
1703
2049
|
__typename: "ExerciseOptionEvent";
|
|
1704
2050
|
transactionHash: string;
|
|
@@ -1731,9 +2077,10 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1731
2077
|
isRefetching: boolean;
|
|
1732
2078
|
isStale: boolean;
|
|
1733
2079
|
isEnabled: boolean;
|
|
1734
|
-
refetch: (options?:
|
|
2080
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
1735
2081
|
optionId: bigint;
|
|
1736
2082
|
marketAddr: Address;
|
|
2083
|
+
ownerAddr: Address;
|
|
1737
2084
|
optionType: "CALL" | "PUT";
|
|
1738
2085
|
createdAt: Date;
|
|
1739
2086
|
expiresAt: Date;
|
|
@@ -1748,11 +2095,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1748
2095
|
entryPrice: bigint;
|
|
1749
2096
|
__typename: "UserOption";
|
|
1750
2097
|
id: string;
|
|
1751
|
-
ownerAddr: string;
|
|
1752
2098
|
strikeTick: number;
|
|
1753
2099
|
entryTick: number;
|
|
1754
2100
|
startTick: number;
|
|
1755
2101
|
fullyExercised: boolean;
|
|
2102
|
+
owner?: {
|
|
2103
|
+
__typename: "TimelockMarketUser";
|
|
2104
|
+
address: string;
|
|
2105
|
+
} | null;
|
|
2106
|
+
market?: {
|
|
2107
|
+
__typename: "TimelockMarket";
|
|
2108
|
+
address: string;
|
|
2109
|
+
} | null;
|
|
1756
2110
|
exerciseEvents: Array<{
|
|
1757
2111
|
__typename: "ExerciseOptionEvent";
|
|
1758
2112
|
transactionHash: string;
|
|
@@ -1762,10 +2116,11 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1762
2116
|
transactionHash: string;
|
|
1763
2117
|
} | null;
|
|
1764
2118
|
}[], Error>>;
|
|
1765
|
-
fetchStatus:
|
|
2119
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
1766
2120
|
promise: Promise<{
|
|
1767
2121
|
optionId: bigint;
|
|
1768
2122
|
marketAddr: Address;
|
|
2123
|
+
ownerAddr: Address;
|
|
1769
2124
|
optionType: "CALL" | "PUT";
|
|
1770
2125
|
createdAt: Date;
|
|
1771
2126
|
expiresAt: Date;
|
|
@@ -1780,11 +2135,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1780
2135
|
entryPrice: bigint;
|
|
1781
2136
|
__typename: "UserOption";
|
|
1782
2137
|
id: string;
|
|
1783
|
-
ownerAddr: string;
|
|
1784
2138
|
strikeTick: number;
|
|
1785
2139
|
entryTick: number;
|
|
1786
2140
|
startTick: number;
|
|
1787
2141
|
fullyExercised: boolean;
|
|
2142
|
+
owner?: {
|
|
2143
|
+
__typename: "TimelockMarketUser";
|
|
2144
|
+
address: string;
|
|
2145
|
+
} | null;
|
|
2146
|
+
market?: {
|
|
2147
|
+
__typename: "TimelockMarket";
|
|
2148
|
+
address: string;
|
|
2149
|
+
} | null;
|
|
1788
2150
|
exerciseEvents: Array<{
|
|
1789
2151
|
__typename: "ExerciseOptionEvent";
|
|
1790
2152
|
transactionHash: string;
|
|
@@ -1797,6 +2159,7 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1797
2159
|
data: {
|
|
1798
2160
|
optionId: bigint;
|
|
1799
2161
|
marketAddr: Address;
|
|
2162
|
+
ownerAddr: Address;
|
|
1800
2163
|
optionType: "CALL" | "PUT";
|
|
1801
2164
|
createdAt: Date;
|
|
1802
2165
|
expiresAt: Date;
|
|
@@ -1811,11 +2174,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1811
2174
|
entryPrice: bigint;
|
|
1812
2175
|
__typename: "UserOption";
|
|
1813
2176
|
id: string;
|
|
1814
|
-
ownerAddr: string;
|
|
1815
2177
|
strikeTick: number;
|
|
1816
2178
|
entryTick: number;
|
|
1817
2179
|
startTick: number;
|
|
1818
2180
|
fullyExercised: boolean;
|
|
2181
|
+
owner?: {
|
|
2182
|
+
__typename: "TimelockMarketUser";
|
|
2183
|
+
address: string;
|
|
2184
|
+
} | null;
|
|
2185
|
+
market?: {
|
|
2186
|
+
__typename: "TimelockMarket";
|
|
2187
|
+
address: string;
|
|
2188
|
+
} | null;
|
|
1819
2189
|
exerciseEvents: Array<{
|
|
1820
2190
|
__typename: "ExerciseOptionEvent";
|
|
1821
2191
|
transactionHash: string;
|
|
@@ -1848,9 +2218,10 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1848
2218
|
isRefetching: boolean;
|
|
1849
2219
|
isStale: boolean;
|
|
1850
2220
|
isEnabled: boolean;
|
|
1851
|
-
refetch: (options?:
|
|
2221
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
1852
2222
|
optionId: bigint;
|
|
1853
2223
|
marketAddr: Address;
|
|
2224
|
+
ownerAddr: Address;
|
|
1854
2225
|
optionType: "CALL" | "PUT";
|
|
1855
2226
|
createdAt: Date;
|
|
1856
2227
|
expiresAt: Date;
|
|
@@ -1865,11 +2236,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1865
2236
|
entryPrice: bigint;
|
|
1866
2237
|
__typename: "UserOption";
|
|
1867
2238
|
id: string;
|
|
1868
|
-
ownerAddr: string;
|
|
1869
2239
|
strikeTick: number;
|
|
1870
2240
|
entryTick: number;
|
|
1871
2241
|
startTick: number;
|
|
1872
2242
|
fullyExercised: boolean;
|
|
2243
|
+
owner?: {
|
|
2244
|
+
__typename: "TimelockMarketUser";
|
|
2245
|
+
address: string;
|
|
2246
|
+
} | null;
|
|
2247
|
+
market?: {
|
|
2248
|
+
__typename: "TimelockMarket";
|
|
2249
|
+
address: string;
|
|
2250
|
+
} | null;
|
|
1873
2251
|
exerciseEvents: Array<{
|
|
1874
2252
|
__typename: "ExerciseOptionEvent";
|
|
1875
2253
|
transactionHash: string;
|
|
@@ -1879,10 +2257,11 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1879
2257
|
transactionHash: string;
|
|
1880
2258
|
} | null;
|
|
1881
2259
|
}[], Error>>;
|
|
1882
|
-
fetchStatus:
|
|
2260
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
1883
2261
|
promise: Promise<{
|
|
1884
2262
|
optionId: bigint;
|
|
1885
2263
|
marketAddr: Address;
|
|
2264
|
+
ownerAddr: Address;
|
|
1886
2265
|
optionType: "CALL" | "PUT";
|
|
1887
2266
|
createdAt: Date;
|
|
1888
2267
|
expiresAt: Date;
|
|
@@ -1897,11 +2276,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1897
2276
|
entryPrice: bigint;
|
|
1898
2277
|
__typename: "UserOption";
|
|
1899
2278
|
id: string;
|
|
1900
|
-
ownerAddr: string;
|
|
1901
2279
|
strikeTick: number;
|
|
1902
2280
|
entryTick: number;
|
|
1903
2281
|
startTick: number;
|
|
1904
2282
|
fullyExercised: boolean;
|
|
2283
|
+
owner?: {
|
|
2284
|
+
__typename: "TimelockMarketUser";
|
|
2285
|
+
address: string;
|
|
2286
|
+
} | null;
|
|
2287
|
+
market?: {
|
|
2288
|
+
__typename: "TimelockMarket";
|
|
2289
|
+
address: string;
|
|
2290
|
+
} | null;
|
|
1905
2291
|
exerciseEvents: Array<{
|
|
1906
2292
|
__typename: "ExerciseOptionEvent";
|
|
1907
2293
|
transactionHash: string;
|
|
@@ -1914,6 +2300,7 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1914
2300
|
data: {
|
|
1915
2301
|
optionId: bigint;
|
|
1916
2302
|
marketAddr: Address;
|
|
2303
|
+
ownerAddr: Address;
|
|
1917
2304
|
optionType: "CALL" | "PUT";
|
|
1918
2305
|
createdAt: Date;
|
|
1919
2306
|
expiresAt: Date;
|
|
@@ -1928,11 +2315,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1928
2315
|
entryPrice: bigint;
|
|
1929
2316
|
__typename: "UserOption";
|
|
1930
2317
|
id: string;
|
|
1931
|
-
ownerAddr: string;
|
|
1932
2318
|
strikeTick: number;
|
|
1933
2319
|
entryTick: number;
|
|
1934
2320
|
startTick: number;
|
|
1935
2321
|
fullyExercised: boolean;
|
|
2322
|
+
owner?: {
|
|
2323
|
+
__typename: "TimelockMarketUser";
|
|
2324
|
+
address: string;
|
|
2325
|
+
} | null;
|
|
2326
|
+
market?: {
|
|
2327
|
+
__typename: "TimelockMarket";
|
|
2328
|
+
address: string;
|
|
2329
|
+
} | null;
|
|
1936
2330
|
exerciseEvents: Array<{
|
|
1937
2331
|
__typename: "ExerciseOptionEvent";
|
|
1938
2332
|
transactionHash: string;
|
|
@@ -1965,9 +2359,10 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1965
2359
|
isRefetching: boolean;
|
|
1966
2360
|
isStale: boolean;
|
|
1967
2361
|
isEnabled: boolean;
|
|
1968
|
-
refetch: (options?:
|
|
2362
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
1969
2363
|
optionId: bigint;
|
|
1970
2364
|
marketAddr: Address;
|
|
2365
|
+
ownerAddr: Address;
|
|
1971
2366
|
optionType: "CALL" | "PUT";
|
|
1972
2367
|
createdAt: Date;
|
|
1973
2368
|
expiresAt: Date;
|
|
@@ -1982,11 +2377,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1982
2377
|
entryPrice: bigint;
|
|
1983
2378
|
__typename: "UserOption";
|
|
1984
2379
|
id: string;
|
|
1985
|
-
ownerAddr: string;
|
|
1986
2380
|
strikeTick: number;
|
|
1987
2381
|
entryTick: number;
|
|
1988
2382
|
startTick: number;
|
|
1989
2383
|
fullyExercised: boolean;
|
|
2384
|
+
owner?: {
|
|
2385
|
+
__typename: "TimelockMarketUser";
|
|
2386
|
+
address: string;
|
|
2387
|
+
} | null;
|
|
2388
|
+
market?: {
|
|
2389
|
+
__typename: "TimelockMarket";
|
|
2390
|
+
address: string;
|
|
2391
|
+
} | null;
|
|
1990
2392
|
exerciseEvents: Array<{
|
|
1991
2393
|
__typename: "ExerciseOptionEvent";
|
|
1992
2394
|
transactionHash: string;
|
|
@@ -1996,10 +2398,11 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
1996
2398
|
transactionHash: string;
|
|
1997
2399
|
} | null;
|
|
1998
2400
|
}[], Error>>;
|
|
1999
|
-
fetchStatus:
|
|
2401
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
2000
2402
|
promise: Promise<{
|
|
2001
2403
|
optionId: bigint;
|
|
2002
2404
|
marketAddr: Address;
|
|
2405
|
+
ownerAddr: Address;
|
|
2003
2406
|
optionType: "CALL" | "PUT";
|
|
2004
2407
|
createdAt: Date;
|
|
2005
2408
|
expiresAt: Date;
|
|
@@ -2014,11 +2417,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2014
2417
|
entryPrice: bigint;
|
|
2015
2418
|
__typename: "UserOption";
|
|
2016
2419
|
id: string;
|
|
2017
|
-
ownerAddr: string;
|
|
2018
2420
|
strikeTick: number;
|
|
2019
2421
|
entryTick: number;
|
|
2020
2422
|
startTick: number;
|
|
2021
2423
|
fullyExercised: boolean;
|
|
2424
|
+
owner?: {
|
|
2425
|
+
__typename: "TimelockMarketUser";
|
|
2426
|
+
address: string;
|
|
2427
|
+
} | null;
|
|
2428
|
+
market?: {
|
|
2429
|
+
__typename: "TimelockMarket";
|
|
2430
|
+
address: string;
|
|
2431
|
+
} | null;
|
|
2022
2432
|
exerciseEvents: Array<{
|
|
2023
2433
|
__typename: "ExerciseOptionEvent";
|
|
2024
2434
|
transactionHash: string;
|
|
@@ -2031,6 +2441,7 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2031
2441
|
data: {
|
|
2032
2442
|
optionId: bigint;
|
|
2033
2443
|
marketAddr: Address;
|
|
2444
|
+
ownerAddr: Address;
|
|
2034
2445
|
optionType: "CALL" | "PUT";
|
|
2035
2446
|
createdAt: Date;
|
|
2036
2447
|
expiresAt: Date;
|
|
@@ -2045,11 +2456,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2045
2456
|
entryPrice: bigint;
|
|
2046
2457
|
__typename: "UserOption";
|
|
2047
2458
|
id: string;
|
|
2048
|
-
ownerAddr: string;
|
|
2049
2459
|
strikeTick: number;
|
|
2050
2460
|
entryTick: number;
|
|
2051
2461
|
startTick: number;
|
|
2052
2462
|
fullyExercised: boolean;
|
|
2463
|
+
owner?: {
|
|
2464
|
+
__typename: "TimelockMarketUser";
|
|
2465
|
+
address: string;
|
|
2466
|
+
} | null;
|
|
2467
|
+
market?: {
|
|
2468
|
+
__typename: "TimelockMarket";
|
|
2469
|
+
address: string;
|
|
2470
|
+
} | null;
|
|
2053
2471
|
exerciseEvents: Array<{
|
|
2054
2472
|
__typename: "ExerciseOptionEvent";
|
|
2055
2473
|
transactionHash: string;
|
|
@@ -2082,9 +2500,10 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2082
2500
|
isRefetching: boolean;
|
|
2083
2501
|
isStale: boolean;
|
|
2084
2502
|
isEnabled: boolean;
|
|
2085
|
-
refetch: (options?:
|
|
2503
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
2086
2504
|
optionId: bigint;
|
|
2087
2505
|
marketAddr: Address;
|
|
2506
|
+
ownerAddr: Address;
|
|
2088
2507
|
optionType: "CALL" | "PUT";
|
|
2089
2508
|
createdAt: Date;
|
|
2090
2509
|
expiresAt: Date;
|
|
@@ -2099,11 +2518,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2099
2518
|
entryPrice: bigint;
|
|
2100
2519
|
__typename: "UserOption";
|
|
2101
2520
|
id: string;
|
|
2102
|
-
ownerAddr: string;
|
|
2103
2521
|
strikeTick: number;
|
|
2104
2522
|
entryTick: number;
|
|
2105
2523
|
startTick: number;
|
|
2106
2524
|
fullyExercised: boolean;
|
|
2525
|
+
owner?: {
|
|
2526
|
+
__typename: "TimelockMarketUser";
|
|
2527
|
+
address: string;
|
|
2528
|
+
} | null;
|
|
2529
|
+
market?: {
|
|
2530
|
+
__typename: "TimelockMarket";
|
|
2531
|
+
address: string;
|
|
2532
|
+
} | null;
|
|
2107
2533
|
exerciseEvents: Array<{
|
|
2108
2534
|
__typename: "ExerciseOptionEvent";
|
|
2109
2535
|
transactionHash: string;
|
|
@@ -2113,10 +2539,11 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2113
2539
|
transactionHash: string;
|
|
2114
2540
|
} | null;
|
|
2115
2541
|
}[], Error>>;
|
|
2116
|
-
fetchStatus:
|
|
2542
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
2117
2543
|
promise: Promise<{
|
|
2118
2544
|
optionId: bigint;
|
|
2119
2545
|
marketAddr: Address;
|
|
2546
|
+
ownerAddr: Address;
|
|
2120
2547
|
optionType: "CALL" | "PUT";
|
|
2121
2548
|
createdAt: Date;
|
|
2122
2549
|
expiresAt: Date;
|
|
@@ -2131,11 +2558,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2131
2558
|
entryPrice: bigint;
|
|
2132
2559
|
__typename: "UserOption";
|
|
2133
2560
|
id: string;
|
|
2134
|
-
ownerAddr: string;
|
|
2135
2561
|
strikeTick: number;
|
|
2136
2562
|
entryTick: number;
|
|
2137
2563
|
startTick: number;
|
|
2138
2564
|
fullyExercised: boolean;
|
|
2565
|
+
owner?: {
|
|
2566
|
+
__typename: "TimelockMarketUser";
|
|
2567
|
+
address: string;
|
|
2568
|
+
} | null;
|
|
2569
|
+
market?: {
|
|
2570
|
+
__typename: "TimelockMarket";
|
|
2571
|
+
address: string;
|
|
2572
|
+
} | null;
|
|
2139
2573
|
exerciseEvents: Array<{
|
|
2140
2574
|
__typename: "ExerciseOptionEvent";
|
|
2141
2575
|
transactionHash: string;
|
|
@@ -2148,6 +2582,7 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2148
2582
|
data: {
|
|
2149
2583
|
optionId: bigint;
|
|
2150
2584
|
marketAddr: Address;
|
|
2585
|
+
ownerAddr: Address;
|
|
2151
2586
|
optionType: "CALL" | "PUT";
|
|
2152
2587
|
createdAt: Date;
|
|
2153
2588
|
expiresAt: Date;
|
|
@@ -2162,11 +2597,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2162
2597
|
entryPrice: bigint;
|
|
2163
2598
|
__typename: "UserOption";
|
|
2164
2599
|
id: string;
|
|
2165
|
-
ownerAddr: string;
|
|
2166
2600
|
strikeTick: number;
|
|
2167
2601
|
entryTick: number;
|
|
2168
2602
|
startTick: number;
|
|
2169
2603
|
fullyExercised: boolean;
|
|
2604
|
+
owner?: {
|
|
2605
|
+
__typename: "TimelockMarketUser";
|
|
2606
|
+
address: string;
|
|
2607
|
+
} | null;
|
|
2608
|
+
market?: {
|
|
2609
|
+
__typename: "TimelockMarket";
|
|
2610
|
+
address: string;
|
|
2611
|
+
} | null;
|
|
2170
2612
|
exerciseEvents: Array<{
|
|
2171
2613
|
__typename: "ExerciseOptionEvent";
|
|
2172
2614
|
transactionHash: string;
|
|
@@ -2199,9 +2641,10 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2199
2641
|
isRefetching: boolean;
|
|
2200
2642
|
isStale: boolean;
|
|
2201
2643
|
isEnabled: boolean;
|
|
2202
|
-
refetch: (options?:
|
|
2644
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
2203
2645
|
optionId: bigint;
|
|
2204
2646
|
marketAddr: Address;
|
|
2647
|
+
ownerAddr: Address;
|
|
2205
2648
|
optionType: "CALL" | "PUT";
|
|
2206
2649
|
createdAt: Date;
|
|
2207
2650
|
expiresAt: Date;
|
|
@@ -2216,11 +2659,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2216
2659
|
entryPrice: bigint;
|
|
2217
2660
|
__typename: "UserOption";
|
|
2218
2661
|
id: string;
|
|
2219
|
-
ownerAddr: string;
|
|
2220
2662
|
strikeTick: number;
|
|
2221
2663
|
entryTick: number;
|
|
2222
2664
|
startTick: number;
|
|
2223
2665
|
fullyExercised: boolean;
|
|
2666
|
+
owner?: {
|
|
2667
|
+
__typename: "TimelockMarketUser";
|
|
2668
|
+
address: string;
|
|
2669
|
+
} | null;
|
|
2670
|
+
market?: {
|
|
2671
|
+
__typename: "TimelockMarket";
|
|
2672
|
+
address: string;
|
|
2673
|
+
} | null;
|
|
2224
2674
|
exerciseEvents: Array<{
|
|
2225
2675
|
__typename: "ExerciseOptionEvent";
|
|
2226
2676
|
transactionHash: string;
|
|
@@ -2230,10 +2680,11 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2230
2680
|
transactionHash: string;
|
|
2231
2681
|
} | null;
|
|
2232
2682
|
}[], Error>>;
|
|
2233
|
-
fetchStatus:
|
|
2683
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
2234
2684
|
promise: Promise<{
|
|
2235
2685
|
optionId: bigint;
|
|
2236
2686
|
marketAddr: Address;
|
|
2687
|
+
ownerAddr: Address;
|
|
2237
2688
|
optionType: "CALL" | "PUT";
|
|
2238
2689
|
createdAt: Date;
|
|
2239
2690
|
expiresAt: Date;
|
|
@@ -2248,11 +2699,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2248
2699
|
entryPrice: bigint;
|
|
2249
2700
|
__typename: "UserOption";
|
|
2250
2701
|
id: string;
|
|
2251
|
-
ownerAddr: string;
|
|
2252
2702
|
strikeTick: number;
|
|
2253
2703
|
entryTick: number;
|
|
2254
2704
|
startTick: number;
|
|
2255
2705
|
fullyExercised: boolean;
|
|
2706
|
+
owner?: {
|
|
2707
|
+
__typename: "TimelockMarketUser";
|
|
2708
|
+
address: string;
|
|
2709
|
+
} | null;
|
|
2710
|
+
market?: {
|
|
2711
|
+
__typename: "TimelockMarket";
|
|
2712
|
+
address: string;
|
|
2713
|
+
} | null;
|
|
2256
2714
|
exerciseEvents: Array<{
|
|
2257
2715
|
__typename: "ExerciseOptionEvent";
|
|
2258
2716
|
transactionHash: string;
|
|
@@ -2265,6 +2723,7 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2265
2723
|
data: {
|
|
2266
2724
|
optionId: bigint;
|
|
2267
2725
|
marketAddr: Address;
|
|
2726
|
+
ownerAddr: Address;
|
|
2268
2727
|
optionType: "CALL" | "PUT";
|
|
2269
2728
|
createdAt: Date;
|
|
2270
2729
|
expiresAt: Date;
|
|
@@ -2279,11 +2738,18 @@ declare const useClosedUserOptions: (user?: Address) => {
|
|
|
2279
2738
|
entryPrice: bigint;
|
|
2280
2739
|
__typename: "UserOption";
|
|
2281
2740
|
id: string;
|
|
2282
|
-
ownerAddr: string;
|
|
2283
2741
|
strikeTick: number;
|
|
2284
2742
|
entryTick: number;
|
|
2285
2743
|
startTick: number;
|
|
2286
2744
|
fullyExercised: boolean;
|
|
2745
|
+
owner?: {
|
|
2746
|
+
__typename: "TimelockMarketUser";
|
|
2747
|
+
address: string;
|
|
2748
|
+
} | null;
|
|
2749
|
+
market?: {
|
|
2750
|
+
__typename: "TimelockMarket";
|
|
2751
|
+
address: string;
|
|
2752
|
+
} | null;
|
|
2287
2753
|
exerciseEvents: Array<{
|
|
2288
2754
|
__typename: "ExerciseOptionEvent";
|
|
2289
2755
|
transactionHash: string;
|
|
@@ -2316,6 +2782,7 @@ declare const useMarketData: (marketAddr?: Address) => Partial<NonUndefinedGuard
|
|
|
2316
2782
|
tradersCount: bigint;
|
|
2317
2783
|
__typename: "TimelockMarket";
|
|
2318
2784
|
id: string;
|
|
2785
|
+
address: string;
|
|
2319
2786
|
tickSpacing: number;
|
|
2320
2787
|
optionAssetIsToken0: boolean;
|
|
2321
2788
|
optionAssetDecimals: number;
|
|
@@ -2378,6 +2845,405 @@ declare const useExtendOption: (marketAddr?: Address) => {
|
|
|
2378
2845
|
resetApproval: () => void;
|
|
2379
2846
|
};
|
|
2380
2847
|
//#endregion
|
|
2848
|
+
//#region src/hooks/market/useUserOperators.d.ts
|
|
2849
|
+
declare const useUserOperators: (userAddr?: Address, marketAddr?: Address) => {
|
|
2850
|
+
data: Partial<NonUndefinedGuard<{
|
|
2851
|
+
spendingApproval: bigint;
|
|
2852
|
+
operatorAddr: string;
|
|
2853
|
+
__typename: "UserMarketOperator";
|
|
2854
|
+
id: string;
|
|
2855
|
+
canExtend: boolean;
|
|
2856
|
+
canExercise: boolean;
|
|
2857
|
+
canTransfer: boolean;
|
|
2858
|
+
canMint: boolean;
|
|
2859
|
+
operator?: {
|
|
2860
|
+
__typename: "MarketOperator";
|
|
2861
|
+
address: string;
|
|
2862
|
+
} | null;
|
|
2863
|
+
}[] | undefined>>;
|
|
2864
|
+
error: Error;
|
|
2865
|
+
isError: true;
|
|
2866
|
+
isPending: false;
|
|
2867
|
+
isLoading: false;
|
|
2868
|
+
isLoadingError: false;
|
|
2869
|
+
isRefetchError: true;
|
|
2870
|
+
isSuccess: false;
|
|
2871
|
+
isPlaceholderData: false;
|
|
2872
|
+
status: "error";
|
|
2873
|
+
dataUpdatedAt: number;
|
|
2874
|
+
errorUpdatedAt: number;
|
|
2875
|
+
failureCount: number;
|
|
2876
|
+
failureReason: Error | null;
|
|
2877
|
+
errorUpdateCount: number;
|
|
2878
|
+
isFetched: boolean;
|
|
2879
|
+
isFetchedAfterMount: boolean;
|
|
2880
|
+
isFetching: boolean;
|
|
2881
|
+
isInitialLoading: boolean;
|
|
2882
|
+
isPaused: boolean;
|
|
2883
|
+
isRefetching: boolean;
|
|
2884
|
+
isStale: boolean;
|
|
2885
|
+
isEnabled: boolean;
|
|
2886
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
2887
|
+
spendingApproval: bigint;
|
|
2888
|
+
operatorAddr: string;
|
|
2889
|
+
__typename: "UserMarketOperator";
|
|
2890
|
+
id: string;
|
|
2891
|
+
canExtend: boolean;
|
|
2892
|
+
canExercise: boolean;
|
|
2893
|
+
canTransfer: boolean;
|
|
2894
|
+
canMint: boolean;
|
|
2895
|
+
operator?: {
|
|
2896
|
+
__typename: "MarketOperator";
|
|
2897
|
+
address: string;
|
|
2898
|
+
} | null;
|
|
2899
|
+
}[] | undefined, Error>>;
|
|
2900
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
2901
|
+
promise: Promise<{
|
|
2902
|
+
spendingApproval: bigint;
|
|
2903
|
+
operatorAddr: string;
|
|
2904
|
+
__typename: "UserMarketOperator";
|
|
2905
|
+
id: string;
|
|
2906
|
+
canExtend: boolean;
|
|
2907
|
+
canExercise: boolean;
|
|
2908
|
+
canTransfer: boolean;
|
|
2909
|
+
canMint: boolean;
|
|
2910
|
+
operator?: {
|
|
2911
|
+
__typename: "MarketOperator";
|
|
2912
|
+
address: string;
|
|
2913
|
+
} | null;
|
|
2914
|
+
}[] | undefined>;
|
|
2915
|
+
} | {
|
|
2916
|
+
data: Partial<NonUndefinedGuard<{
|
|
2917
|
+
spendingApproval: bigint;
|
|
2918
|
+
operatorAddr: string;
|
|
2919
|
+
__typename: "UserMarketOperator";
|
|
2920
|
+
id: string;
|
|
2921
|
+
canExtend: boolean;
|
|
2922
|
+
canExercise: boolean;
|
|
2923
|
+
canTransfer: boolean;
|
|
2924
|
+
canMint: boolean;
|
|
2925
|
+
operator?: {
|
|
2926
|
+
__typename: "MarketOperator";
|
|
2927
|
+
address: string;
|
|
2928
|
+
} | null;
|
|
2929
|
+
}[] | undefined>>;
|
|
2930
|
+
error: null;
|
|
2931
|
+
isError: false;
|
|
2932
|
+
isPending: false;
|
|
2933
|
+
isLoading: false;
|
|
2934
|
+
isLoadingError: false;
|
|
2935
|
+
isRefetchError: false;
|
|
2936
|
+
isSuccess: true;
|
|
2937
|
+
isPlaceholderData: false;
|
|
2938
|
+
status: "success";
|
|
2939
|
+
dataUpdatedAt: number;
|
|
2940
|
+
errorUpdatedAt: number;
|
|
2941
|
+
failureCount: number;
|
|
2942
|
+
failureReason: Error | null;
|
|
2943
|
+
errorUpdateCount: number;
|
|
2944
|
+
isFetched: boolean;
|
|
2945
|
+
isFetchedAfterMount: boolean;
|
|
2946
|
+
isFetching: boolean;
|
|
2947
|
+
isInitialLoading: boolean;
|
|
2948
|
+
isPaused: boolean;
|
|
2949
|
+
isRefetching: boolean;
|
|
2950
|
+
isStale: boolean;
|
|
2951
|
+
isEnabled: boolean;
|
|
2952
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
2953
|
+
spendingApproval: bigint;
|
|
2954
|
+
operatorAddr: string;
|
|
2955
|
+
__typename: "UserMarketOperator";
|
|
2956
|
+
id: string;
|
|
2957
|
+
canExtend: boolean;
|
|
2958
|
+
canExercise: boolean;
|
|
2959
|
+
canTransfer: boolean;
|
|
2960
|
+
canMint: boolean;
|
|
2961
|
+
operator?: {
|
|
2962
|
+
__typename: "MarketOperator";
|
|
2963
|
+
address: string;
|
|
2964
|
+
} | null;
|
|
2965
|
+
}[] | undefined, Error>>;
|
|
2966
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
2967
|
+
promise: Promise<{
|
|
2968
|
+
spendingApproval: bigint;
|
|
2969
|
+
operatorAddr: string;
|
|
2970
|
+
__typename: "UserMarketOperator";
|
|
2971
|
+
id: string;
|
|
2972
|
+
canExtend: boolean;
|
|
2973
|
+
canExercise: boolean;
|
|
2974
|
+
canTransfer: boolean;
|
|
2975
|
+
canMint: boolean;
|
|
2976
|
+
operator?: {
|
|
2977
|
+
__typename: "MarketOperator";
|
|
2978
|
+
address: string;
|
|
2979
|
+
} | null;
|
|
2980
|
+
}[] | undefined>;
|
|
2981
|
+
} | {
|
|
2982
|
+
data: Partial<NonUndefinedGuard<{
|
|
2983
|
+
spendingApproval: bigint;
|
|
2984
|
+
operatorAddr: string;
|
|
2985
|
+
__typename: "UserMarketOperator";
|
|
2986
|
+
id: string;
|
|
2987
|
+
canExtend: boolean;
|
|
2988
|
+
canExercise: boolean;
|
|
2989
|
+
canTransfer: boolean;
|
|
2990
|
+
canMint: boolean;
|
|
2991
|
+
operator?: {
|
|
2992
|
+
__typename: "MarketOperator";
|
|
2993
|
+
address: string;
|
|
2994
|
+
} | null;
|
|
2995
|
+
}[] | undefined>>;
|
|
2996
|
+
error: Error;
|
|
2997
|
+
isError: true;
|
|
2998
|
+
isPending: false;
|
|
2999
|
+
isLoading: false;
|
|
3000
|
+
isLoadingError: true;
|
|
3001
|
+
isRefetchError: false;
|
|
3002
|
+
isSuccess: false;
|
|
3003
|
+
isPlaceholderData: false;
|
|
3004
|
+
status: "error";
|
|
3005
|
+
dataUpdatedAt: number;
|
|
3006
|
+
errorUpdatedAt: number;
|
|
3007
|
+
failureCount: number;
|
|
3008
|
+
failureReason: Error | null;
|
|
3009
|
+
errorUpdateCount: number;
|
|
3010
|
+
isFetched: boolean;
|
|
3011
|
+
isFetchedAfterMount: boolean;
|
|
3012
|
+
isFetching: boolean;
|
|
3013
|
+
isInitialLoading: boolean;
|
|
3014
|
+
isPaused: boolean;
|
|
3015
|
+
isRefetching: boolean;
|
|
3016
|
+
isStale: boolean;
|
|
3017
|
+
isEnabled: boolean;
|
|
3018
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
3019
|
+
spendingApproval: bigint;
|
|
3020
|
+
operatorAddr: string;
|
|
3021
|
+
__typename: "UserMarketOperator";
|
|
3022
|
+
id: string;
|
|
3023
|
+
canExtend: boolean;
|
|
3024
|
+
canExercise: boolean;
|
|
3025
|
+
canTransfer: boolean;
|
|
3026
|
+
canMint: boolean;
|
|
3027
|
+
operator?: {
|
|
3028
|
+
__typename: "MarketOperator";
|
|
3029
|
+
address: string;
|
|
3030
|
+
} | null;
|
|
3031
|
+
}[] | undefined, Error>>;
|
|
3032
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
3033
|
+
promise: Promise<{
|
|
3034
|
+
spendingApproval: bigint;
|
|
3035
|
+
operatorAddr: string;
|
|
3036
|
+
__typename: "UserMarketOperator";
|
|
3037
|
+
id: string;
|
|
3038
|
+
canExtend: boolean;
|
|
3039
|
+
canExercise: boolean;
|
|
3040
|
+
canTransfer: boolean;
|
|
3041
|
+
canMint: boolean;
|
|
3042
|
+
operator?: {
|
|
3043
|
+
__typename: "MarketOperator";
|
|
3044
|
+
address: string;
|
|
3045
|
+
} | null;
|
|
3046
|
+
}[] | undefined>;
|
|
3047
|
+
} | {
|
|
3048
|
+
data: Partial<NonUndefinedGuard<{
|
|
3049
|
+
spendingApproval: bigint;
|
|
3050
|
+
operatorAddr: string;
|
|
3051
|
+
__typename: "UserMarketOperator";
|
|
3052
|
+
id: string;
|
|
3053
|
+
canExtend: boolean;
|
|
3054
|
+
canExercise: boolean;
|
|
3055
|
+
canTransfer: boolean;
|
|
3056
|
+
canMint: boolean;
|
|
3057
|
+
operator?: {
|
|
3058
|
+
__typename: "MarketOperator";
|
|
3059
|
+
address: string;
|
|
3060
|
+
} | null;
|
|
3061
|
+
}[] | undefined>>;
|
|
3062
|
+
error: null;
|
|
3063
|
+
isError: false;
|
|
3064
|
+
isPending: true;
|
|
3065
|
+
isLoading: true;
|
|
3066
|
+
isLoadingError: false;
|
|
3067
|
+
isRefetchError: false;
|
|
3068
|
+
isSuccess: false;
|
|
3069
|
+
isPlaceholderData: false;
|
|
3070
|
+
status: "pending";
|
|
3071
|
+
dataUpdatedAt: number;
|
|
3072
|
+
errorUpdatedAt: number;
|
|
3073
|
+
failureCount: number;
|
|
3074
|
+
failureReason: Error | null;
|
|
3075
|
+
errorUpdateCount: number;
|
|
3076
|
+
isFetched: boolean;
|
|
3077
|
+
isFetchedAfterMount: boolean;
|
|
3078
|
+
isFetching: boolean;
|
|
3079
|
+
isInitialLoading: boolean;
|
|
3080
|
+
isPaused: boolean;
|
|
3081
|
+
isRefetching: boolean;
|
|
3082
|
+
isStale: boolean;
|
|
3083
|
+
isEnabled: boolean;
|
|
3084
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
3085
|
+
spendingApproval: bigint;
|
|
3086
|
+
operatorAddr: string;
|
|
3087
|
+
__typename: "UserMarketOperator";
|
|
3088
|
+
id: string;
|
|
3089
|
+
canExtend: boolean;
|
|
3090
|
+
canExercise: boolean;
|
|
3091
|
+
canTransfer: boolean;
|
|
3092
|
+
canMint: boolean;
|
|
3093
|
+
operator?: {
|
|
3094
|
+
__typename: "MarketOperator";
|
|
3095
|
+
address: string;
|
|
3096
|
+
} | null;
|
|
3097
|
+
}[] | undefined, Error>>;
|
|
3098
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
3099
|
+
promise: Promise<{
|
|
3100
|
+
spendingApproval: bigint;
|
|
3101
|
+
operatorAddr: string;
|
|
3102
|
+
__typename: "UserMarketOperator";
|
|
3103
|
+
id: string;
|
|
3104
|
+
canExtend: boolean;
|
|
3105
|
+
canExercise: boolean;
|
|
3106
|
+
canTransfer: boolean;
|
|
3107
|
+
canMint: boolean;
|
|
3108
|
+
operator?: {
|
|
3109
|
+
__typename: "MarketOperator";
|
|
3110
|
+
address: string;
|
|
3111
|
+
} | null;
|
|
3112
|
+
}[] | undefined>;
|
|
3113
|
+
} | {
|
|
3114
|
+
data: Partial<NonUndefinedGuard<{
|
|
3115
|
+
spendingApproval: bigint;
|
|
3116
|
+
operatorAddr: string;
|
|
3117
|
+
__typename: "UserMarketOperator";
|
|
3118
|
+
id: string;
|
|
3119
|
+
canExtend: boolean;
|
|
3120
|
+
canExercise: boolean;
|
|
3121
|
+
canTransfer: boolean;
|
|
3122
|
+
canMint: boolean;
|
|
3123
|
+
operator?: {
|
|
3124
|
+
__typename: "MarketOperator";
|
|
3125
|
+
address: string;
|
|
3126
|
+
} | null;
|
|
3127
|
+
}[] | undefined>>;
|
|
3128
|
+
error: null;
|
|
3129
|
+
isError: false;
|
|
3130
|
+
isPending: true;
|
|
3131
|
+
isLoadingError: false;
|
|
3132
|
+
isRefetchError: false;
|
|
3133
|
+
isSuccess: false;
|
|
3134
|
+
isPlaceholderData: false;
|
|
3135
|
+
status: "pending";
|
|
3136
|
+
dataUpdatedAt: number;
|
|
3137
|
+
errorUpdatedAt: number;
|
|
3138
|
+
failureCount: number;
|
|
3139
|
+
failureReason: Error | null;
|
|
3140
|
+
errorUpdateCount: number;
|
|
3141
|
+
isFetched: boolean;
|
|
3142
|
+
isFetchedAfterMount: boolean;
|
|
3143
|
+
isFetching: boolean;
|
|
3144
|
+
isLoading: boolean;
|
|
3145
|
+
isInitialLoading: boolean;
|
|
3146
|
+
isPaused: boolean;
|
|
3147
|
+
isRefetching: boolean;
|
|
3148
|
+
isStale: boolean;
|
|
3149
|
+
isEnabled: boolean;
|
|
3150
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
3151
|
+
spendingApproval: bigint;
|
|
3152
|
+
operatorAddr: string;
|
|
3153
|
+
__typename: "UserMarketOperator";
|
|
3154
|
+
id: string;
|
|
3155
|
+
canExtend: boolean;
|
|
3156
|
+
canExercise: boolean;
|
|
3157
|
+
canTransfer: boolean;
|
|
3158
|
+
canMint: boolean;
|
|
3159
|
+
operator?: {
|
|
3160
|
+
__typename: "MarketOperator";
|
|
3161
|
+
address: string;
|
|
3162
|
+
} | null;
|
|
3163
|
+
}[] | undefined, Error>>;
|
|
3164
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
3165
|
+
promise: Promise<{
|
|
3166
|
+
spendingApproval: bigint;
|
|
3167
|
+
operatorAddr: string;
|
|
3168
|
+
__typename: "UserMarketOperator";
|
|
3169
|
+
id: string;
|
|
3170
|
+
canExtend: boolean;
|
|
3171
|
+
canExercise: boolean;
|
|
3172
|
+
canTransfer: boolean;
|
|
3173
|
+
canMint: boolean;
|
|
3174
|
+
operator?: {
|
|
3175
|
+
__typename: "MarketOperator";
|
|
3176
|
+
address: string;
|
|
3177
|
+
} | null;
|
|
3178
|
+
}[] | undefined>;
|
|
3179
|
+
} | {
|
|
3180
|
+
data: Partial<NonUndefinedGuard<{
|
|
3181
|
+
spendingApproval: bigint;
|
|
3182
|
+
operatorAddr: string;
|
|
3183
|
+
__typename: "UserMarketOperator";
|
|
3184
|
+
id: string;
|
|
3185
|
+
canExtend: boolean;
|
|
3186
|
+
canExercise: boolean;
|
|
3187
|
+
canTransfer: boolean;
|
|
3188
|
+
canMint: boolean;
|
|
3189
|
+
operator?: {
|
|
3190
|
+
__typename: "MarketOperator";
|
|
3191
|
+
address: string;
|
|
3192
|
+
} | null;
|
|
3193
|
+
}[] | undefined>>;
|
|
3194
|
+
isError: false;
|
|
3195
|
+
error: null;
|
|
3196
|
+
isPending: false;
|
|
3197
|
+
isLoading: false;
|
|
3198
|
+
isLoadingError: false;
|
|
3199
|
+
isRefetchError: false;
|
|
3200
|
+
isSuccess: true;
|
|
3201
|
+
isPlaceholderData: true;
|
|
3202
|
+
status: "success";
|
|
3203
|
+
dataUpdatedAt: number;
|
|
3204
|
+
errorUpdatedAt: number;
|
|
3205
|
+
failureCount: number;
|
|
3206
|
+
failureReason: Error | null;
|
|
3207
|
+
errorUpdateCount: number;
|
|
3208
|
+
isFetched: boolean;
|
|
3209
|
+
isFetchedAfterMount: boolean;
|
|
3210
|
+
isFetching: boolean;
|
|
3211
|
+
isInitialLoading: boolean;
|
|
3212
|
+
isPaused: boolean;
|
|
3213
|
+
isRefetching: boolean;
|
|
3214
|
+
isStale: boolean;
|
|
3215
|
+
isEnabled: boolean;
|
|
3216
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
|
|
3217
|
+
spendingApproval: bigint;
|
|
3218
|
+
operatorAddr: string;
|
|
3219
|
+
__typename: "UserMarketOperator";
|
|
3220
|
+
id: string;
|
|
3221
|
+
canExtend: boolean;
|
|
3222
|
+
canExercise: boolean;
|
|
3223
|
+
canTransfer: boolean;
|
|
3224
|
+
canMint: boolean;
|
|
3225
|
+
operator?: {
|
|
3226
|
+
__typename: "MarketOperator";
|
|
3227
|
+
address: string;
|
|
3228
|
+
} | null;
|
|
3229
|
+
}[] | undefined, Error>>;
|
|
3230
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
3231
|
+
promise: Promise<{
|
|
3232
|
+
spendingApproval: bigint;
|
|
3233
|
+
operatorAddr: string;
|
|
3234
|
+
__typename: "UserMarketOperator";
|
|
3235
|
+
id: string;
|
|
3236
|
+
canExtend: boolean;
|
|
3237
|
+
canExercise: boolean;
|
|
3238
|
+
canTransfer: boolean;
|
|
3239
|
+
canMint: boolean;
|
|
3240
|
+
operator?: {
|
|
3241
|
+
__typename: "MarketOperator";
|
|
3242
|
+
address: string;
|
|
3243
|
+
} | null;
|
|
3244
|
+
}[] | undefined>;
|
|
3245
|
+
};
|
|
3246
|
+
//#endregion
|
|
2381
3247
|
//#region src/hooks/pool/useCurrentPrice.d.ts
|
|
2382
3248
|
declare const useCurrentPrice: (poolAddr?: Address) => {
|
|
2383
3249
|
currentPrice: Amount | undefined;
|
|
@@ -2464,7 +3330,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2464
3330
|
isRefetching: boolean;
|
|
2465
3331
|
isStale: boolean;
|
|
2466
3332
|
isEnabled: boolean;
|
|
2467
|
-
refetch: (options?:
|
|
3333
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<readonly {
|
|
2468
3334
|
tickLower: number;
|
|
2469
3335
|
tickUpper: number;
|
|
2470
3336
|
prevTickLower: number;
|
|
@@ -2475,7 +3341,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2475
3341
|
borrowedAmount0: bigint;
|
|
2476
3342
|
borrowedAmount1: bigint;
|
|
2477
3343
|
}[], viem249.ReadContractErrorType>>;
|
|
2478
|
-
fetchStatus:
|
|
3344
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
2479
3345
|
promise: Promise<readonly {
|
|
2480
3346
|
tickLower: number;
|
|
2481
3347
|
tickUpper: number;
|
|
@@ -2487,7 +3353,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2487
3353
|
borrowedAmount0: bigint;
|
|
2488
3354
|
borrowedAmount1: bigint;
|
|
2489
3355
|
}[]>;
|
|
2490
|
-
queryKey:
|
|
3356
|
+
queryKey: _tanstack_query_core0.QueryKey;
|
|
2491
3357
|
data: readonly {
|
|
2492
3358
|
tickLower: number;
|
|
2493
3359
|
tickUpper: number;
|
|
@@ -2522,7 +3388,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2522
3388
|
isRefetching: boolean;
|
|
2523
3389
|
isStale: boolean;
|
|
2524
3390
|
isEnabled: boolean;
|
|
2525
|
-
refetch: (options?:
|
|
3391
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<readonly {
|
|
2526
3392
|
tickLower: number;
|
|
2527
3393
|
tickUpper: number;
|
|
2528
3394
|
prevTickLower: number;
|
|
@@ -2533,7 +3399,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2533
3399
|
borrowedAmount0: bigint;
|
|
2534
3400
|
borrowedAmount1: bigint;
|
|
2535
3401
|
}[], viem249.ReadContractErrorType>>;
|
|
2536
|
-
fetchStatus:
|
|
3402
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
2537
3403
|
promise: Promise<readonly {
|
|
2538
3404
|
tickLower: number;
|
|
2539
3405
|
tickUpper: number;
|
|
@@ -2545,7 +3411,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2545
3411
|
borrowedAmount0: bigint;
|
|
2546
3412
|
borrowedAmount1: bigint;
|
|
2547
3413
|
}[]>;
|
|
2548
|
-
queryKey:
|
|
3414
|
+
queryKey: _tanstack_query_core0.QueryKey;
|
|
2549
3415
|
data: readonly {
|
|
2550
3416
|
tickLower: number;
|
|
2551
3417
|
tickUpper: number;
|
|
@@ -2580,7 +3446,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2580
3446
|
isRefetching: boolean;
|
|
2581
3447
|
isStale: boolean;
|
|
2582
3448
|
isEnabled: boolean;
|
|
2583
|
-
refetch: (options?:
|
|
3449
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<readonly {
|
|
2584
3450
|
tickLower: number;
|
|
2585
3451
|
tickUpper: number;
|
|
2586
3452
|
prevTickLower: number;
|
|
@@ -2591,7 +3457,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2591
3457
|
borrowedAmount0: bigint;
|
|
2592
3458
|
borrowedAmount1: bigint;
|
|
2593
3459
|
}[], viem249.ReadContractErrorType>>;
|
|
2594
|
-
fetchStatus:
|
|
3460
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
2595
3461
|
promise: Promise<readonly {
|
|
2596
3462
|
tickLower: number;
|
|
2597
3463
|
tickUpper: number;
|
|
@@ -2603,7 +3469,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2603
3469
|
borrowedAmount0: bigint;
|
|
2604
3470
|
borrowedAmount1: bigint;
|
|
2605
3471
|
}[]>;
|
|
2606
|
-
queryKey:
|
|
3472
|
+
queryKey: _tanstack_query_core0.QueryKey;
|
|
2607
3473
|
data: readonly {
|
|
2608
3474
|
tickLower: number;
|
|
2609
3475
|
tickUpper: number;
|
|
@@ -2638,7 +3504,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2638
3504
|
isRefetching: boolean;
|
|
2639
3505
|
isStale: boolean;
|
|
2640
3506
|
isEnabled: boolean;
|
|
2641
|
-
refetch: (options?:
|
|
3507
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<readonly {
|
|
2642
3508
|
tickLower: number;
|
|
2643
3509
|
tickUpper: number;
|
|
2644
3510
|
prevTickLower: number;
|
|
@@ -2649,7 +3515,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2649
3515
|
borrowedAmount0: bigint;
|
|
2650
3516
|
borrowedAmount1: bigint;
|
|
2651
3517
|
}[], viem249.ReadContractErrorType>>;
|
|
2652
|
-
fetchStatus:
|
|
3518
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
2653
3519
|
promise: Promise<readonly {
|
|
2654
3520
|
tickLower: number;
|
|
2655
3521
|
tickUpper: number;
|
|
@@ -2661,7 +3527,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2661
3527
|
borrowedAmount0: bigint;
|
|
2662
3528
|
borrowedAmount1: bigint;
|
|
2663
3529
|
}[]>;
|
|
2664
|
-
queryKey:
|
|
3530
|
+
queryKey: _tanstack_query_core0.QueryKey;
|
|
2665
3531
|
data: readonly {
|
|
2666
3532
|
tickLower: number;
|
|
2667
3533
|
tickUpper: number;
|
|
@@ -2696,7 +3562,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2696
3562
|
isRefetching: boolean;
|
|
2697
3563
|
isStale: boolean;
|
|
2698
3564
|
isEnabled: boolean;
|
|
2699
|
-
refetch: (options?:
|
|
3565
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<readonly {
|
|
2700
3566
|
tickLower: number;
|
|
2701
3567
|
tickUpper: number;
|
|
2702
3568
|
prevTickLower: number;
|
|
@@ -2707,7 +3573,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2707
3573
|
borrowedAmount0: bigint;
|
|
2708
3574
|
borrowedAmount1: bigint;
|
|
2709
3575
|
}[], viem249.ReadContractErrorType>>;
|
|
2710
|
-
fetchStatus:
|
|
3576
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
2711
3577
|
promise: Promise<readonly {
|
|
2712
3578
|
tickLower: number;
|
|
2713
3579
|
tickUpper: number;
|
|
@@ -2719,7 +3585,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2719
3585
|
borrowedAmount0: bigint;
|
|
2720
3586
|
borrowedAmount1: bigint;
|
|
2721
3587
|
}[]>;
|
|
2722
|
-
queryKey:
|
|
3588
|
+
queryKey: _tanstack_query_core0.QueryKey;
|
|
2723
3589
|
data: readonly {
|
|
2724
3590
|
tickLower: number;
|
|
2725
3591
|
tickUpper: number;
|
|
@@ -2754,7 +3620,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2754
3620
|
isRefetching: boolean;
|
|
2755
3621
|
isStale: boolean;
|
|
2756
3622
|
isEnabled: boolean;
|
|
2757
|
-
refetch: (options?:
|
|
3623
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<readonly {
|
|
2758
3624
|
tickLower: number;
|
|
2759
3625
|
tickUpper: number;
|
|
2760
3626
|
prevTickLower: number;
|
|
@@ -2765,7 +3631,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2765
3631
|
borrowedAmount0: bigint;
|
|
2766
3632
|
borrowedAmount1: bigint;
|
|
2767
3633
|
}[], viem249.ReadContractErrorType>>;
|
|
2768
|
-
fetchStatus:
|
|
3634
|
+
fetchStatus: _tanstack_query_core0.FetchStatus;
|
|
2769
3635
|
promise: Promise<readonly {
|
|
2770
3636
|
tickLower: number;
|
|
2771
3637
|
tickUpper: number;
|
|
@@ -2777,7 +3643,7 @@ declare const useLiquidityBlocks: (vaultAddr?: Address) => {
|
|
|
2777
3643
|
borrowedAmount0: bigint;
|
|
2778
3644
|
borrowedAmount1: bigint;
|
|
2779
3645
|
}[]>;
|
|
2780
|
-
queryKey:
|
|
3646
|
+
queryKey: _tanstack_query_core0.QueryKey;
|
|
2781
3647
|
data: readonly {
|
|
2782
3648
|
tickLower: number;
|
|
2783
3649
|
tickUpper: number;
|
|
@@ -2837,7 +3703,7 @@ declare const useVaultTVL: (vaultAddr?: Address) => {
|
|
|
2837
3703
|
borrowedAmount0: Amount;
|
|
2838
3704
|
borrowedAmount1: Amount;
|
|
2839
3705
|
blocksCount: bigint;
|
|
2840
|
-
refetch: (options?:
|
|
3706
|
+
refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<readonly [bigint, bigint, bigint, bigint, bigint, bigint, bigint], viem249.ReadContractErrorType>>;
|
|
2841
3707
|
};
|
|
2842
3708
|
//#endregion
|
|
2843
3709
|
//#region src/hooks/useLens.d.ts
|
|
@@ -29159,5 +30025,5 @@ declare const useLens: () => {
|
|
|
29159
30025
|
} | undefined;
|
|
29160
30026
|
};
|
|
29161
30027
|
//#endregion
|
|
29162
|
-
export { LiquidityBlockData, OptionData, TimelockMarketProvider, UniswapPoolData, batchGetAmountsFromLiquidity, useActiveUserOptions, useBurnLiquidity, useClosedUserOptions, useCurrentMarket, useCurrentPrice, useCurrentTick, useExerciseOption, useExtendOption, useLens, useLiquidityBlocks, useMarketData, useMaxPositionSize, useMintLiquidity, useMintOption, useOptionPnl, useOptionPremium, usePoolData, usePriceAtTick, usePriceHistory, useTimelockConfig, useVaultData, useVaultTVL };
|
|
30028
|
+
export { LiquidityBlockData, OptionData, TimelockMarketProvider, UniswapPoolData, batchGetAmountsFromLiquidity, useActiveUserOptions, useBurnLiquidity, useClosedUserOptions, useCurrentMarket, useCurrentPrice, useCurrentTick, useExerciseOption, useExtendOption, useLens, useLiquidityBlocks, useMarketData, useMaxPositionSize, useMintLiquidity, useMintOption, useOptionPnl, useOptionPremium, usePoolData, usePriceAtTick, usePriceHistory, useTimelockConfig, useUserOperators, useVaultData, useVaultTVL };
|
|
29163
30029
|
//# sourceMappingURL=client.d.cts.map
|