timelock-sdk 0.0.177 → 0.0.179

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.
@@ -49162,7 +49162,6 @@ declare const useMarketVolume: (marketAddr: Address | undefined) => _tanstack_re
49162
49162
  }, Error>;
49163
49163
  //#endregion
49164
49164
  //#region src/lib/numberUtils.d.ts
49165
- declare const EMPTY_ARRAY: never[];
49166
49165
  type Amount = {
49167
49166
  scaled: bigint;
49168
49167
  unscaled: Big;
@@ -49371,3891 +49370,224 @@ declare const useMintOption: (marketAddr: Address | undefined) => _tanstack_reac
49371
49370
  //#endregion
49372
49371
  //#region src/hooks/options/useUserOptions.d.ts
49373
49372
  type OptionData = ReturnType<typeof useUserOptions>['data'][0];
49374
- declare const useUserOptions: (userAddr: Address | undefined, marketAddr: Address | "*" | undefined, active?: boolean) => {
49375
- error: Error;
49376
- isError: true;
49377
- isPending: false;
49378
- isLoading: false;
49379
- isLoadingError: false;
49380
- isRefetchError: true;
49381
- isSuccess: false;
49382
- isPlaceholderData: false;
49383
- status: "error";
49384
- dataUpdatedAt: number;
49385
- errorUpdatedAt: number;
49386
- failureCount: number;
49387
- failureReason: Error | null;
49388
- errorUpdateCount: number;
49389
- isFetched: boolean;
49390
- isFetchedAfterMount: boolean;
49391
- isFetching: boolean;
49392
- isInitialLoading: boolean;
49393
- isPaused: boolean;
49394
- isRefetching: boolean;
49395
- isStale: boolean;
49396
- isEnabled: boolean;
49397
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
49398
- optionId: bigint;
49399
- marketAddr: Address;
49400
- ownerAddr: Address;
49401
- optionType: "CALL" | "PUT";
49402
- createdAt: Date;
49403
- expiresAt: Date;
49404
- premium: bigint;
49405
- protocolFee: bigint;
49406
- realizedPayout: bigint;
49407
- liquiditiesAtOpen: bigint[];
49408
- liquiditiesCurrent: bigint[];
49409
- positionSizeAtOpen: bigint;
49410
- positionSizeCurrent: bigint;
49411
- strikePrice: bigint;
49412
- entryPrice: bigint;
49413
- __typename: "UserOption";
49414
- id: string;
49415
- strikeTick: number;
49416
- startTick: number;
49417
- fullyExercised: boolean;
49418
- owner?: {
49419
- __typename: "TimelockMarketUser";
49420
- address: string;
49421
- } | null;
49422
- market?: {
49423
- __typename: "TimelockMarket";
49424
- address: string;
49425
- } | null;
49426
- }[], Error>>;
49427
- fetchStatus: _tanstack_query_core0.FetchStatus;
49428
- promise: Promise<{
49429
- optionId: bigint;
49430
- marketAddr: Address;
49431
- ownerAddr: Address;
49432
- optionType: "CALL" | "PUT";
49433
- createdAt: Date;
49434
- expiresAt: Date;
49435
- premium: bigint;
49436
- protocolFee: bigint;
49437
- realizedPayout: bigint;
49438
- liquiditiesAtOpen: bigint[];
49439
- liquiditiesCurrent: bigint[];
49440
- positionSizeAtOpen: bigint;
49441
- positionSizeCurrent: bigint;
49442
- strikePrice: bigint;
49443
- entryPrice: bigint;
49444
- __typename: "UserOption";
49445
- id: string;
49446
- strikeTick: number;
49447
- startTick: number;
49448
- fullyExercised: boolean;
49449
- owner?: {
49450
- __typename: "TimelockMarketUser";
49451
- address: string;
49452
- } | null;
49453
- market?: {
49454
- __typename: "TimelockMarket";
49455
- address: string;
49456
- } | null;
49457
- }[]>;
49458
- data: {
49459
- optionId: bigint;
49460
- marketAddr: Address;
49461
- ownerAddr: Address;
49462
- optionType: "CALL" | "PUT";
49463
- createdAt: Date;
49464
- expiresAt: Date;
49465
- premium: bigint;
49466
- protocolFee: bigint;
49467
- realizedPayout: bigint;
49468
- liquiditiesAtOpen: bigint[];
49469
- liquiditiesCurrent: bigint[];
49470
- positionSizeAtOpen: bigint;
49471
- positionSizeCurrent: bigint;
49472
- strikePrice: bigint;
49473
- entryPrice: bigint;
49474
- __typename: "UserOption";
49475
- id: string;
49476
- strikeTick: number;
49477
- startTick: number;
49478
- fullyExercised: boolean;
49479
- owner?: {
49480
- __typename: "TimelockMarketUser";
49481
- address: string;
49482
- } | null;
49483
- market?: {
49484
- __typename: "TimelockMarket";
49485
- address: string;
49486
- } | null;
49487
- }[];
49488
- } | {
49489
- error: null;
49490
- isError: false;
49491
- isPending: false;
49492
- isLoading: false;
49493
- isLoadingError: false;
49494
- isRefetchError: false;
49495
- isSuccess: true;
49496
- isPlaceholderData: false;
49497
- status: "success";
49498
- dataUpdatedAt: number;
49499
- errorUpdatedAt: number;
49500
- failureCount: number;
49501
- failureReason: Error | null;
49502
- errorUpdateCount: number;
49503
- isFetched: boolean;
49504
- isFetchedAfterMount: boolean;
49505
- isFetching: boolean;
49506
- isInitialLoading: boolean;
49507
- isPaused: boolean;
49508
- isRefetching: boolean;
49509
- isStale: boolean;
49510
- isEnabled: boolean;
49511
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
49512
- optionId: bigint;
49513
- marketAddr: Address;
49514
- ownerAddr: Address;
49515
- optionType: "CALL" | "PUT";
49516
- createdAt: Date;
49517
- expiresAt: Date;
49518
- premium: bigint;
49519
- protocolFee: bigint;
49520
- realizedPayout: bigint;
49521
- liquiditiesAtOpen: bigint[];
49522
- liquiditiesCurrent: bigint[];
49523
- positionSizeAtOpen: bigint;
49524
- positionSizeCurrent: bigint;
49525
- strikePrice: bigint;
49526
- entryPrice: bigint;
49527
- __typename: "UserOption";
49528
- id: string;
49529
- strikeTick: number;
49530
- startTick: number;
49531
- fullyExercised: boolean;
49532
- owner?: {
49533
- __typename: "TimelockMarketUser";
49534
- address: string;
49535
- } | null;
49536
- market?: {
49537
- __typename: "TimelockMarket";
49538
- address: string;
49539
- } | null;
49540
- }[], Error>>;
49541
- fetchStatus: _tanstack_query_core0.FetchStatus;
49542
- promise: Promise<{
49543
- optionId: bigint;
49544
- marketAddr: Address;
49545
- ownerAddr: Address;
49546
- optionType: "CALL" | "PUT";
49547
- createdAt: Date;
49548
- expiresAt: Date;
49549
- premium: bigint;
49550
- protocolFee: bigint;
49551
- realizedPayout: bigint;
49552
- liquiditiesAtOpen: bigint[];
49553
- liquiditiesCurrent: bigint[];
49554
- positionSizeAtOpen: bigint;
49555
- positionSizeCurrent: bigint;
49556
- strikePrice: bigint;
49557
- entryPrice: bigint;
49558
- __typename: "UserOption";
49559
- id: string;
49560
- strikeTick: number;
49561
- startTick: number;
49562
- fullyExercised: boolean;
49563
- owner?: {
49564
- __typename: "TimelockMarketUser";
49565
- address: string;
49566
- } | null;
49567
- market?: {
49568
- __typename: "TimelockMarket";
49569
- address: string;
49570
- } | null;
49571
- }[]>;
49572
- data: {
49573
- optionId: bigint;
49574
- marketAddr: Address;
49575
- ownerAddr: Address;
49576
- optionType: "CALL" | "PUT";
49577
- createdAt: Date;
49578
- expiresAt: Date;
49579
- premium: bigint;
49580
- protocolFee: bigint;
49581
- realizedPayout: bigint;
49582
- liquiditiesAtOpen: bigint[];
49583
- liquiditiesCurrent: bigint[];
49584
- positionSizeAtOpen: bigint;
49585
- positionSizeCurrent: bigint;
49586
- strikePrice: bigint;
49587
- entryPrice: bigint;
49588
- __typename: "UserOption";
49589
- id: string;
49590
- strikeTick: number;
49591
- startTick: number;
49592
- fullyExercised: boolean;
49593
- owner?: {
49594
- __typename: "TimelockMarketUser";
49595
- address: string;
49596
- } | null;
49597
- market?: {
49598
- __typename: "TimelockMarket";
49599
- address: string;
49600
- } | null;
49601
- }[];
49602
- } | {
49603
- error: Error;
49604
- isError: true;
49605
- isPending: false;
49606
- isLoading: false;
49607
- isLoadingError: true;
49608
- isRefetchError: false;
49609
- isSuccess: false;
49610
- isPlaceholderData: false;
49611
- status: "error";
49612
- dataUpdatedAt: number;
49613
- errorUpdatedAt: number;
49614
- failureCount: number;
49615
- failureReason: Error | null;
49616
- errorUpdateCount: number;
49617
- isFetched: boolean;
49618
- isFetchedAfterMount: boolean;
49619
- isFetching: boolean;
49620
- isInitialLoading: boolean;
49621
- isPaused: boolean;
49622
- isRefetching: boolean;
49623
- isStale: boolean;
49624
- isEnabled: boolean;
49625
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
49626
- optionId: bigint;
49627
- marketAddr: Address;
49628
- ownerAddr: Address;
49629
- optionType: "CALL" | "PUT";
49630
- createdAt: Date;
49631
- expiresAt: Date;
49632
- premium: bigint;
49633
- protocolFee: bigint;
49634
- realizedPayout: bigint;
49635
- liquiditiesAtOpen: bigint[];
49636
- liquiditiesCurrent: bigint[];
49637
- positionSizeAtOpen: bigint;
49638
- positionSizeCurrent: bigint;
49639
- strikePrice: bigint;
49640
- entryPrice: bigint;
49641
- __typename: "UserOption";
49642
- id: string;
49643
- strikeTick: number;
49644
- startTick: number;
49645
- fullyExercised: boolean;
49646
- owner?: {
49647
- __typename: "TimelockMarketUser";
49648
- address: string;
49649
- } | null;
49650
- market?: {
49651
- __typename: "TimelockMarket";
49652
- address: string;
49653
- } | null;
49654
- }[], Error>>;
49655
- fetchStatus: _tanstack_query_core0.FetchStatus;
49656
- promise: Promise<{
49657
- optionId: bigint;
49658
- marketAddr: Address;
49659
- ownerAddr: Address;
49660
- optionType: "CALL" | "PUT";
49661
- createdAt: Date;
49662
- expiresAt: Date;
49663
- premium: bigint;
49664
- protocolFee: bigint;
49665
- realizedPayout: bigint;
49666
- liquiditiesAtOpen: bigint[];
49667
- liquiditiesCurrent: bigint[];
49668
- positionSizeAtOpen: bigint;
49669
- positionSizeCurrent: bigint;
49670
- strikePrice: bigint;
49671
- entryPrice: bigint;
49672
- __typename: "UserOption";
49673
- id: string;
49674
- strikeTick: number;
49675
- startTick: number;
49676
- fullyExercised: boolean;
49677
- owner?: {
49678
- __typename: "TimelockMarketUser";
49679
- address: string;
49680
- } | null;
49681
- market?: {
49682
- __typename: "TimelockMarket";
49683
- address: string;
49684
- } | null;
49685
- }[]>;
49686
- data: {
49687
- optionId: bigint;
49688
- marketAddr: Address;
49689
- ownerAddr: Address;
49690
- optionType: "CALL" | "PUT";
49691
- createdAt: Date;
49692
- expiresAt: Date;
49693
- premium: bigint;
49694
- protocolFee: bigint;
49695
- realizedPayout: bigint;
49696
- liquiditiesAtOpen: bigint[];
49697
- liquiditiesCurrent: bigint[];
49698
- positionSizeAtOpen: bigint;
49699
- positionSizeCurrent: bigint;
49700
- strikePrice: bigint;
49701
- entryPrice: bigint;
49702
- __typename: "UserOption";
49703
- id: string;
49704
- strikeTick: number;
49705
- startTick: number;
49706
- fullyExercised: boolean;
49707
- owner?: {
49708
- __typename: "TimelockMarketUser";
49709
- address: string;
49710
- } | null;
49711
- market?: {
49712
- __typename: "TimelockMarket";
49713
- address: string;
49714
- } | null;
49715
- }[];
49716
- } | {
49717
- error: null;
49718
- isError: false;
49719
- isPending: true;
49720
- isLoading: true;
49721
- isLoadingError: false;
49722
- isRefetchError: false;
49723
- isSuccess: false;
49724
- isPlaceholderData: false;
49725
- status: "pending";
49726
- dataUpdatedAt: number;
49727
- errorUpdatedAt: number;
49728
- failureCount: number;
49729
- failureReason: Error | null;
49730
- errorUpdateCount: number;
49731
- isFetched: boolean;
49732
- isFetchedAfterMount: boolean;
49733
- isFetching: boolean;
49734
- isInitialLoading: boolean;
49735
- isPaused: boolean;
49736
- isRefetching: boolean;
49737
- isStale: boolean;
49738
- isEnabled: boolean;
49739
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
49740
- optionId: bigint;
49741
- marketAddr: Address;
49742
- ownerAddr: Address;
49743
- optionType: "CALL" | "PUT";
49744
- createdAt: Date;
49745
- expiresAt: Date;
49746
- premium: bigint;
49747
- protocolFee: bigint;
49748
- realizedPayout: bigint;
49749
- liquiditiesAtOpen: bigint[];
49750
- liquiditiesCurrent: bigint[];
49751
- positionSizeAtOpen: bigint;
49752
- positionSizeCurrent: bigint;
49753
- strikePrice: bigint;
49754
- entryPrice: bigint;
49755
- __typename: "UserOption";
49756
- id: string;
49757
- strikeTick: number;
49758
- startTick: number;
49759
- fullyExercised: boolean;
49760
- owner?: {
49761
- __typename: "TimelockMarketUser";
49762
- address: string;
49763
- } | null;
49764
- market?: {
49765
- __typename: "TimelockMarket";
49766
- address: string;
49767
- } | null;
49768
- }[], Error>>;
49769
- fetchStatus: _tanstack_query_core0.FetchStatus;
49770
- promise: Promise<{
49771
- optionId: bigint;
49772
- marketAddr: Address;
49773
- ownerAddr: Address;
49774
- optionType: "CALL" | "PUT";
49775
- createdAt: Date;
49776
- expiresAt: Date;
49777
- premium: bigint;
49778
- protocolFee: bigint;
49779
- realizedPayout: bigint;
49780
- liquiditiesAtOpen: bigint[];
49781
- liquiditiesCurrent: bigint[];
49782
- positionSizeAtOpen: bigint;
49783
- positionSizeCurrent: bigint;
49784
- strikePrice: bigint;
49785
- entryPrice: bigint;
49786
- __typename: "UserOption";
49787
- id: string;
49788
- strikeTick: number;
49789
- startTick: number;
49790
- fullyExercised: boolean;
49791
- owner?: {
49792
- __typename: "TimelockMarketUser";
49793
- address: string;
49794
- } | null;
49795
- market?: {
49796
- __typename: "TimelockMarket";
49797
- address: string;
49798
- } | null;
49799
- }[]>;
49800
- data: {
49801
- optionId: bigint;
49802
- marketAddr: Address;
49803
- ownerAddr: Address;
49804
- optionType: "CALL" | "PUT";
49805
- createdAt: Date;
49806
- expiresAt: Date;
49807
- premium: bigint;
49808
- protocolFee: bigint;
49809
- realizedPayout: bigint;
49810
- liquiditiesAtOpen: bigint[];
49811
- liquiditiesCurrent: bigint[];
49812
- positionSizeAtOpen: bigint;
49813
- positionSizeCurrent: bigint;
49814
- strikePrice: bigint;
49815
- entryPrice: bigint;
49816
- __typename: "UserOption";
49817
- id: string;
49818
- strikeTick: number;
49819
- startTick: number;
49820
- fullyExercised: boolean;
49821
- owner?: {
49822
- __typename: "TimelockMarketUser";
49823
- address: string;
49824
- } | null;
49825
- market?: {
49826
- __typename: "TimelockMarket";
49827
- address: string;
49828
- } | null;
49829
- }[];
49830
- } | {
49831
- error: null;
49832
- isError: false;
49833
- isPending: true;
49834
- isLoadingError: false;
49835
- isRefetchError: false;
49836
- isSuccess: false;
49837
- isPlaceholderData: false;
49838
- status: "pending";
49839
- dataUpdatedAt: number;
49840
- errorUpdatedAt: number;
49841
- failureCount: number;
49842
- failureReason: Error | null;
49843
- errorUpdateCount: number;
49844
- isFetched: boolean;
49845
- isFetchedAfterMount: boolean;
49846
- isFetching: boolean;
49847
- isLoading: boolean;
49848
- isInitialLoading: boolean;
49849
- isPaused: boolean;
49850
- isRefetching: boolean;
49851
- isStale: boolean;
49852
- isEnabled: boolean;
49853
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
49854
- optionId: bigint;
49855
- marketAddr: Address;
49856
- ownerAddr: Address;
49857
- optionType: "CALL" | "PUT";
49858
- createdAt: Date;
49859
- expiresAt: Date;
49860
- premium: bigint;
49861
- protocolFee: bigint;
49862
- realizedPayout: bigint;
49863
- liquiditiesAtOpen: bigint[];
49864
- liquiditiesCurrent: bigint[];
49865
- positionSizeAtOpen: bigint;
49866
- positionSizeCurrent: bigint;
49867
- strikePrice: bigint;
49868
- entryPrice: bigint;
49869
- __typename: "UserOption";
49870
- id: string;
49871
- strikeTick: number;
49872
- startTick: number;
49873
- fullyExercised: boolean;
49874
- owner?: {
49875
- __typename: "TimelockMarketUser";
49876
- address: string;
49877
- } | null;
49878
- market?: {
49879
- __typename: "TimelockMarket";
49880
- address: string;
49881
- } | null;
49882
- }[], Error>>;
49883
- fetchStatus: _tanstack_query_core0.FetchStatus;
49884
- promise: Promise<{
49885
- optionId: bigint;
49886
- marketAddr: Address;
49887
- ownerAddr: Address;
49888
- optionType: "CALL" | "PUT";
49889
- createdAt: Date;
49890
- expiresAt: Date;
49891
- premium: bigint;
49892
- protocolFee: bigint;
49893
- realizedPayout: bigint;
49894
- liquiditiesAtOpen: bigint[];
49895
- liquiditiesCurrent: bigint[];
49896
- positionSizeAtOpen: bigint;
49897
- positionSizeCurrent: bigint;
49898
- strikePrice: bigint;
49899
- entryPrice: bigint;
49900
- __typename: "UserOption";
49901
- id: string;
49902
- strikeTick: number;
49903
- startTick: number;
49904
- fullyExercised: boolean;
49905
- owner?: {
49906
- __typename: "TimelockMarketUser";
49907
- address: string;
49908
- } | null;
49909
- market?: {
49910
- __typename: "TimelockMarket";
49911
- address: string;
49912
- } | null;
49913
- }[]>;
49914
- data: {
49915
- optionId: bigint;
49916
- marketAddr: Address;
49917
- ownerAddr: Address;
49918
- optionType: "CALL" | "PUT";
49919
- createdAt: Date;
49920
- expiresAt: Date;
49921
- premium: bigint;
49922
- protocolFee: bigint;
49923
- realizedPayout: bigint;
49924
- liquiditiesAtOpen: bigint[];
49925
- liquiditiesCurrent: bigint[];
49926
- positionSizeAtOpen: bigint;
49927
- positionSizeCurrent: bigint;
49928
- strikePrice: bigint;
49929
- entryPrice: bigint;
49930
- __typename: "UserOption";
49931
- id: string;
49932
- strikeTick: number;
49933
- startTick: number;
49934
- fullyExercised: boolean;
49935
- owner?: {
49936
- __typename: "TimelockMarketUser";
49937
- address: string;
49938
- } | null;
49939
- market?: {
49940
- __typename: "TimelockMarket";
49941
- address: string;
49942
- } | null;
49943
- }[];
49944
- } | {
49945
- isError: false;
49946
- error: null;
49947
- isPending: false;
49948
- isLoading: false;
49949
- isLoadingError: false;
49950
- isRefetchError: false;
49951
- isSuccess: true;
49952
- isPlaceholderData: true;
49953
- status: "success";
49954
- dataUpdatedAt: number;
49955
- errorUpdatedAt: number;
49956
- failureCount: number;
49957
- failureReason: Error | null;
49958
- errorUpdateCount: number;
49959
- isFetched: boolean;
49960
- isFetchedAfterMount: boolean;
49961
- isFetching: boolean;
49962
- isInitialLoading: boolean;
49963
- isPaused: boolean;
49964
- isRefetching: boolean;
49965
- isStale: boolean;
49966
- isEnabled: boolean;
49967
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
49968
- optionId: bigint;
49969
- marketAddr: Address;
49970
- ownerAddr: Address;
49971
- optionType: "CALL" | "PUT";
49972
- createdAt: Date;
49973
- expiresAt: Date;
49974
- premium: bigint;
49975
- protocolFee: bigint;
49976
- realizedPayout: bigint;
49977
- liquiditiesAtOpen: bigint[];
49978
- liquiditiesCurrent: bigint[];
49979
- positionSizeAtOpen: bigint;
49980
- positionSizeCurrent: bigint;
49981
- strikePrice: bigint;
49982
- entryPrice: bigint;
49983
- __typename: "UserOption";
49984
- id: string;
49985
- strikeTick: number;
49986
- startTick: number;
49987
- fullyExercised: boolean;
49988
- owner?: {
49989
- __typename: "TimelockMarketUser";
49990
- address: string;
49991
- } | null;
49992
- market?: {
49993
- __typename: "TimelockMarket";
49994
- address: string;
49995
- } | null;
49996
- }[], Error>>;
49997
- fetchStatus: _tanstack_query_core0.FetchStatus;
49998
- promise: Promise<{
49999
- optionId: bigint;
50000
- marketAddr: Address;
50001
- ownerAddr: Address;
50002
- optionType: "CALL" | "PUT";
50003
- createdAt: Date;
50004
- expiresAt: Date;
50005
- premium: bigint;
50006
- protocolFee: bigint;
50007
- realizedPayout: bigint;
50008
- liquiditiesAtOpen: bigint[];
50009
- liquiditiesCurrent: bigint[];
50010
- positionSizeAtOpen: bigint;
50011
- positionSizeCurrent: bigint;
50012
- strikePrice: bigint;
50013
- entryPrice: bigint;
50014
- __typename: "UserOption";
50015
- id: string;
50016
- strikeTick: number;
50017
- startTick: number;
50018
- fullyExercised: boolean;
50019
- owner?: {
50020
- __typename: "TimelockMarketUser";
50021
- address: string;
50022
- } | null;
50023
- market?: {
50024
- __typename: "TimelockMarket";
50025
- address: string;
50026
- } | null;
50027
- }[]>;
50028
- data: {
50029
- optionId: bigint;
50030
- marketAddr: Address;
50031
- ownerAddr: Address;
50032
- optionType: "CALL" | "PUT";
50033
- createdAt: Date;
50034
- expiresAt: Date;
50035
- premium: bigint;
50036
- protocolFee: bigint;
50037
- realizedPayout: bigint;
50038
- liquiditiesAtOpen: bigint[];
50039
- liquiditiesCurrent: bigint[];
50040
- positionSizeAtOpen: bigint;
50041
- positionSizeCurrent: bigint;
50042
- strikePrice: bigint;
50043
- entryPrice: bigint;
50044
- __typename: "UserOption";
50045
- id: string;
50046
- strikeTick: number;
50047
- startTick: number;
50048
- fullyExercised: boolean;
50049
- owner?: {
50050
- __typename: "TimelockMarketUser";
50051
- address: string;
50052
- } | null;
50053
- market?: {
50054
- __typename: "TimelockMarket";
50055
- address: string;
50056
- } | null;
50057
- }[];
50058
- };
50059
- declare const useActiveUserOptions: (userAddr?: Address, marketAddr?: Address | "*") => {
50060
- error: Error;
50061
- isError: true;
50062
- isPending: false;
50063
- isLoading: false;
50064
- isLoadingError: false;
50065
- isRefetchError: true;
50066
- isSuccess: false;
50067
- isPlaceholderData: false;
50068
- status: "error";
50069
- dataUpdatedAt: number;
50070
- errorUpdatedAt: number;
50071
- failureCount: number;
50072
- failureReason: Error | null;
50073
- errorUpdateCount: number;
50074
- isFetched: boolean;
50075
- isFetchedAfterMount: boolean;
50076
- isFetching: boolean;
50077
- isInitialLoading: boolean;
50078
- isPaused: boolean;
50079
- isRefetching: boolean;
50080
- isStale: boolean;
50081
- isEnabled: boolean;
50082
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
50083
- optionId: bigint;
50084
- marketAddr: Address;
50085
- ownerAddr: Address;
50086
- optionType: "CALL" | "PUT";
50087
- createdAt: Date;
50088
- expiresAt: Date;
50089
- premium: bigint;
50090
- protocolFee: bigint;
50091
- realizedPayout: bigint;
50092
- liquiditiesAtOpen: bigint[];
50093
- liquiditiesCurrent: bigint[];
50094
- positionSizeAtOpen: bigint;
50095
- positionSizeCurrent: bigint;
50096
- strikePrice: bigint;
50097
- entryPrice: bigint;
50098
- __typename: "UserOption";
50099
- id: string;
50100
- strikeTick: number;
50101
- startTick: number;
50102
- fullyExercised: boolean;
50103
- owner?: {
50104
- __typename: "TimelockMarketUser";
50105
- address: string;
50106
- } | null;
50107
- market?: {
50108
- __typename: "TimelockMarket";
50109
- address: string;
50110
- } | null;
50111
- }[], Error>>;
50112
- fetchStatus: _tanstack_query_core0.FetchStatus;
50113
- promise: Promise<{
50114
- optionId: bigint;
50115
- marketAddr: Address;
50116
- ownerAddr: Address;
50117
- optionType: "CALL" | "PUT";
50118
- createdAt: Date;
50119
- expiresAt: Date;
50120
- premium: bigint;
50121
- protocolFee: bigint;
50122
- realizedPayout: bigint;
50123
- liquiditiesAtOpen: bigint[];
50124
- liquiditiesCurrent: bigint[];
50125
- positionSizeAtOpen: bigint;
50126
- positionSizeCurrent: bigint;
50127
- strikePrice: bigint;
50128
- entryPrice: bigint;
50129
- __typename: "UserOption";
50130
- id: string;
50131
- strikeTick: number;
50132
- startTick: number;
50133
- fullyExercised: boolean;
50134
- owner?: {
50135
- __typename: "TimelockMarketUser";
50136
- address: string;
50137
- } | null;
50138
- market?: {
50139
- __typename: "TimelockMarket";
50140
- address: string;
50141
- } | null;
50142
- }[]>;
50143
- data: {
50144
- optionId: bigint;
50145
- marketAddr: Address;
50146
- ownerAddr: Address;
50147
- optionType: "CALL" | "PUT";
50148
- createdAt: Date;
50149
- expiresAt: Date;
50150
- premium: bigint;
50151
- protocolFee: bigint;
50152
- realizedPayout: bigint;
50153
- liquiditiesAtOpen: bigint[];
50154
- liquiditiesCurrent: bigint[];
50155
- positionSizeAtOpen: bigint;
50156
- positionSizeCurrent: bigint;
50157
- strikePrice: bigint;
50158
- entryPrice: bigint;
50159
- __typename: "UserOption";
50160
- id: string;
50161
- strikeTick: number;
50162
- startTick: number;
50163
- fullyExercised: boolean;
50164
- owner?: {
50165
- __typename: "TimelockMarketUser";
50166
- address: string;
50167
- } | null;
50168
- market?: {
50169
- __typename: "TimelockMarket";
50170
- address: string;
50171
- } | null;
50172
- }[];
50173
- } | {
50174
- error: null;
50175
- isError: false;
50176
- isPending: false;
50177
- isLoading: false;
50178
- isLoadingError: false;
50179
- isRefetchError: false;
50180
- isSuccess: true;
50181
- isPlaceholderData: false;
50182
- status: "success";
50183
- dataUpdatedAt: number;
50184
- errorUpdatedAt: number;
50185
- failureCount: number;
50186
- failureReason: Error | null;
50187
- errorUpdateCount: number;
50188
- isFetched: boolean;
50189
- isFetchedAfterMount: boolean;
50190
- isFetching: boolean;
50191
- isInitialLoading: boolean;
50192
- isPaused: boolean;
50193
- isRefetching: boolean;
50194
- isStale: boolean;
50195
- isEnabled: boolean;
50196
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
50197
- optionId: bigint;
50198
- marketAddr: Address;
50199
- ownerAddr: Address;
50200
- optionType: "CALL" | "PUT";
50201
- createdAt: Date;
50202
- expiresAt: Date;
50203
- premium: bigint;
50204
- protocolFee: bigint;
50205
- realizedPayout: bigint;
50206
- liquiditiesAtOpen: bigint[];
50207
- liquiditiesCurrent: bigint[];
50208
- positionSizeAtOpen: bigint;
50209
- positionSizeCurrent: bigint;
50210
- strikePrice: bigint;
50211
- entryPrice: bigint;
50212
- __typename: "UserOption";
50213
- id: string;
50214
- strikeTick: number;
50215
- startTick: number;
50216
- fullyExercised: boolean;
50217
- owner?: {
50218
- __typename: "TimelockMarketUser";
50219
- address: string;
50220
- } | null;
50221
- market?: {
50222
- __typename: "TimelockMarket";
50223
- address: string;
50224
- } | null;
50225
- }[], Error>>;
50226
- fetchStatus: _tanstack_query_core0.FetchStatus;
50227
- promise: Promise<{
50228
- optionId: bigint;
50229
- marketAddr: Address;
50230
- ownerAddr: Address;
50231
- optionType: "CALL" | "PUT";
50232
- createdAt: Date;
50233
- expiresAt: Date;
50234
- premium: bigint;
50235
- protocolFee: bigint;
50236
- realizedPayout: bigint;
50237
- liquiditiesAtOpen: bigint[];
50238
- liquiditiesCurrent: bigint[];
50239
- positionSizeAtOpen: bigint;
50240
- positionSizeCurrent: bigint;
50241
- strikePrice: bigint;
50242
- entryPrice: bigint;
50243
- __typename: "UserOption";
50244
- id: string;
50245
- strikeTick: number;
50246
- startTick: number;
50247
- fullyExercised: boolean;
50248
- owner?: {
50249
- __typename: "TimelockMarketUser";
50250
- address: string;
50251
- } | null;
50252
- market?: {
50253
- __typename: "TimelockMarket";
50254
- address: string;
50255
- } | null;
50256
- }[]>;
50257
- data: {
50258
- optionId: bigint;
50259
- marketAddr: Address;
50260
- ownerAddr: Address;
50261
- optionType: "CALL" | "PUT";
50262
- createdAt: Date;
50263
- expiresAt: Date;
50264
- premium: bigint;
50265
- protocolFee: bigint;
50266
- realizedPayout: bigint;
50267
- liquiditiesAtOpen: bigint[];
50268
- liquiditiesCurrent: bigint[];
50269
- positionSizeAtOpen: bigint;
50270
- positionSizeCurrent: bigint;
50271
- strikePrice: bigint;
50272
- entryPrice: bigint;
50273
- __typename: "UserOption";
50274
- id: string;
50275
- strikeTick: number;
50276
- startTick: number;
50277
- fullyExercised: boolean;
50278
- owner?: {
50279
- __typename: "TimelockMarketUser";
50280
- address: string;
50281
- } | null;
50282
- market?: {
50283
- __typename: "TimelockMarket";
50284
- address: string;
50285
- } | null;
50286
- }[];
50287
- } | {
50288
- error: Error;
50289
- isError: true;
50290
- isPending: false;
50291
- isLoading: false;
50292
- isLoadingError: true;
50293
- isRefetchError: false;
50294
- isSuccess: false;
50295
- isPlaceholderData: false;
50296
- status: "error";
50297
- dataUpdatedAt: number;
50298
- errorUpdatedAt: number;
50299
- failureCount: number;
50300
- failureReason: Error | null;
50301
- errorUpdateCount: number;
50302
- isFetched: boolean;
50303
- isFetchedAfterMount: boolean;
50304
- isFetching: boolean;
50305
- isInitialLoading: boolean;
50306
- isPaused: boolean;
50307
- isRefetching: boolean;
50308
- isStale: boolean;
50309
- isEnabled: boolean;
50310
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
50311
- optionId: bigint;
50312
- marketAddr: Address;
50313
- ownerAddr: Address;
50314
- optionType: "CALL" | "PUT";
50315
- createdAt: Date;
50316
- expiresAt: Date;
50317
- premium: bigint;
50318
- protocolFee: bigint;
50319
- realizedPayout: bigint;
50320
- liquiditiesAtOpen: bigint[];
50321
- liquiditiesCurrent: bigint[];
50322
- positionSizeAtOpen: bigint;
50323
- positionSizeCurrent: bigint;
50324
- strikePrice: bigint;
50325
- entryPrice: bigint;
50326
- __typename: "UserOption";
50327
- id: string;
50328
- strikeTick: number;
50329
- startTick: number;
50330
- fullyExercised: boolean;
50331
- owner?: {
50332
- __typename: "TimelockMarketUser";
50333
- address: string;
50334
- } | null;
50335
- market?: {
50336
- __typename: "TimelockMarket";
50337
- address: string;
50338
- } | null;
50339
- }[], Error>>;
50340
- fetchStatus: _tanstack_query_core0.FetchStatus;
50341
- promise: Promise<{
50342
- optionId: bigint;
50343
- marketAddr: Address;
50344
- ownerAddr: Address;
50345
- optionType: "CALL" | "PUT";
50346
- createdAt: Date;
50347
- expiresAt: Date;
50348
- premium: bigint;
50349
- protocolFee: bigint;
50350
- realizedPayout: bigint;
50351
- liquiditiesAtOpen: bigint[];
50352
- liquiditiesCurrent: bigint[];
50353
- positionSizeAtOpen: bigint;
50354
- positionSizeCurrent: bigint;
50355
- strikePrice: bigint;
50356
- entryPrice: bigint;
50357
- __typename: "UserOption";
50358
- id: string;
50359
- strikeTick: number;
50360
- startTick: number;
50361
- fullyExercised: boolean;
50362
- owner?: {
50363
- __typename: "TimelockMarketUser";
50364
- address: string;
50365
- } | null;
50366
- market?: {
50367
- __typename: "TimelockMarket";
50368
- address: string;
50369
- } | null;
50370
- }[]>;
50371
- data: {
50372
- optionId: bigint;
50373
- marketAddr: Address;
50374
- ownerAddr: Address;
50375
- optionType: "CALL" | "PUT";
50376
- createdAt: Date;
50377
- expiresAt: Date;
50378
- premium: bigint;
50379
- protocolFee: bigint;
50380
- realizedPayout: bigint;
50381
- liquiditiesAtOpen: bigint[];
50382
- liquiditiesCurrent: bigint[];
50383
- positionSizeAtOpen: bigint;
50384
- positionSizeCurrent: bigint;
50385
- strikePrice: bigint;
50386
- entryPrice: bigint;
50387
- __typename: "UserOption";
50388
- id: string;
50389
- strikeTick: number;
50390
- startTick: number;
50391
- fullyExercised: boolean;
50392
- owner?: {
50393
- __typename: "TimelockMarketUser";
50394
- address: string;
50395
- } | null;
50396
- market?: {
50397
- __typename: "TimelockMarket";
50398
- address: string;
50399
- } | null;
50400
- }[];
50401
- } | {
50402
- error: null;
50403
- isError: false;
50404
- isPending: true;
50405
- isLoading: true;
50406
- isLoadingError: false;
50407
- isRefetchError: false;
50408
- isSuccess: false;
50409
- isPlaceholderData: false;
50410
- status: "pending";
50411
- dataUpdatedAt: number;
50412
- errorUpdatedAt: number;
50413
- failureCount: number;
50414
- failureReason: Error | null;
50415
- errorUpdateCount: number;
50416
- isFetched: boolean;
50417
- isFetchedAfterMount: boolean;
50418
- isFetching: boolean;
50419
- isInitialLoading: boolean;
50420
- isPaused: boolean;
50421
- isRefetching: boolean;
50422
- isStale: boolean;
50423
- isEnabled: boolean;
50424
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
50425
- optionId: bigint;
50426
- marketAddr: Address;
50427
- ownerAddr: Address;
50428
- optionType: "CALL" | "PUT";
50429
- createdAt: Date;
50430
- expiresAt: Date;
50431
- premium: bigint;
50432
- protocolFee: bigint;
50433
- realizedPayout: bigint;
50434
- liquiditiesAtOpen: bigint[];
50435
- liquiditiesCurrent: bigint[];
50436
- positionSizeAtOpen: bigint;
50437
- positionSizeCurrent: bigint;
50438
- strikePrice: bigint;
50439
- entryPrice: bigint;
50440
- __typename: "UserOption";
50441
- id: string;
50442
- strikeTick: number;
50443
- startTick: number;
50444
- fullyExercised: boolean;
50445
- owner?: {
50446
- __typename: "TimelockMarketUser";
50447
- address: string;
50448
- } | null;
50449
- market?: {
50450
- __typename: "TimelockMarket";
50451
- address: string;
50452
- } | null;
50453
- }[], Error>>;
50454
- fetchStatus: _tanstack_query_core0.FetchStatus;
50455
- promise: Promise<{
50456
- optionId: bigint;
50457
- marketAddr: Address;
50458
- ownerAddr: Address;
50459
- optionType: "CALL" | "PUT";
50460
- createdAt: Date;
50461
- expiresAt: Date;
50462
- premium: bigint;
50463
- protocolFee: bigint;
50464
- realizedPayout: bigint;
50465
- liquiditiesAtOpen: bigint[];
50466
- liquiditiesCurrent: bigint[];
50467
- positionSizeAtOpen: bigint;
50468
- positionSizeCurrent: bigint;
50469
- strikePrice: bigint;
50470
- entryPrice: bigint;
50471
- __typename: "UserOption";
50472
- id: string;
50473
- strikeTick: number;
50474
- startTick: number;
50475
- fullyExercised: boolean;
50476
- owner?: {
50477
- __typename: "TimelockMarketUser";
50478
- address: string;
50479
- } | null;
50480
- market?: {
50481
- __typename: "TimelockMarket";
50482
- address: string;
50483
- } | null;
50484
- }[]>;
50485
- data: {
50486
- optionId: bigint;
50487
- marketAddr: Address;
50488
- ownerAddr: Address;
50489
- optionType: "CALL" | "PUT";
50490
- createdAt: Date;
50491
- expiresAt: Date;
50492
- premium: bigint;
50493
- protocolFee: bigint;
50494
- realizedPayout: bigint;
50495
- liquiditiesAtOpen: bigint[];
50496
- liquiditiesCurrent: bigint[];
50497
- positionSizeAtOpen: bigint;
50498
- positionSizeCurrent: bigint;
50499
- strikePrice: bigint;
50500
- entryPrice: bigint;
50501
- __typename: "UserOption";
50502
- id: string;
50503
- strikeTick: number;
50504
- startTick: number;
50505
- fullyExercised: boolean;
50506
- owner?: {
50507
- __typename: "TimelockMarketUser";
50508
- address: string;
50509
- } | null;
50510
- market?: {
50511
- __typename: "TimelockMarket";
50512
- address: string;
50513
- } | null;
50514
- }[];
50515
- } | {
50516
- error: null;
50517
- isError: false;
50518
- isPending: true;
50519
- isLoadingError: false;
50520
- isRefetchError: false;
50521
- isSuccess: false;
50522
- isPlaceholderData: false;
50523
- status: "pending";
50524
- dataUpdatedAt: number;
50525
- errorUpdatedAt: number;
50526
- failureCount: number;
50527
- failureReason: Error | null;
50528
- errorUpdateCount: number;
50529
- isFetched: boolean;
50530
- isFetchedAfterMount: boolean;
50531
- isFetching: boolean;
50532
- isLoading: boolean;
50533
- isInitialLoading: boolean;
50534
- isPaused: boolean;
50535
- isRefetching: boolean;
50536
- isStale: boolean;
50537
- isEnabled: boolean;
50538
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
50539
- optionId: bigint;
50540
- marketAddr: Address;
50541
- ownerAddr: Address;
50542
- optionType: "CALL" | "PUT";
50543
- createdAt: Date;
50544
- expiresAt: Date;
50545
- premium: bigint;
50546
- protocolFee: bigint;
50547
- realizedPayout: bigint;
50548
- liquiditiesAtOpen: bigint[];
50549
- liquiditiesCurrent: bigint[];
50550
- positionSizeAtOpen: bigint;
50551
- positionSizeCurrent: bigint;
50552
- strikePrice: bigint;
50553
- entryPrice: bigint;
50554
- __typename: "UserOption";
50555
- id: string;
50556
- strikeTick: number;
50557
- startTick: number;
50558
- fullyExercised: boolean;
50559
- owner?: {
50560
- __typename: "TimelockMarketUser";
50561
- address: string;
50562
- } | null;
50563
- market?: {
50564
- __typename: "TimelockMarket";
50565
- address: string;
50566
- } | null;
50567
- }[], Error>>;
50568
- fetchStatus: _tanstack_query_core0.FetchStatus;
50569
- promise: Promise<{
50570
- optionId: bigint;
50571
- marketAddr: Address;
50572
- ownerAddr: Address;
50573
- optionType: "CALL" | "PUT";
50574
- createdAt: Date;
50575
- expiresAt: Date;
50576
- premium: bigint;
50577
- protocolFee: bigint;
50578
- realizedPayout: bigint;
50579
- liquiditiesAtOpen: bigint[];
50580
- liquiditiesCurrent: bigint[];
50581
- positionSizeAtOpen: bigint;
50582
- positionSizeCurrent: bigint;
50583
- strikePrice: bigint;
50584
- entryPrice: bigint;
50585
- __typename: "UserOption";
50586
- id: string;
50587
- strikeTick: number;
50588
- startTick: number;
50589
- fullyExercised: boolean;
50590
- owner?: {
50591
- __typename: "TimelockMarketUser";
50592
- address: string;
50593
- } | null;
50594
- market?: {
50595
- __typename: "TimelockMarket";
50596
- address: string;
50597
- } | null;
50598
- }[]>;
50599
- data: {
50600
- optionId: bigint;
50601
- marketAddr: Address;
50602
- ownerAddr: Address;
50603
- optionType: "CALL" | "PUT";
50604
- createdAt: Date;
50605
- expiresAt: Date;
50606
- premium: bigint;
50607
- protocolFee: bigint;
50608
- realizedPayout: bigint;
50609
- liquiditiesAtOpen: bigint[];
50610
- liquiditiesCurrent: bigint[];
50611
- positionSizeAtOpen: bigint;
50612
- positionSizeCurrent: bigint;
50613
- strikePrice: bigint;
50614
- entryPrice: bigint;
50615
- __typename: "UserOption";
50616
- id: string;
50617
- strikeTick: number;
50618
- startTick: number;
50619
- fullyExercised: boolean;
50620
- owner?: {
50621
- __typename: "TimelockMarketUser";
50622
- address: string;
50623
- } | null;
50624
- market?: {
50625
- __typename: "TimelockMarket";
50626
- address: string;
50627
- } | null;
50628
- }[];
50629
- } | {
50630
- isError: false;
50631
- error: null;
50632
- isPending: false;
50633
- isLoading: false;
50634
- isLoadingError: false;
50635
- isRefetchError: false;
50636
- isSuccess: true;
50637
- isPlaceholderData: true;
50638
- status: "success";
50639
- dataUpdatedAt: number;
50640
- errorUpdatedAt: number;
50641
- failureCount: number;
50642
- failureReason: Error | null;
50643
- errorUpdateCount: number;
50644
- isFetched: boolean;
50645
- isFetchedAfterMount: boolean;
50646
- isFetching: boolean;
50647
- isInitialLoading: boolean;
50648
- isPaused: boolean;
50649
- isRefetching: boolean;
50650
- isStale: boolean;
50651
- isEnabled: boolean;
50652
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
50653
- optionId: bigint;
50654
- marketAddr: Address;
50655
- ownerAddr: Address;
50656
- optionType: "CALL" | "PUT";
50657
- createdAt: Date;
50658
- expiresAt: Date;
50659
- premium: bigint;
50660
- protocolFee: bigint;
50661
- realizedPayout: bigint;
50662
- liquiditiesAtOpen: bigint[];
50663
- liquiditiesCurrent: bigint[];
50664
- positionSizeAtOpen: bigint;
50665
- positionSizeCurrent: bigint;
50666
- strikePrice: bigint;
50667
- entryPrice: bigint;
50668
- __typename: "UserOption";
50669
- id: string;
50670
- strikeTick: number;
50671
- startTick: number;
50672
- fullyExercised: boolean;
50673
- owner?: {
50674
- __typename: "TimelockMarketUser";
50675
- address: string;
50676
- } | null;
50677
- market?: {
50678
- __typename: "TimelockMarket";
50679
- address: string;
50680
- } | null;
50681
- }[], Error>>;
50682
- fetchStatus: _tanstack_query_core0.FetchStatus;
50683
- promise: Promise<{
50684
- optionId: bigint;
50685
- marketAddr: Address;
50686
- ownerAddr: Address;
50687
- optionType: "CALL" | "PUT";
50688
- createdAt: Date;
50689
- expiresAt: Date;
50690
- premium: bigint;
50691
- protocolFee: bigint;
50692
- realizedPayout: bigint;
50693
- liquiditiesAtOpen: bigint[];
50694
- liquiditiesCurrent: bigint[];
50695
- positionSizeAtOpen: bigint;
50696
- positionSizeCurrent: bigint;
50697
- strikePrice: bigint;
50698
- entryPrice: bigint;
50699
- __typename: "UserOption";
50700
- id: string;
50701
- strikeTick: number;
50702
- startTick: number;
50703
- fullyExercised: boolean;
50704
- owner?: {
50705
- __typename: "TimelockMarketUser";
50706
- address: string;
50707
- } | null;
50708
- market?: {
50709
- __typename: "TimelockMarket";
50710
- address: string;
50711
- } | null;
50712
- }[]>;
50713
- data: {
50714
- optionId: bigint;
50715
- marketAddr: Address;
50716
- ownerAddr: Address;
50717
- optionType: "CALL" | "PUT";
50718
- createdAt: Date;
50719
- expiresAt: Date;
50720
- premium: bigint;
50721
- protocolFee: bigint;
50722
- realizedPayout: bigint;
50723
- liquiditiesAtOpen: bigint[];
50724
- liquiditiesCurrent: bigint[];
50725
- positionSizeAtOpen: bigint;
50726
- positionSizeCurrent: bigint;
50727
- strikePrice: bigint;
50728
- entryPrice: bigint;
50729
- __typename: "UserOption";
50730
- id: string;
50731
- strikeTick: number;
50732
- startTick: number;
50733
- fullyExercised: boolean;
50734
- owner?: {
50735
- __typename: "TimelockMarketUser";
50736
- address: string;
50737
- } | null;
50738
- market?: {
50739
- __typename: "TimelockMarket";
50740
- address: string;
50741
- } | null;
50742
- }[];
50743
- };
50744
- declare const useClosedUserOptions: (userAddr?: Address, marketAddr?: Address | "*") => {
50745
- error: Error;
50746
- isError: true;
50747
- isPending: false;
50748
- isLoading: false;
50749
- isLoadingError: false;
50750
- isRefetchError: true;
50751
- isSuccess: false;
50752
- isPlaceholderData: false;
50753
- status: "error";
50754
- dataUpdatedAt: number;
50755
- errorUpdatedAt: number;
50756
- failureCount: number;
50757
- failureReason: Error | null;
50758
- errorUpdateCount: number;
50759
- isFetched: boolean;
50760
- isFetchedAfterMount: boolean;
50761
- isFetching: boolean;
50762
- isInitialLoading: boolean;
50763
- isPaused: boolean;
50764
- isRefetching: boolean;
50765
- isStale: boolean;
50766
- isEnabled: boolean;
50767
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
50768
- optionId: bigint;
50769
- marketAddr: Address;
50770
- ownerAddr: Address;
50771
- optionType: "CALL" | "PUT";
50772
- createdAt: Date;
50773
- expiresAt: Date;
50774
- premium: bigint;
50775
- protocolFee: bigint;
50776
- realizedPayout: bigint;
50777
- liquiditiesAtOpen: bigint[];
50778
- liquiditiesCurrent: bigint[];
50779
- positionSizeAtOpen: bigint;
50780
- positionSizeCurrent: bigint;
50781
- strikePrice: bigint;
50782
- entryPrice: bigint;
50783
- __typename: "UserOption";
50784
- id: string;
50785
- strikeTick: number;
50786
- startTick: number;
50787
- fullyExercised: boolean;
50788
- owner?: {
50789
- __typename: "TimelockMarketUser";
50790
- address: string;
50791
- } | null;
50792
- market?: {
50793
- __typename: "TimelockMarket";
50794
- address: string;
50795
- } | null;
50796
- }[], Error>>;
50797
- fetchStatus: _tanstack_query_core0.FetchStatus;
50798
- promise: Promise<{
50799
- optionId: bigint;
50800
- marketAddr: Address;
50801
- ownerAddr: Address;
50802
- optionType: "CALL" | "PUT";
50803
- createdAt: Date;
50804
- expiresAt: Date;
50805
- premium: bigint;
50806
- protocolFee: bigint;
50807
- realizedPayout: bigint;
50808
- liquiditiesAtOpen: bigint[];
50809
- liquiditiesCurrent: bigint[];
50810
- positionSizeAtOpen: bigint;
50811
- positionSizeCurrent: bigint;
50812
- strikePrice: bigint;
50813
- entryPrice: bigint;
50814
- __typename: "UserOption";
50815
- id: string;
50816
- strikeTick: number;
50817
- startTick: number;
50818
- fullyExercised: boolean;
50819
- owner?: {
50820
- __typename: "TimelockMarketUser";
50821
- address: string;
50822
- } | null;
50823
- market?: {
50824
- __typename: "TimelockMarket";
50825
- address: string;
50826
- } | null;
50827
- }[]>;
50828
- data: {
50829
- optionId: bigint;
50830
- marketAddr: Address;
50831
- ownerAddr: Address;
50832
- optionType: "CALL" | "PUT";
50833
- createdAt: Date;
50834
- expiresAt: Date;
50835
- premium: bigint;
50836
- protocolFee: bigint;
50837
- realizedPayout: bigint;
50838
- liquiditiesAtOpen: bigint[];
50839
- liquiditiesCurrent: bigint[];
50840
- positionSizeAtOpen: bigint;
50841
- positionSizeCurrent: bigint;
50842
- strikePrice: bigint;
50843
- entryPrice: bigint;
50844
- __typename: "UserOption";
50845
- id: string;
50846
- strikeTick: number;
50847
- startTick: number;
50848
- fullyExercised: boolean;
50849
- owner?: {
50850
- __typename: "TimelockMarketUser";
50851
- address: string;
50852
- } | null;
50853
- market?: {
50854
- __typename: "TimelockMarket";
50855
- address: string;
50856
- } | null;
50857
- }[];
50858
- } | {
50859
- error: null;
50860
- isError: false;
50861
- isPending: false;
50862
- isLoading: false;
50863
- isLoadingError: false;
50864
- isRefetchError: false;
50865
- isSuccess: true;
50866
- isPlaceholderData: false;
50867
- status: "success";
50868
- dataUpdatedAt: number;
50869
- errorUpdatedAt: number;
50870
- failureCount: number;
50871
- failureReason: Error | null;
50872
- errorUpdateCount: number;
50873
- isFetched: boolean;
50874
- isFetchedAfterMount: boolean;
50875
- isFetching: boolean;
50876
- isInitialLoading: boolean;
50877
- isPaused: boolean;
50878
- isRefetching: boolean;
50879
- isStale: boolean;
50880
- isEnabled: boolean;
50881
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
50882
- optionId: bigint;
50883
- marketAddr: Address;
50884
- ownerAddr: Address;
50885
- optionType: "CALL" | "PUT";
50886
- createdAt: Date;
50887
- expiresAt: Date;
50888
- premium: bigint;
50889
- protocolFee: bigint;
50890
- realizedPayout: bigint;
50891
- liquiditiesAtOpen: bigint[];
50892
- liquiditiesCurrent: bigint[];
50893
- positionSizeAtOpen: bigint;
50894
- positionSizeCurrent: bigint;
50895
- strikePrice: bigint;
50896
- entryPrice: bigint;
50897
- __typename: "UserOption";
50898
- id: string;
50899
- strikeTick: number;
50900
- startTick: number;
50901
- fullyExercised: boolean;
50902
- owner?: {
50903
- __typename: "TimelockMarketUser";
50904
- address: string;
50905
- } | null;
50906
- market?: {
50907
- __typename: "TimelockMarket";
50908
- address: string;
50909
- } | null;
50910
- }[], Error>>;
50911
- fetchStatus: _tanstack_query_core0.FetchStatus;
50912
- promise: Promise<{
50913
- optionId: bigint;
50914
- marketAddr: Address;
50915
- ownerAddr: Address;
50916
- optionType: "CALL" | "PUT";
50917
- createdAt: Date;
50918
- expiresAt: Date;
50919
- premium: bigint;
50920
- protocolFee: bigint;
50921
- realizedPayout: bigint;
50922
- liquiditiesAtOpen: bigint[];
50923
- liquiditiesCurrent: bigint[];
50924
- positionSizeAtOpen: bigint;
50925
- positionSizeCurrent: bigint;
50926
- strikePrice: bigint;
50927
- entryPrice: bigint;
50928
- __typename: "UserOption";
50929
- id: string;
50930
- strikeTick: number;
50931
- startTick: number;
50932
- fullyExercised: boolean;
50933
- owner?: {
50934
- __typename: "TimelockMarketUser";
50935
- address: string;
50936
- } | null;
50937
- market?: {
50938
- __typename: "TimelockMarket";
50939
- address: string;
50940
- } | null;
50941
- }[]>;
50942
- data: {
50943
- optionId: bigint;
50944
- marketAddr: Address;
50945
- ownerAddr: Address;
50946
- optionType: "CALL" | "PUT";
50947
- createdAt: Date;
50948
- expiresAt: Date;
50949
- premium: bigint;
50950
- protocolFee: bigint;
50951
- realizedPayout: bigint;
50952
- liquiditiesAtOpen: bigint[];
50953
- liquiditiesCurrent: bigint[];
50954
- positionSizeAtOpen: bigint;
50955
- positionSizeCurrent: bigint;
50956
- strikePrice: bigint;
50957
- entryPrice: bigint;
50958
- __typename: "UserOption";
50959
- id: string;
50960
- strikeTick: number;
50961
- startTick: number;
50962
- fullyExercised: boolean;
50963
- owner?: {
50964
- __typename: "TimelockMarketUser";
50965
- address: string;
50966
- } | null;
50967
- market?: {
50968
- __typename: "TimelockMarket";
50969
- address: string;
50970
- } | null;
50971
- }[];
50972
- } | {
50973
- error: Error;
50974
- isError: true;
50975
- isPending: false;
50976
- isLoading: false;
50977
- isLoadingError: true;
50978
- isRefetchError: false;
50979
- isSuccess: false;
50980
- isPlaceholderData: false;
50981
- status: "error";
50982
- dataUpdatedAt: number;
50983
- errorUpdatedAt: number;
50984
- failureCount: number;
50985
- failureReason: Error | null;
50986
- errorUpdateCount: number;
50987
- isFetched: boolean;
50988
- isFetchedAfterMount: boolean;
50989
- isFetching: boolean;
50990
- isInitialLoading: boolean;
50991
- isPaused: boolean;
50992
- isRefetching: boolean;
50993
- isStale: boolean;
50994
- isEnabled: boolean;
50995
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
50996
- optionId: bigint;
50997
- marketAddr: Address;
50998
- ownerAddr: Address;
50999
- optionType: "CALL" | "PUT";
51000
- createdAt: Date;
51001
- expiresAt: Date;
51002
- premium: bigint;
51003
- protocolFee: bigint;
51004
- realizedPayout: bigint;
51005
- liquiditiesAtOpen: bigint[];
51006
- liquiditiesCurrent: bigint[];
51007
- positionSizeAtOpen: bigint;
51008
- positionSizeCurrent: bigint;
51009
- strikePrice: bigint;
51010
- entryPrice: bigint;
51011
- __typename: "UserOption";
51012
- id: string;
51013
- strikeTick: number;
51014
- startTick: number;
51015
- fullyExercised: boolean;
51016
- owner?: {
51017
- __typename: "TimelockMarketUser";
51018
- address: string;
51019
- } | null;
51020
- market?: {
51021
- __typename: "TimelockMarket";
51022
- address: string;
51023
- } | null;
51024
- }[], Error>>;
51025
- fetchStatus: _tanstack_query_core0.FetchStatus;
51026
- promise: Promise<{
51027
- optionId: bigint;
51028
- marketAddr: Address;
51029
- ownerAddr: Address;
51030
- optionType: "CALL" | "PUT";
51031
- createdAt: Date;
51032
- expiresAt: Date;
51033
- premium: bigint;
51034
- protocolFee: bigint;
51035
- realizedPayout: bigint;
51036
- liquiditiesAtOpen: bigint[];
51037
- liquiditiesCurrent: bigint[];
51038
- positionSizeAtOpen: bigint;
51039
- positionSizeCurrent: bigint;
51040
- strikePrice: bigint;
51041
- entryPrice: bigint;
51042
- __typename: "UserOption";
51043
- id: string;
51044
- strikeTick: number;
51045
- startTick: number;
51046
- fullyExercised: boolean;
51047
- owner?: {
51048
- __typename: "TimelockMarketUser";
51049
- address: string;
51050
- } | null;
51051
- market?: {
51052
- __typename: "TimelockMarket";
51053
- address: string;
51054
- } | null;
51055
- }[]>;
51056
- data: {
51057
- optionId: bigint;
51058
- marketAddr: Address;
51059
- ownerAddr: Address;
51060
- optionType: "CALL" | "PUT";
51061
- createdAt: Date;
51062
- expiresAt: Date;
51063
- premium: bigint;
51064
- protocolFee: bigint;
51065
- realizedPayout: bigint;
51066
- liquiditiesAtOpen: bigint[];
51067
- liquiditiesCurrent: bigint[];
51068
- positionSizeAtOpen: bigint;
51069
- positionSizeCurrent: bigint;
51070
- strikePrice: bigint;
51071
- entryPrice: bigint;
51072
- __typename: "UserOption";
51073
- id: string;
51074
- strikeTick: number;
51075
- startTick: number;
51076
- fullyExercised: boolean;
51077
- owner?: {
51078
- __typename: "TimelockMarketUser";
51079
- address: string;
51080
- } | null;
51081
- market?: {
51082
- __typename: "TimelockMarket";
51083
- address: string;
51084
- } | null;
51085
- }[];
51086
- } | {
51087
- error: null;
51088
- isError: false;
51089
- isPending: true;
51090
- isLoading: true;
51091
- isLoadingError: false;
51092
- isRefetchError: false;
51093
- isSuccess: false;
51094
- isPlaceholderData: false;
51095
- status: "pending";
51096
- dataUpdatedAt: number;
51097
- errorUpdatedAt: number;
51098
- failureCount: number;
51099
- failureReason: Error | null;
51100
- errorUpdateCount: number;
51101
- isFetched: boolean;
51102
- isFetchedAfterMount: boolean;
51103
- isFetching: boolean;
51104
- isInitialLoading: boolean;
51105
- isPaused: boolean;
51106
- isRefetching: boolean;
51107
- isStale: boolean;
51108
- isEnabled: boolean;
51109
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
51110
- optionId: bigint;
51111
- marketAddr: Address;
51112
- ownerAddr: Address;
51113
- optionType: "CALL" | "PUT";
51114
- createdAt: Date;
51115
- expiresAt: Date;
51116
- premium: bigint;
51117
- protocolFee: bigint;
51118
- realizedPayout: bigint;
51119
- liquiditiesAtOpen: bigint[];
51120
- liquiditiesCurrent: bigint[];
51121
- positionSizeAtOpen: bigint;
51122
- positionSizeCurrent: bigint;
51123
- strikePrice: bigint;
51124
- entryPrice: bigint;
51125
- __typename: "UserOption";
51126
- id: string;
51127
- strikeTick: number;
51128
- startTick: number;
51129
- fullyExercised: boolean;
51130
- owner?: {
51131
- __typename: "TimelockMarketUser";
51132
- address: string;
51133
- } | null;
51134
- market?: {
51135
- __typename: "TimelockMarket";
51136
- address: string;
51137
- } | null;
51138
- }[], Error>>;
51139
- fetchStatus: _tanstack_query_core0.FetchStatus;
51140
- promise: Promise<{
51141
- optionId: bigint;
51142
- marketAddr: Address;
51143
- ownerAddr: Address;
51144
- optionType: "CALL" | "PUT";
51145
- createdAt: Date;
51146
- expiresAt: Date;
51147
- premium: bigint;
51148
- protocolFee: bigint;
51149
- realizedPayout: bigint;
51150
- liquiditiesAtOpen: bigint[];
51151
- liquiditiesCurrent: bigint[];
51152
- positionSizeAtOpen: bigint;
51153
- positionSizeCurrent: bigint;
51154
- strikePrice: bigint;
51155
- entryPrice: bigint;
51156
- __typename: "UserOption";
51157
- id: string;
51158
- strikeTick: number;
51159
- startTick: number;
51160
- fullyExercised: boolean;
51161
- owner?: {
51162
- __typename: "TimelockMarketUser";
51163
- address: string;
51164
- } | null;
51165
- market?: {
51166
- __typename: "TimelockMarket";
51167
- address: string;
51168
- } | null;
51169
- }[]>;
51170
- data: {
51171
- optionId: bigint;
51172
- marketAddr: Address;
51173
- ownerAddr: Address;
51174
- optionType: "CALL" | "PUT";
51175
- createdAt: Date;
51176
- expiresAt: Date;
51177
- premium: bigint;
51178
- protocolFee: bigint;
51179
- realizedPayout: bigint;
51180
- liquiditiesAtOpen: bigint[];
51181
- liquiditiesCurrent: bigint[];
51182
- positionSizeAtOpen: bigint;
51183
- positionSizeCurrent: bigint;
51184
- strikePrice: bigint;
51185
- entryPrice: bigint;
51186
- __typename: "UserOption";
51187
- id: string;
51188
- strikeTick: number;
51189
- startTick: number;
51190
- fullyExercised: boolean;
51191
- owner?: {
51192
- __typename: "TimelockMarketUser";
51193
- address: string;
51194
- } | null;
51195
- market?: {
51196
- __typename: "TimelockMarket";
51197
- address: string;
51198
- } | null;
51199
- }[];
51200
- } | {
51201
- error: null;
51202
- isError: false;
51203
- isPending: true;
51204
- isLoadingError: false;
51205
- isRefetchError: false;
51206
- isSuccess: false;
51207
- isPlaceholderData: false;
51208
- status: "pending";
51209
- dataUpdatedAt: number;
51210
- errorUpdatedAt: number;
51211
- failureCount: number;
51212
- failureReason: Error | null;
51213
- errorUpdateCount: number;
51214
- isFetched: boolean;
51215
- isFetchedAfterMount: boolean;
51216
- isFetching: boolean;
51217
- isLoading: boolean;
51218
- isInitialLoading: boolean;
51219
- isPaused: boolean;
51220
- isRefetching: boolean;
51221
- isStale: boolean;
51222
- isEnabled: boolean;
51223
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
51224
- optionId: bigint;
51225
- marketAddr: Address;
51226
- ownerAddr: Address;
51227
- optionType: "CALL" | "PUT";
51228
- createdAt: Date;
51229
- expiresAt: Date;
51230
- premium: bigint;
51231
- protocolFee: bigint;
51232
- realizedPayout: bigint;
51233
- liquiditiesAtOpen: bigint[];
51234
- liquiditiesCurrent: bigint[];
51235
- positionSizeAtOpen: bigint;
51236
- positionSizeCurrent: bigint;
51237
- strikePrice: bigint;
51238
- entryPrice: bigint;
51239
- __typename: "UserOption";
51240
- id: string;
51241
- strikeTick: number;
51242
- startTick: number;
51243
- fullyExercised: boolean;
51244
- owner?: {
51245
- __typename: "TimelockMarketUser";
51246
- address: string;
51247
- } | null;
51248
- market?: {
51249
- __typename: "TimelockMarket";
51250
- address: string;
51251
- } | null;
51252
- }[], Error>>;
51253
- fetchStatus: _tanstack_query_core0.FetchStatus;
51254
- promise: Promise<{
51255
- optionId: bigint;
51256
- marketAddr: Address;
51257
- ownerAddr: Address;
51258
- optionType: "CALL" | "PUT";
51259
- createdAt: Date;
51260
- expiresAt: Date;
51261
- premium: bigint;
51262
- protocolFee: bigint;
51263
- realizedPayout: bigint;
51264
- liquiditiesAtOpen: bigint[];
51265
- liquiditiesCurrent: bigint[];
51266
- positionSizeAtOpen: bigint;
51267
- positionSizeCurrent: bigint;
51268
- strikePrice: bigint;
51269
- entryPrice: bigint;
51270
- __typename: "UserOption";
51271
- id: string;
51272
- strikeTick: number;
51273
- startTick: number;
51274
- fullyExercised: boolean;
51275
- owner?: {
51276
- __typename: "TimelockMarketUser";
51277
- address: string;
51278
- } | null;
51279
- market?: {
51280
- __typename: "TimelockMarket";
51281
- address: string;
51282
- } | null;
51283
- }[]>;
51284
- data: {
51285
- optionId: bigint;
51286
- marketAddr: Address;
51287
- ownerAddr: Address;
51288
- optionType: "CALL" | "PUT";
51289
- createdAt: Date;
51290
- expiresAt: Date;
51291
- premium: bigint;
51292
- protocolFee: bigint;
51293
- realizedPayout: bigint;
51294
- liquiditiesAtOpen: bigint[];
51295
- liquiditiesCurrent: bigint[];
51296
- positionSizeAtOpen: bigint;
51297
- positionSizeCurrent: bigint;
51298
- strikePrice: bigint;
51299
- entryPrice: bigint;
51300
- __typename: "UserOption";
51301
- id: string;
51302
- strikeTick: number;
51303
- startTick: number;
51304
- fullyExercised: boolean;
51305
- owner?: {
51306
- __typename: "TimelockMarketUser";
51307
- address: string;
51308
- } | null;
51309
- market?: {
51310
- __typename: "TimelockMarket";
51311
- address: string;
51312
- } | null;
51313
- }[];
51314
- } | {
51315
- isError: false;
51316
- error: null;
51317
- isPending: false;
51318
- isLoading: false;
51319
- isLoadingError: false;
51320
- isRefetchError: false;
51321
- isSuccess: true;
51322
- isPlaceholderData: true;
51323
- status: "success";
51324
- dataUpdatedAt: number;
51325
- errorUpdatedAt: number;
51326
- failureCount: number;
51327
- failureReason: Error | null;
51328
- errorUpdateCount: number;
51329
- isFetched: boolean;
51330
- isFetchedAfterMount: boolean;
51331
- isFetching: boolean;
51332
- isInitialLoading: boolean;
51333
- isPaused: boolean;
51334
- isRefetching: boolean;
51335
- isStale: boolean;
51336
- isEnabled: boolean;
51337
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
51338
- optionId: bigint;
51339
- marketAddr: Address;
51340
- ownerAddr: Address;
51341
- optionType: "CALL" | "PUT";
51342
- createdAt: Date;
51343
- expiresAt: Date;
51344
- premium: bigint;
51345
- protocolFee: bigint;
51346
- realizedPayout: bigint;
51347
- liquiditiesAtOpen: bigint[];
51348
- liquiditiesCurrent: bigint[];
51349
- positionSizeAtOpen: bigint;
51350
- positionSizeCurrent: bigint;
51351
- strikePrice: bigint;
51352
- entryPrice: bigint;
51353
- __typename: "UserOption";
51354
- id: string;
51355
- strikeTick: number;
51356
- startTick: number;
51357
- fullyExercised: boolean;
51358
- owner?: {
51359
- __typename: "TimelockMarketUser";
51360
- address: string;
51361
- } | null;
51362
- market?: {
51363
- __typename: "TimelockMarket";
51364
- address: string;
51365
- } | null;
51366
- }[], Error>>;
51367
- fetchStatus: _tanstack_query_core0.FetchStatus;
51368
- promise: Promise<{
51369
- optionId: bigint;
51370
- marketAddr: Address;
51371
- ownerAddr: Address;
51372
- optionType: "CALL" | "PUT";
51373
- createdAt: Date;
51374
- expiresAt: Date;
51375
- premium: bigint;
51376
- protocolFee: bigint;
51377
- realizedPayout: bigint;
51378
- liquiditiesAtOpen: bigint[];
51379
- liquiditiesCurrent: bigint[];
51380
- positionSizeAtOpen: bigint;
51381
- positionSizeCurrent: bigint;
51382
- strikePrice: bigint;
51383
- entryPrice: bigint;
51384
- __typename: "UserOption";
51385
- id: string;
51386
- strikeTick: number;
51387
- startTick: number;
51388
- fullyExercised: boolean;
51389
- owner?: {
51390
- __typename: "TimelockMarketUser";
51391
- address: string;
51392
- } | null;
51393
- market?: {
51394
- __typename: "TimelockMarket";
51395
- address: string;
51396
- } | null;
51397
- }[]>;
51398
- data: {
51399
- optionId: bigint;
51400
- marketAddr: Address;
51401
- ownerAddr: Address;
51402
- optionType: "CALL" | "PUT";
51403
- createdAt: Date;
51404
- expiresAt: Date;
51405
- premium: bigint;
51406
- protocolFee: bigint;
51407
- realizedPayout: bigint;
51408
- liquiditiesAtOpen: bigint[];
51409
- liquiditiesCurrent: bigint[];
51410
- positionSizeAtOpen: bigint;
51411
- positionSizeCurrent: bigint;
51412
- strikePrice: bigint;
51413
- entryPrice: bigint;
51414
- __typename: "UserOption";
51415
- id: string;
51416
- strikeTick: number;
51417
- startTick: number;
51418
- fullyExercised: boolean;
51419
- owner?: {
51420
- __typename: "TimelockMarketUser";
51421
- address: string;
51422
- } | null;
51423
- market?: {
51424
- __typename: "TimelockMarket";
51425
- address: string;
51426
- } | null;
51427
- }[];
51428
- };
51429
- //#endregion
51430
- //#region src/hooks/options/useExerciseOption.d.ts
51431
- declare const useExerciseOption: (marketAddr: Address | undefined) => _tanstack_react_query0.UseMutationResult<`0x${string}`, Error, {
51432
- option: OptionData;
51433
- liquidities: readonly bigint[];
51434
- }, unknown>;
51435
- //#endregion
51436
- //#region src/hooks/options/useOptionPnl.d.ts
51437
- declare const useOptionPnl: (option: OptionData) => {
51438
- unrealizedPayout: Amount | undefined;
51439
- displayPnl: Amount | undefined;
51440
- };
51441
- //#endregion
51442
- //#region src/hooks/options/useOptionPremium.d.ts
51443
- declare const useOptionPremium: (marketAddr: Address | undefined, optionType: "CALL" | "PUT", optionAmount?: bigint, addedDuration?: number, remainingDuration?: number, strikeTick?: number) => {
51444
- premium?: undefined;
51445
- protocolFee?: undefined;
51446
- totalPremium?: undefined;
51447
- } | {
51448
- premium: Amount;
51449
- protocolFee: Amount;
51450
- totalPremium: Amount;
51451
- };
51452
- //#endregion
51453
- //#region src/hooks/options/useExtendOption.d.ts
51454
- declare const useExtendOption: (marketAddr: Address | undefined) => _tanstack_react_query0.UseMutationResult<`0x${string}`, Error, {
51455
- option: OptionData;
51456
- duration: number;
51457
- }, unknown>;
51458
- //#endregion
51459
- //#region src/hooks/options/useOptionTimeline.d.ts
51460
- type OptionEvent = ReturnType<typeof useOptionTimeline>['data'][number];
51461
- type MintOptionEvent = Extract<OptionEvent, {
51462
- type: 'mint';
51463
- }>;
51464
- type ExerciseOptionEvent = Extract<OptionEvent, {
51465
- type: 'exercise';
51466
- }>;
51467
- type ExtendEvent = Extract<OptionEvent, {
51468
- type: 'extend';
51469
- }>;
51470
- declare const useOptionTimeline: (marketAddr: Address | undefined, optionId: bigint | undefined) => {
51471
- error: Error;
51472
- isError: true;
51473
- isPending: false;
51474
- isLoading: false;
51475
- isLoadingError: false;
51476
- isRefetchError: true;
51477
- isSuccess: false;
51478
- isPlaceholderData: false;
51479
- status: "error";
51480
- dataUpdatedAt: number;
51481
- errorUpdatedAt: number;
51482
- failureCount: number;
51483
- failureReason: Error | null;
51484
- errorUpdateCount: number;
51485
- isFetched: boolean;
51486
- isFetchedAfterMount: boolean;
51487
- isFetching: boolean;
51488
- isInitialLoading: boolean;
51489
- isPaused: boolean;
51490
- isRefetching: boolean;
51491
- isStale: boolean;
51492
- isEnabled: boolean;
51493
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<({
51494
- type: "mint";
51495
- data: {
51496
- id: string;
51497
- optionType: 0 | 1;
51498
- strikeTick: number;
51499
- price: bigint;
51500
- premium: bigint;
51501
- protocolFee: bigint;
51502
- liquidities: bigint[];
51503
- timestamp: Date;
51504
- expiresAt: Date;
51505
- blockNumber: bigint;
51506
- transactionHash: string;
51507
- };
51508
- } | {
51509
- type: "exercise";
51510
- data: {
51511
- id: string;
51512
- payout: bigint;
51513
- price: bigint;
51514
- liquidities: bigint[];
51515
- timestamp: Date;
51516
- blockNumber: bigint;
51517
- transactionHash: string;
51518
- };
51519
- } | {
51520
- type: "extend";
51521
- data: {
51522
- id: string;
51523
- premium: bigint;
51524
- protocolFee: bigint;
51525
- price: bigint;
51526
- addedDuration: bigint;
51527
- timestamp: Date;
51528
- blockNumber: bigint;
51529
- transactionHash: string;
51530
- };
51531
- })[], Error>>;
51532
- fetchStatus: _tanstack_query_core0.FetchStatus;
51533
- promise: Promise<({
51534
- type: "mint";
51535
- data: {
51536
- id: string;
51537
- optionType: 0 | 1;
51538
- strikeTick: number;
51539
- price: bigint;
51540
- premium: bigint;
51541
- protocolFee: bigint;
51542
- liquidities: bigint[];
51543
- timestamp: Date;
51544
- expiresAt: Date;
51545
- blockNumber: bigint;
51546
- transactionHash: string;
51547
- };
51548
- } | {
51549
- type: "exercise";
51550
- data: {
51551
- id: string;
51552
- payout: bigint;
51553
- price: bigint;
51554
- liquidities: bigint[];
51555
- timestamp: Date;
51556
- blockNumber: bigint;
51557
- transactionHash: string;
51558
- };
51559
- } | {
51560
- type: "extend";
51561
- data: {
51562
- id: string;
51563
- premium: bigint;
51564
- protocolFee: bigint;
51565
- price: bigint;
51566
- addedDuration: bigint;
51567
- timestamp: Date;
51568
- blockNumber: bigint;
51569
- transactionHash: string;
51570
- };
51571
- })[]>;
51572
- data: ({
51573
- type: "mint";
51574
- data: {
51575
- id: string;
51576
- optionType: 0 | 1;
51577
- strikeTick: number;
51578
- price: bigint;
51579
- premium: bigint;
51580
- protocolFee: bigint;
51581
- liquidities: bigint[];
51582
- timestamp: Date;
51583
- expiresAt: Date;
51584
- blockNumber: bigint;
51585
- transactionHash: string;
51586
- };
51587
- } | {
51588
- type: "exercise";
51589
- data: {
51590
- id: string;
51591
- payout: bigint;
51592
- price: bigint;
51593
- liquidities: bigint[];
51594
- timestamp: Date;
51595
- blockNumber: bigint;
51596
- transactionHash: string;
51597
- };
51598
- } | {
51599
- type: "extend";
51600
- data: {
51601
- id: string;
51602
- premium: bigint;
51603
- protocolFee: bigint;
51604
- price: bigint;
51605
- addedDuration: bigint;
51606
- timestamp: Date;
51607
- blockNumber: bigint;
51608
- transactionHash: string;
51609
- };
51610
- })[];
51611
- } | {
51612
- error: null;
51613
- isError: false;
51614
- isPending: false;
51615
- isLoading: false;
51616
- isLoadingError: false;
51617
- isRefetchError: false;
51618
- isSuccess: true;
51619
- isPlaceholderData: false;
51620
- status: "success";
51621
- dataUpdatedAt: number;
51622
- errorUpdatedAt: number;
51623
- failureCount: number;
51624
- failureReason: Error | null;
51625
- errorUpdateCount: number;
51626
- isFetched: boolean;
51627
- isFetchedAfterMount: boolean;
51628
- isFetching: boolean;
51629
- isInitialLoading: boolean;
51630
- isPaused: boolean;
51631
- isRefetching: boolean;
51632
- isStale: boolean;
51633
- isEnabled: boolean;
51634
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<({
51635
- type: "mint";
51636
- data: {
51637
- id: string;
51638
- optionType: 0 | 1;
51639
- strikeTick: number;
51640
- price: bigint;
51641
- premium: bigint;
51642
- protocolFee: bigint;
51643
- liquidities: bigint[];
51644
- timestamp: Date;
51645
- expiresAt: Date;
51646
- blockNumber: bigint;
51647
- transactionHash: string;
51648
- };
51649
- } | {
51650
- type: "exercise";
51651
- data: {
51652
- id: string;
51653
- payout: bigint;
51654
- price: bigint;
51655
- liquidities: bigint[];
51656
- timestamp: Date;
51657
- blockNumber: bigint;
51658
- transactionHash: string;
51659
- };
51660
- } | {
51661
- type: "extend";
51662
- data: {
51663
- id: string;
51664
- premium: bigint;
51665
- protocolFee: bigint;
51666
- price: bigint;
51667
- addedDuration: bigint;
51668
- timestamp: Date;
51669
- blockNumber: bigint;
51670
- transactionHash: string;
51671
- };
51672
- })[], Error>>;
51673
- fetchStatus: _tanstack_query_core0.FetchStatus;
51674
- promise: Promise<({
51675
- type: "mint";
51676
- data: {
51677
- id: string;
51678
- optionType: 0 | 1;
51679
- strikeTick: number;
51680
- price: bigint;
51681
- premium: bigint;
51682
- protocolFee: bigint;
51683
- liquidities: bigint[];
51684
- timestamp: Date;
51685
- expiresAt: Date;
51686
- blockNumber: bigint;
51687
- transactionHash: string;
51688
- };
51689
- } | {
51690
- type: "exercise";
51691
- data: {
51692
- id: string;
51693
- payout: bigint;
51694
- price: bigint;
51695
- liquidities: bigint[];
51696
- timestamp: Date;
51697
- blockNumber: bigint;
51698
- transactionHash: string;
51699
- };
51700
- } | {
51701
- type: "extend";
51702
- data: {
51703
- id: string;
51704
- premium: bigint;
51705
- protocolFee: bigint;
51706
- price: bigint;
51707
- addedDuration: bigint;
51708
- timestamp: Date;
51709
- blockNumber: bigint;
51710
- transactionHash: string;
51711
- };
51712
- })[]>;
51713
- data: ({
51714
- type: "mint";
51715
- data: {
51716
- id: string;
51717
- optionType: 0 | 1;
51718
- strikeTick: number;
51719
- price: bigint;
51720
- premium: bigint;
51721
- protocolFee: bigint;
51722
- liquidities: bigint[];
51723
- timestamp: Date;
51724
- expiresAt: Date;
51725
- blockNumber: bigint;
51726
- transactionHash: string;
51727
- };
51728
- } | {
51729
- type: "exercise";
51730
- data: {
51731
- id: string;
51732
- payout: bigint;
51733
- price: bigint;
51734
- liquidities: bigint[];
51735
- timestamp: Date;
51736
- blockNumber: bigint;
51737
- transactionHash: string;
51738
- };
51739
- } | {
51740
- type: "extend";
51741
- data: {
51742
- id: string;
51743
- premium: bigint;
51744
- protocolFee: bigint;
51745
- price: bigint;
51746
- addedDuration: bigint;
51747
- timestamp: Date;
51748
- blockNumber: bigint;
51749
- transactionHash: string;
51750
- };
51751
- })[];
51752
- } | {
51753
- error: Error;
51754
- isError: true;
51755
- isPending: false;
51756
- isLoading: false;
51757
- isLoadingError: true;
51758
- isRefetchError: false;
51759
- isSuccess: false;
51760
- isPlaceholderData: false;
51761
- status: "error";
51762
- dataUpdatedAt: number;
51763
- errorUpdatedAt: number;
51764
- failureCount: number;
51765
- failureReason: Error | null;
51766
- errorUpdateCount: number;
51767
- isFetched: boolean;
51768
- isFetchedAfterMount: boolean;
51769
- isFetching: boolean;
51770
- isInitialLoading: boolean;
51771
- isPaused: boolean;
51772
- isRefetching: boolean;
51773
- isStale: boolean;
51774
- isEnabled: boolean;
51775
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<({
51776
- type: "mint";
51777
- data: {
51778
- id: string;
51779
- optionType: 0 | 1;
51780
- strikeTick: number;
51781
- price: bigint;
51782
- premium: bigint;
51783
- protocolFee: bigint;
51784
- liquidities: bigint[];
51785
- timestamp: Date;
51786
- expiresAt: Date;
51787
- blockNumber: bigint;
51788
- transactionHash: string;
51789
- };
51790
- } | {
51791
- type: "exercise";
51792
- data: {
51793
- id: string;
51794
- payout: bigint;
51795
- price: bigint;
51796
- liquidities: bigint[];
51797
- timestamp: Date;
51798
- blockNumber: bigint;
51799
- transactionHash: string;
51800
- };
51801
- } | {
51802
- type: "extend";
51803
- data: {
51804
- id: string;
51805
- premium: bigint;
51806
- protocolFee: bigint;
51807
- price: bigint;
51808
- addedDuration: bigint;
51809
- timestamp: Date;
51810
- blockNumber: bigint;
51811
- transactionHash: string;
51812
- };
51813
- })[], Error>>;
51814
- fetchStatus: _tanstack_query_core0.FetchStatus;
51815
- promise: Promise<({
51816
- type: "mint";
51817
- data: {
51818
- id: string;
51819
- optionType: 0 | 1;
51820
- strikeTick: number;
51821
- price: bigint;
51822
- premium: bigint;
51823
- protocolFee: bigint;
51824
- liquidities: bigint[];
51825
- timestamp: Date;
51826
- expiresAt: Date;
51827
- blockNumber: bigint;
51828
- transactionHash: string;
51829
- };
51830
- } | {
51831
- type: "exercise";
51832
- data: {
51833
- id: string;
51834
- payout: bigint;
51835
- price: bigint;
51836
- liquidities: bigint[];
51837
- timestamp: Date;
51838
- blockNumber: bigint;
51839
- transactionHash: string;
51840
- };
51841
- } | {
51842
- type: "extend";
51843
- data: {
51844
- id: string;
51845
- premium: bigint;
51846
- protocolFee: bigint;
51847
- price: bigint;
51848
- addedDuration: bigint;
51849
- timestamp: Date;
51850
- blockNumber: bigint;
51851
- transactionHash: string;
51852
- };
51853
- })[]>;
51854
- data: ({
51855
- type: "mint";
51856
- data: {
51857
- id: string;
51858
- optionType: 0 | 1;
51859
- strikeTick: number;
51860
- price: bigint;
51861
- premium: bigint;
51862
- protocolFee: bigint;
51863
- liquidities: bigint[];
51864
- timestamp: Date;
51865
- expiresAt: Date;
51866
- blockNumber: bigint;
51867
- transactionHash: string;
51868
- };
51869
- } | {
51870
- type: "exercise";
51871
- data: {
51872
- id: string;
51873
- payout: bigint;
51874
- price: bigint;
51875
- liquidities: bigint[];
51876
- timestamp: Date;
51877
- blockNumber: bigint;
51878
- transactionHash: string;
51879
- };
51880
- } | {
51881
- type: "extend";
51882
- data: {
51883
- id: string;
51884
- premium: bigint;
51885
- protocolFee: bigint;
51886
- price: bigint;
51887
- addedDuration: bigint;
51888
- timestamp: Date;
51889
- blockNumber: bigint;
51890
- transactionHash: string;
51891
- };
51892
- })[];
51893
- } | {
51894
- error: null;
51895
- isError: false;
51896
- isPending: true;
51897
- isLoading: true;
51898
- isLoadingError: false;
51899
- isRefetchError: false;
51900
- isSuccess: false;
51901
- isPlaceholderData: false;
51902
- status: "pending";
51903
- dataUpdatedAt: number;
51904
- errorUpdatedAt: number;
51905
- failureCount: number;
51906
- failureReason: Error | null;
51907
- errorUpdateCount: number;
51908
- isFetched: boolean;
51909
- isFetchedAfterMount: boolean;
51910
- isFetching: boolean;
51911
- isInitialLoading: boolean;
51912
- isPaused: boolean;
51913
- isRefetching: boolean;
51914
- isStale: boolean;
51915
- isEnabled: boolean;
51916
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<({
51917
- type: "mint";
51918
- data: {
51919
- id: string;
51920
- optionType: 0 | 1;
51921
- strikeTick: number;
51922
- price: bigint;
51923
- premium: bigint;
51924
- protocolFee: bigint;
51925
- liquidities: bigint[];
51926
- timestamp: Date;
51927
- expiresAt: Date;
51928
- blockNumber: bigint;
51929
- transactionHash: string;
51930
- };
51931
- } | {
51932
- type: "exercise";
51933
- data: {
51934
- id: string;
51935
- payout: bigint;
51936
- price: bigint;
51937
- liquidities: bigint[];
51938
- timestamp: Date;
51939
- blockNumber: bigint;
51940
- transactionHash: string;
51941
- };
51942
- } | {
51943
- type: "extend";
51944
- data: {
51945
- id: string;
51946
- premium: bigint;
51947
- protocolFee: bigint;
51948
- price: bigint;
51949
- addedDuration: bigint;
51950
- timestamp: Date;
51951
- blockNumber: bigint;
51952
- transactionHash: string;
51953
- };
51954
- })[], Error>>;
51955
- fetchStatus: _tanstack_query_core0.FetchStatus;
51956
- promise: Promise<({
51957
- type: "mint";
51958
- data: {
51959
- id: string;
51960
- optionType: 0 | 1;
51961
- strikeTick: number;
51962
- price: bigint;
51963
- premium: bigint;
51964
- protocolFee: bigint;
51965
- liquidities: bigint[];
51966
- timestamp: Date;
51967
- expiresAt: Date;
51968
- blockNumber: bigint;
51969
- transactionHash: string;
51970
- };
51971
- } | {
51972
- type: "exercise";
51973
- data: {
51974
- id: string;
51975
- payout: bigint;
51976
- price: bigint;
51977
- liquidities: bigint[];
51978
- timestamp: Date;
51979
- blockNumber: bigint;
51980
- transactionHash: string;
51981
- };
51982
- } | {
51983
- type: "extend";
51984
- data: {
51985
- id: string;
51986
- premium: bigint;
51987
- protocolFee: bigint;
51988
- price: bigint;
51989
- addedDuration: bigint;
51990
- timestamp: Date;
51991
- blockNumber: bigint;
51992
- transactionHash: string;
51993
- };
51994
- })[]>;
51995
- data: ({
51996
- type: "mint";
51997
- data: {
51998
- id: string;
51999
- optionType: 0 | 1;
52000
- strikeTick: number;
52001
- price: bigint;
52002
- premium: bigint;
52003
- protocolFee: bigint;
52004
- liquidities: bigint[];
52005
- timestamp: Date;
52006
- expiresAt: Date;
52007
- blockNumber: bigint;
52008
- transactionHash: string;
52009
- };
52010
- } | {
52011
- type: "exercise";
52012
- data: {
52013
- id: string;
52014
- payout: bigint;
52015
- price: bigint;
52016
- liquidities: bigint[];
52017
- timestamp: Date;
52018
- blockNumber: bigint;
52019
- transactionHash: string;
52020
- };
52021
- } | {
52022
- type: "extend";
52023
- data: {
52024
- id: string;
52025
- premium: bigint;
52026
- protocolFee: bigint;
52027
- price: bigint;
52028
- addedDuration: bigint;
52029
- timestamp: Date;
52030
- blockNumber: bigint;
52031
- transactionHash: string;
52032
- };
52033
- })[];
52034
- } | {
52035
- error: null;
52036
- isError: false;
52037
- isPending: true;
52038
- isLoadingError: false;
52039
- isRefetchError: false;
52040
- isSuccess: false;
52041
- isPlaceholderData: false;
52042
- status: "pending";
52043
- dataUpdatedAt: number;
52044
- errorUpdatedAt: number;
52045
- failureCount: number;
52046
- failureReason: Error | null;
52047
- errorUpdateCount: number;
52048
- isFetched: boolean;
52049
- isFetchedAfterMount: boolean;
52050
- isFetching: boolean;
52051
- isLoading: boolean;
52052
- isInitialLoading: boolean;
52053
- isPaused: boolean;
52054
- isRefetching: boolean;
52055
- isStale: boolean;
52056
- isEnabled: boolean;
52057
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<({
52058
- type: "mint";
52059
- data: {
52060
- id: string;
52061
- optionType: 0 | 1;
52062
- strikeTick: number;
52063
- price: bigint;
52064
- premium: bigint;
52065
- protocolFee: bigint;
52066
- liquidities: bigint[];
52067
- timestamp: Date;
52068
- expiresAt: Date;
52069
- blockNumber: bigint;
52070
- transactionHash: string;
52071
- };
52072
- } | {
52073
- type: "exercise";
52074
- data: {
52075
- id: string;
52076
- payout: bigint;
52077
- price: bigint;
52078
- liquidities: bigint[];
52079
- timestamp: Date;
52080
- blockNumber: bigint;
52081
- transactionHash: string;
52082
- };
52083
- } | {
52084
- type: "extend";
52085
- data: {
52086
- id: string;
52087
- premium: bigint;
52088
- protocolFee: bigint;
52089
- price: bigint;
52090
- addedDuration: bigint;
52091
- timestamp: Date;
52092
- blockNumber: bigint;
52093
- transactionHash: string;
52094
- };
52095
- })[], Error>>;
52096
- fetchStatus: _tanstack_query_core0.FetchStatus;
52097
- promise: Promise<({
52098
- type: "mint";
52099
- data: {
52100
- id: string;
52101
- optionType: 0 | 1;
52102
- strikeTick: number;
52103
- price: bigint;
52104
- premium: bigint;
52105
- protocolFee: bigint;
52106
- liquidities: bigint[];
52107
- timestamp: Date;
52108
- expiresAt: Date;
52109
- blockNumber: bigint;
52110
- transactionHash: string;
52111
- };
52112
- } | {
52113
- type: "exercise";
52114
- data: {
52115
- id: string;
52116
- payout: bigint;
52117
- price: bigint;
52118
- liquidities: bigint[];
52119
- timestamp: Date;
52120
- blockNumber: bigint;
52121
- transactionHash: string;
52122
- };
52123
- } | {
52124
- type: "extend";
52125
- data: {
52126
- id: string;
52127
- premium: bigint;
52128
- protocolFee: bigint;
52129
- price: bigint;
52130
- addedDuration: bigint;
52131
- timestamp: Date;
52132
- blockNumber: bigint;
52133
- transactionHash: string;
52134
- };
52135
- })[]>;
52136
- data: ({
52137
- type: "mint";
52138
- data: {
52139
- id: string;
52140
- optionType: 0 | 1;
52141
- strikeTick: number;
52142
- price: bigint;
52143
- premium: bigint;
52144
- protocolFee: bigint;
52145
- liquidities: bigint[];
52146
- timestamp: Date;
52147
- expiresAt: Date;
52148
- blockNumber: bigint;
52149
- transactionHash: string;
52150
- };
52151
- } | {
52152
- type: "exercise";
52153
- data: {
52154
- id: string;
52155
- payout: bigint;
52156
- price: bigint;
52157
- liquidities: bigint[];
52158
- timestamp: Date;
52159
- blockNumber: bigint;
52160
- transactionHash: string;
52161
- };
52162
- } | {
52163
- type: "extend";
52164
- data: {
52165
- id: string;
52166
- premium: bigint;
52167
- protocolFee: bigint;
52168
- price: bigint;
52169
- addedDuration: bigint;
52170
- timestamp: Date;
52171
- blockNumber: bigint;
52172
- transactionHash: string;
52173
- };
52174
- })[];
52175
- } | {
52176
- isError: false;
52177
- error: null;
52178
- isPending: false;
52179
- isLoading: false;
52180
- isLoadingError: false;
52181
- isRefetchError: false;
52182
- isSuccess: true;
52183
- isPlaceholderData: true;
52184
- status: "success";
52185
- dataUpdatedAt: number;
52186
- errorUpdatedAt: number;
52187
- failureCount: number;
52188
- failureReason: Error | null;
52189
- errorUpdateCount: number;
52190
- isFetched: boolean;
52191
- isFetchedAfterMount: boolean;
52192
- isFetching: boolean;
52193
- isInitialLoading: boolean;
52194
- isPaused: boolean;
52195
- isRefetching: boolean;
52196
- isStale: boolean;
52197
- isEnabled: boolean;
52198
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<({
52199
- type: "mint";
52200
- data: {
52201
- id: string;
52202
- optionType: 0 | 1;
52203
- strikeTick: number;
52204
- price: bigint;
52205
- premium: bigint;
52206
- protocolFee: bigint;
52207
- liquidities: bigint[];
52208
- timestamp: Date;
52209
- expiresAt: Date;
52210
- blockNumber: bigint;
52211
- transactionHash: string;
52212
- };
52213
- } | {
52214
- type: "exercise";
52215
- data: {
52216
- id: string;
52217
- payout: bigint;
52218
- price: bigint;
52219
- liquidities: bigint[];
52220
- timestamp: Date;
52221
- blockNumber: bigint;
52222
- transactionHash: string;
52223
- };
52224
- } | {
52225
- type: "extend";
52226
- data: {
52227
- id: string;
52228
- premium: bigint;
52229
- protocolFee: bigint;
52230
- price: bigint;
52231
- addedDuration: bigint;
52232
- timestamp: Date;
52233
- blockNumber: bigint;
52234
- transactionHash: string;
52235
- };
52236
- })[], Error>>;
52237
- fetchStatus: _tanstack_query_core0.FetchStatus;
52238
- promise: Promise<({
52239
- type: "mint";
52240
- data: {
52241
- id: string;
52242
- optionType: 0 | 1;
52243
- strikeTick: number;
52244
- price: bigint;
52245
- premium: bigint;
52246
- protocolFee: bigint;
52247
- liquidities: bigint[];
52248
- timestamp: Date;
52249
- expiresAt: Date;
52250
- blockNumber: bigint;
52251
- transactionHash: string;
52252
- };
52253
- } | {
52254
- type: "exercise";
52255
- data: {
52256
- id: string;
52257
- payout: bigint;
52258
- price: bigint;
52259
- liquidities: bigint[];
52260
- timestamp: Date;
52261
- blockNumber: bigint;
52262
- transactionHash: string;
52263
- };
52264
- } | {
52265
- type: "extend";
52266
- data: {
52267
- id: string;
52268
- premium: bigint;
52269
- protocolFee: bigint;
52270
- price: bigint;
52271
- addedDuration: bigint;
52272
- timestamp: Date;
52273
- blockNumber: bigint;
52274
- transactionHash: string;
52275
- };
52276
- })[]>;
52277
- data: ({
52278
- type: "mint";
52279
- data: {
52280
- id: string;
52281
- optionType: 0 | 1;
52282
- strikeTick: number;
52283
- price: bigint;
52284
- premium: bigint;
52285
- protocolFee: bigint;
52286
- liquidities: bigint[];
52287
- timestamp: Date;
52288
- expiresAt: Date;
52289
- blockNumber: bigint;
52290
- transactionHash: string;
52291
- };
52292
- } | {
52293
- type: "exercise";
52294
- data: {
52295
- id: string;
52296
- payout: bigint;
52297
- price: bigint;
52298
- liquidities: bigint[];
52299
- timestamp: Date;
52300
- blockNumber: bigint;
52301
- transactionHash: string;
52302
- };
52303
- } | {
52304
- type: "extend";
52305
- data: {
52306
- id: string;
52307
- premium: bigint;
52308
- protocolFee: bigint;
52309
- price: bigint;
52310
- addedDuration: bigint;
52311
- timestamp: Date;
52312
- blockNumber: bigint;
52313
- transactionHash: string;
52314
- };
52315
- })[];
52316
- };
52317
- //#endregion
52318
- //#region src/hooks/perps/useMintPerp.d.ts
52319
- declare const useMintPerp: (marketAddr: Address | undefined) => _tanstack_react_query0.UseMutationResult<void, Error, {
52320
- optionType: "CALL" | "PUT";
52321
- amount: bigint;
52322
- duration: number;
52323
- strikeTick?: number;
52324
- }, unknown>;
52325
- //#endregion
52326
- //#region src/hooks/perps/useClosePerp.d.ts
52327
- declare const useClosePerp: () => _tanstack_react_query0.UseMutationResult<void, Error, ExercisePerpBody, unknown>;
52328
- //#endregion
52329
- //#region src/hooks/perps/usePerpsOperator.d.ts
52330
- declare const usePerpsOperator: () => {
52331
- operator: PerpsOperator | undefined;
52332
- address: `0x${string}` | undefined;
52333
- signMessage: _tanstack_react_query0.UseMutationResult<void, Error, void, unknown>;
52334
- };
52335
- //#endregion
52336
- //#region src/hooks/perps/useUserPerps.d.ts
52337
- declare const useUserPerps: (marketAddr: Address | undefined, userAddr: Address | undefined, type: "active" | "closed" | undefined) => {
52338
- error: Error;
52339
- isError: true;
52340
- isPending: false;
52341
- isLoading: false;
52342
- isLoadingError: false;
52343
- isRefetchError: true;
52344
- isSuccess: false;
52345
- isPlaceholderData: false;
52346
- status: "error";
52347
- dataUpdatedAt: number;
52348
- errorUpdatedAt: number;
52349
- failureCount: number;
52350
- failureReason: Error | null;
52351
- errorUpdateCount: number;
52352
- isFetched: boolean;
52353
- isFetchedAfterMount: boolean;
52354
- isFetching: boolean;
52355
- isInitialLoading: boolean;
52356
- isPaused: boolean;
52357
- isRefetching: boolean;
52358
- isStale: boolean;
52359
- isEnabled: boolean;
52360
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
52361
- optionId: bigint;
52362
- id: string;
52363
- ownerAddr: Address;
52364
- marketAddr: Address;
52365
- perpDuration: number;
52366
- expiresAt: number;
52367
- closed: boolean;
52368
- }[] | undefined, Error>>;
52369
- fetchStatus: _tanstack_query_core0.FetchStatus;
52370
- promise: Promise<{
52371
- optionId: bigint;
52372
- id: string;
52373
- ownerAddr: Address;
52374
- marketAddr: Address;
52375
- perpDuration: number;
52376
- expiresAt: number;
52377
- closed: boolean;
52378
- }[] | undefined>;
52379
- data: {
52380
- optionId: bigint;
52381
- id: string;
52382
- ownerAddr: Address;
52383
- marketAddr: Address;
52384
- perpDuration: number;
52385
- expiresAt: number;
52386
- closed: boolean;
52387
- }[];
52388
- } | {
52389
- error: null;
52390
- isError: false;
52391
- isPending: false;
52392
- isLoading: false;
52393
- isLoadingError: false;
52394
- isRefetchError: false;
52395
- isSuccess: true;
52396
- isPlaceholderData: false;
52397
- status: "success";
52398
- dataUpdatedAt: number;
52399
- errorUpdatedAt: number;
52400
- failureCount: number;
52401
- failureReason: Error | null;
52402
- errorUpdateCount: number;
52403
- isFetched: boolean;
52404
- isFetchedAfterMount: boolean;
52405
- isFetching: boolean;
52406
- isInitialLoading: boolean;
52407
- isPaused: boolean;
52408
- isRefetching: boolean;
52409
- isStale: boolean;
52410
- isEnabled: boolean;
52411
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
52412
- optionId: bigint;
52413
- id: string;
52414
- ownerAddr: Address;
52415
- marketAddr: Address;
52416
- perpDuration: number;
52417
- expiresAt: number;
52418
- closed: boolean;
52419
- }[] | undefined, Error>>;
52420
- fetchStatus: _tanstack_query_core0.FetchStatus;
52421
- promise: Promise<{
52422
- optionId: bigint;
52423
- id: string;
52424
- ownerAddr: Address;
52425
- marketAddr: Address;
52426
- perpDuration: number;
52427
- expiresAt: number;
52428
- closed: boolean;
52429
- }[] | undefined>;
52430
- data: {
52431
- optionId: bigint;
52432
- id: string;
52433
- ownerAddr: Address;
52434
- marketAddr: Address;
52435
- perpDuration: number;
52436
- expiresAt: number;
52437
- closed: boolean;
52438
- }[];
52439
- } | {
52440
- error: Error;
52441
- isError: true;
52442
- isPending: false;
52443
- isLoading: false;
52444
- isLoadingError: true;
52445
- isRefetchError: false;
52446
- isSuccess: false;
52447
- isPlaceholderData: false;
52448
- status: "error";
52449
- dataUpdatedAt: number;
52450
- errorUpdatedAt: number;
52451
- failureCount: number;
52452
- failureReason: Error | null;
52453
- errorUpdateCount: number;
52454
- isFetched: boolean;
52455
- isFetchedAfterMount: boolean;
52456
- isFetching: boolean;
52457
- isInitialLoading: boolean;
52458
- isPaused: boolean;
52459
- isRefetching: boolean;
52460
- isStale: boolean;
52461
- isEnabled: boolean;
52462
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
52463
- optionId: bigint;
52464
- id: string;
52465
- ownerAddr: Address;
52466
- marketAddr: Address;
52467
- perpDuration: number;
52468
- expiresAt: number;
52469
- closed: boolean;
52470
- }[] | undefined, Error>>;
52471
- fetchStatus: _tanstack_query_core0.FetchStatus;
52472
- promise: Promise<{
52473
- optionId: bigint;
52474
- id: string;
52475
- ownerAddr: Address;
52476
- marketAddr: Address;
52477
- perpDuration: number;
52478
- expiresAt: number;
52479
- closed: boolean;
52480
- }[] | undefined>;
52481
- data: {
52482
- optionId: bigint;
52483
- id: string;
52484
- ownerAddr: Address;
52485
- marketAddr: Address;
52486
- perpDuration: number;
52487
- expiresAt: number;
52488
- closed: boolean;
52489
- }[];
52490
- } | {
52491
- error: null;
52492
- isError: false;
52493
- isPending: true;
52494
- isLoading: true;
52495
- isLoadingError: false;
52496
- isRefetchError: false;
52497
- isSuccess: false;
52498
- isPlaceholderData: false;
52499
- status: "pending";
52500
- dataUpdatedAt: number;
52501
- errorUpdatedAt: number;
52502
- failureCount: number;
52503
- failureReason: Error | null;
52504
- errorUpdateCount: number;
52505
- isFetched: boolean;
52506
- isFetchedAfterMount: boolean;
52507
- isFetching: boolean;
52508
- isInitialLoading: boolean;
52509
- isPaused: boolean;
52510
- isRefetching: boolean;
52511
- isStale: boolean;
52512
- isEnabled: boolean;
52513
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
52514
- optionId: bigint;
52515
- id: string;
52516
- ownerAddr: Address;
52517
- marketAddr: Address;
52518
- perpDuration: number;
52519
- expiresAt: number;
52520
- closed: boolean;
52521
- }[] | undefined, Error>>;
52522
- fetchStatus: _tanstack_query_core0.FetchStatus;
52523
- promise: Promise<{
52524
- optionId: bigint;
52525
- id: string;
52526
- ownerAddr: Address;
52527
- marketAddr: Address;
52528
- perpDuration: number;
52529
- expiresAt: number;
52530
- closed: boolean;
52531
- }[] | undefined>;
52532
- data: {
52533
- optionId: bigint;
52534
- id: string;
52535
- ownerAddr: Address;
52536
- marketAddr: Address;
52537
- perpDuration: number;
52538
- expiresAt: number;
52539
- closed: boolean;
52540
- }[];
52541
- } | {
52542
- error: null;
52543
- isError: false;
52544
- isPending: true;
52545
- isLoadingError: false;
52546
- isRefetchError: false;
52547
- isSuccess: false;
52548
- isPlaceholderData: false;
52549
- status: "pending";
52550
- dataUpdatedAt: number;
52551
- errorUpdatedAt: number;
52552
- failureCount: number;
52553
- failureReason: Error | null;
52554
- errorUpdateCount: number;
52555
- isFetched: boolean;
52556
- isFetchedAfterMount: boolean;
52557
- isFetching: boolean;
52558
- isLoading: boolean;
52559
- isInitialLoading: boolean;
52560
- isPaused: boolean;
52561
- isRefetching: boolean;
52562
- isStale: boolean;
52563
- isEnabled: boolean;
52564
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
52565
- optionId: bigint;
52566
- id: string;
52567
- ownerAddr: Address;
52568
- marketAddr: Address;
52569
- perpDuration: number;
52570
- expiresAt: number;
52571
- closed: boolean;
52572
- }[] | undefined, Error>>;
52573
- fetchStatus: _tanstack_query_core0.FetchStatus;
52574
- promise: Promise<{
52575
- optionId: bigint;
52576
- id: string;
52577
- ownerAddr: Address;
52578
- marketAddr: Address;
52579
- perpDuration: number;
52580
- expiresAt: number;
52581
- closed: boolean;
52582
- }[] | undefined>;
52583
- data: {
52584
- optionId: bigint;
52585
- id: string;
52586
- ownerAddr: Address;
52587
- marketAddr: Address;
52588
- perpDuration: number;
52589
- expiresAt: number;
52590
- closed: boolean;
52591
- }[];
52592
- } | {
52593
- isError: false;
52594
- error: null;
52595
- isPending: false;
52596
- isLoading: false;
52597
- isLoadingError: false;
52598
- isRefetchError: false;
52599
- isSuccess: true;
52600
- isPlaceholderData: true;
52601
- status: "success";
52602
- dataUpdatedAt: number;
52603
- errorUpdatedAt: number;
52604
- failureCount: number;
52605
- failureReason: Error | null;
52606
- errorUpdateCount: number;
52607
- isFetched: boolean;
52608
- isFetchedAfterMount: boolean;
52609
- isFetching: boolean;
52610
- isInitialLoading: boolean;
52611
- isPaused: boolean;
52612
- isRefetching: boolean;
52613
- isStale: boolean;
52614
- isEnabled: boolean;
52615
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
52616
- optionId: bigint;
52617
- id: string;
52618
- ownerAddr: Address;
52619
- marketAddr: Address;
52620
- perpDuration: number;
52621
- expiresAt: number;
52622
- closed: boolean;
52623
- }[] | undefined, Error>>;
52624
- fetchStatus: _tanstack_query_core0.FetchStatus;
52625
- promise: Promise<{
52626
- optionId: bigint;
52627
- id: string;
52628
- ownerAddr: Address;
52629
- marketAddr: Address;
52630
- perpDuration: number;
52631
- expiresAt: number;
52632
- closed: boolean;
52633
- }[] | undefined>;
52634
- data: {
52635
- optionId: bigint;
52636
- id: string;
52637
- ownerAddr: Address;
52638
- marketAddr: Address;
52639
- perpDuration: number;
52640
- expiresAt: number;
52641
- closed: boolean;
52642
- }[];
52643
- };
52644
- declare const useActiveUserPerps: (marketAddr: Address | undefined, userAddr: Address | undefined) => {
52645
- error: Error;
52646
- isError: true;
52647
- isPending: false;
52648
- isLoading: false;
52649
- isLoadingError: false;
52650
- isRefetchError: true;
52651
- isSuccess: false;
52652
- isPlaceholderData: false;
52653
- status: "error";
52654
- dataUpdatedAt: number;
52655
- errorUpdatedAt: number;
52656
- failureCount: number;
52657
- failureReason: Error | null;
52658
- errorUpdateCount: number;
52659
- isFetched: boolean;
52660
- isFetchedAfterMount: boolean;
52661
- isFetching: boolean;
52662
- isInitialLoading: boolean;
52663
- isPaused: boolean;
52664
- isRefetching: boolean;
52665
- isStale: boolean;
52666
- isEnabled: boolean;
52667
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
52668
- optionId: bigint;
52669
- id: string;
52670
- ownerAddr: Address;
52671
- marketAddr: Address;
52672
- perpDuration: number;
52673
- expiresAt: number;
52674
- closed: boolean;
52675
- }[] | undefined, Error>>;
52676
- fetchStatus: _tanstack_query_core0.FetchStatus;
52677
- promise: Promise<{
52678
- optionId: bigint;
52679
- id: string;
52680
- ownerAddr: Address;
52681
- marketAddr: Address;
52682
- perpDuration: number;
52683
- expiresAt: number;
52684
- closed: boolean;
52685
- }[] | undefined>;
52686
- data: {
52687
- optionId: bigint;
52688
- id: string;
52689
- ownerAddr: Address;
52690
- marketAddr: Address;
52691
- perpDuration: number;
52692
- expiresAt: number;
52693
- closed: boolean;
52694
- }[];
52695
- } | {
52696
- error: null;
52697
- isError: false;
52698
- isPending: false;
52699
- isLoading: false;
52700
- isLoadingError: false;
52701
- isRefetchError: false;
52702
- isSuccess: true;
52703
- isPlaceholderData: false;
52704
- status: "success";
52705
- dataUpdatedAt: number;
52706
- errorUpdatedAt: number;
52707
- failureCount: number;
52708
- failureReason: Error | null;
52709
- errorUpdateCount: number;
52710
- isFetched: boolean;
52711
- isFetchedAfterMount: boolean;
52712
- isFetching: boolean;
52713
- isInitialLoading: boolean;
52714
- isPaused: boolean;
52715
- isRefetching: boolean;
52716
- isStale: boolean;
52717
- isEnabled: boolean;
52718
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
52719
- optionId: bigint;
52720
- id: string;
52721
- ownerAddr: Address;
52722
- marketAddr: Address;
52723
- perpDuration: number;
52724
- expiresAt: number;
52725
- closed: boolean;
52726
- }[] | undefined, Error>>;
52727
- fetchStatus: _tanstack_query_core0.FetchStatus;
52728
- promise: Promise<{
52729
- optionId: bigint;
52730
- id: string;
52731
- ownerAddr: Address;
52732
- marketAddr: Address;
52733
- perpDuration: number;
52734
- expiresAt: number;
52735
- closed: boolean;
52736
- }[] | undefined>;
52737
- data: {
52738
- optionId: bigint;
52739
- id: string;
52740
- ownerAddr: Address;
52741
- marketAddr: Address;
52742
- perpDuration: number;
52743
- expiresAt: number;
52744
- closed: boolean;
52745
- }[];
52746
- } | {
52747
- error: Error;
52748
- isError: true;
52749
- isPending: false;
52750
- isLoading: false;
52751
- isLoadingError: true;
52752
- isRefetchError: false;
52753
- isSuccess: false;
52754
- isPlaceholderData: false;
52755
- status: "error";
52756
- dataUpdatedAt: number;
52757
- errorUpdatedAt: number;
52758
- failureCount: number;
52759
- failureReason: Error | null;
52760
- errorUpdateCount: number;
52761
- isFetched: boolean;
52762
- isFetchedAfterMount: boolean;
52763
- isFetching: boolean;
52764
- isInitialLoading: boolean;
52765
- isPaused: boolean;
52766
- isRefetching: boolean;
52767
- isStale: boolean;
52768
- isEnabled: boolean;
52769
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
52770
- optionId: bigint;
52771
- id: string;
52772
- ownerAddr: Address;
52773
- marketAddr: Address;
52774
- perpDuration: number;
52775
- expiresAt: number;
52776
- closed: boolean;
52777
- }[] | undefined, Error>>;
52778
- fetchStatus: _tanstack_query_core0.FetchStatus;
52779
- promise: Promise<{
52780
- optionId: bigint;
52781
- id: string;
52782
- ownerAddr: Address;
52783
- marketAddr: Address;
52784
- perpDuration: number;
52785
- expiresAt: number;
52786
- closed: boolean;
52787
- }[] | undefined>;
52788
- data: {
52789
- optionId: bigint;
52790
- id: string;
52791
- ownerAddr: Address;
52792
- marketAddr: Address;
52793
- perpDuration: number;
52794
- expiresAt: number;
52795
- closed: boolean;
52796
- }[];
52797
- } | {
52798
- error: null;
52799
- isError: false;
52800
- isPending: true;
52801
- isLoading: true;
52802
- isLoadingError: false;
52803
- isRefetchError: false;
52804
- isSuccess: false;
52805
- isPlaceholderData: false;
52806
- status: "pending";
52807
- dataUpdatedAt: number;
52808
- errorUpdatedAt: number;
52809
- failureCount: number;
52810
- failureReason: Error | null;
52811
- errorUpdateCount: number;
52812
- isFetched: boolean;
52813
- isFetchedAfterMount: boolean;
52814
- isFetching: boolean;
52815
- isInitialLoading: boolean;
52816
- isPaused: boolean;
52817
- isRefetching: boolean;
52818
- isStale: boolean;
52819
- isEnabled: boolean;
52820
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
52821
- optionId: bigint;
52822
- id: string;
52823
- ownerAddr: Address;
52824
- marketAddr: Address;
52825
- perpDuration: number;
52826
- expiresAt: number;
52827
- closed: boolean;
52828
- }[] | undefined, Error>>;
52829
- fetchStatus: _tanstack_query_core0.FetchStatus;
52830
- promise: Promise<{
52831
- optionId: bigint;
52832
- id: string;
52833
- ownerAddr: Address;
52834
- marketAddr: Address;
52835
- perpDuration: number;
52836
- expiresAt: number;
52837
- closed: boolean;
52838
- }[] | undefined>;
52839
- data: {
52840
- optionId: bigint;
52841
- id: string;
52842
- ownerAddr: Address;
52843
- marketAddr: Address;
52844
- perpDuration: number;
52845
- expiresAt: number;
52846
- closed: boolean;
52847
- }[];
52848
- } | {
52849
- error: null;
52850
- isError: false;
52851
- isPending: true;
52852
- isLoadingError: false;
52853
- isRefetchError: false;
52854
- isSuccess: false;
52855
- isPlaceholderData: false;
52856
- status: "pending";
52857
- dataUpdatedAt: number;
52858
- errorUpdatedAt: number;
52859
- failureCount: number;
52860
- failureReason: Error | null;
52861
- errorUpdateCount: number;
52862
- isFetched: boolean;
52863
- isFetchedAfterMount: boolean;
52864
- isFetching: boolean;
52865
- isLoading: boolean;
52866
- isInitialLoading: boolean;
52867
- isPaused: boolean;
52868
- isRefetching: boolean;
52869
- isStale: boolean;
52870
- isEnabled: boolean;
52871
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
52872
- optionId: bigint;
52873
- id: string;
52874
- ownerAddr: Address;
52875
- marketAddr: Address;
52876
- perpDuration: number;
52877
- expiresAt: number;
52878
- closed: boolean;
52879
- }[] | undefined, Error>>;
52880
- fetchStatus: _tanstack_query_core0.FetchStatus;
52881
- promise: Promise<{
52882
- optionId: bigint;
52883
- id: string;
52884
- ownerAddr: Address;
52885
- marketAddr: Address;
52886
- perpDuration: number;
52887
- expiresAt: number;
52888
- closed: boolean;
52889
- }[] | undefined>;
52890
- data: {
52891
- optionId: bigint;
52892
- id: string;
52893
- ownerAddr: Address;
52894
- marketAddr: Address;
52895
- perpDuration: number;
52896
- expiresAt: number;
52897
- closed: boolean;
52898
- }[];
52899
- } | {
52900
- isError: false;
52901
- error: null;
52902
- isPending: false;
52903
- isLoading: false;
52904
- isLoadingError: false;
52905
- isRefetchError: false;
52906
- isSuccess: true;
52907
- isPlaceholderData: true;
52908
- status: "success";
52909
- dataUpdatedAt: number;
52910
- errorUpdatedAt: number;
52911
- failureCount: number;
52912
- failureReason: Error | null;
52913
- errorUpdateCount: number;
52914
- isFetched: boolean;
52915
- isFetchedAfterMount: boolean;
52916
- isFetching: boolean;
52917
- isInitialLoading: boolean;
52918
- isPaused: boolean;
52919
- isRefetching: boolean;
52920
- isStale: boolean;
52921
- isEnabled: boolean;
52922
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
52923
- optionId: bigint;
52924
- id: string;
52925
- ownerAddr: Address;
52926
- marketAddr: Address;
52927
- perpDuration: number;
52928
- expiresAt: number;
52929
- closed: boolean;
52930
- }[] | undefined, Error>>;
52931
- fetchStatus: _tanstack_query_core0.FetchStatus;
52932
- promise: Promise<{
52933
- optionId: bigint;
52934
- id: string;
52935
- ownerAddr: Address;
52936
- marketAddr: Address;
52937
- perpDuration: number;
52938
- expiresAt: number;
52939
- closed: boolean;
52940
- }[] | undefined>;
52941
- data: {
52942
- optionId: bigint;
52943
- id: string;
52944
- ownerAddr: Address;
52945
- marketAddr: Address;
52946
- perpDuration: number;
52947
- expiresAt: number;
52948
- closed: boolean;
52949
- }[];
52950
- };
52951
- declare const useClosedUserPerps: (marketAddr: Address | undefined, userAddr: Address | undefined) => {
52952
- error: Error;
52953
- isError: true;
52954
- isPending: false;
52955
- isLoading: false;
52956
- isLoadingError: false;
52957
- isRefetchError: true;
52958
- isSuccess: false;
52959
- isPlaceholderData: false;
52960
- status: "error";
52961
- dataUpdatedAt: number;
52962
- errorUpdatedAt: number;
52963
- failureCount: number;
52964
- failureReason: Error | null;
52965
- errorUpdateCount: number;
52966
- isFetched: boolean;
52967
- isFetchedAfterMount: boolean;
52968
- isFetching: boolean;
52969
- isInitialLoading: boolean;
52970
- isPaused: boolean;
52971
- isRefetching: boolean;
52972
- isStale: boolean;
52973
- isEnabled: boolean;
52974
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
52975
- optionId: bigint;
52976
- id: string;
52977
- ownerAddr: Address;
52978
- marketAddr: Address;
52979
- perpDuration: number;
52980
- expiresAt: number;
52981
- closed: boolean;
52982
- }[] | undefined, Error>>;
52983
- fetchStatus: _tanstack_query_core0.FetchStatus;
52984
- promise: Promise<{
52985
- optionId: bigint;
52986
- id: string;
52987
- ownerAddr: Address;
52988
- marketAddr: Address;
52989
- perpDuration: number;
52990
- expiresAt: number;
52991
- closed: boolean;
52992
- }[] | undefined>;
52993
- data: {
52994
- optionId: bigint;
52995
- id: string;
52996
- ownerAddr: Address;
52997
- marketAddr: Address;
52998
- perpDuration: number;
52999
- expiresAt: number;
53000
- closed: boolean;
53001
- }[];
53002
- } | {
53003
- error: null;
53004
- isError: false;
53005
- isPending: false;
53006
- isLoading: false;
53007
- isLoadingError: false;
53008
- isRefetchError: false;
53009
- isSuccess: true;
53010
- isPlaceholderData: false;
53011
- status: "success";
53012
- dataUpdatedAt: number;
53013
- errorUpdatedAt: number;
53014
- failureCount: number;
53015
- failureReason: Error | null;
53016
- errorUpdateCount: number;
53017
- isFetched: boolean;
53018
- isFetchedAfterMount: boolean;
53019
- isFetching: boolean;
53020
- isInitialLoading: boolean;
53021
- isPaused: boolean;
53022
- isRefetching: boolean;
53023
- isStale: boolean;
53024
- isEnabled: boolean;
53025
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
53026
- optionId: bigint;
53027
- id: string;
53028
- ownerAddr: Address;
53029
- marketAddr: Address;
53030
- perpDuration: number;
53031
- expiresAt: number;
53032
- closed: boolean;
53033
- }[] | undefined, Error>>;
53034
- fetchStatus: _tanstack_query_core0.FetchStatus;
53035
- promise: Promise<{
53036
- optionId: bigint;
53037
- id: string;
53038
- ownerAddr: Address;
53039
- marketAddr: Address;
53040
- perpDuration: number;
53041
- expiresAt: number;
53042
- closed: boolean;
53043
- }[] | undefined>;
53044
- data: {
53045
- optionId: bigint;
53046
- id: string;
53047
- ownerAddr: Address;
53048
- marketAddr: Address;
53049
- perpDuration: number;
53050
- expiresAt: number;
53051
- closed: boolean;
53052
- }[];
53053
- } | {
53054
- error: Error;
53055
- isError: true;
53056
- isPending: false;
53057
- isLoading: false;
53058
- isLoadingError: true;
53059
- isRefetchError: false;
53060
- isSuccess: false;
53061
- isPlaceholderData: false;
53062
- status: "error";
53063
- dataUpdatedAt: number;
53064
- errorUpdatedAt: number;
53065
- failureCount: number;
53066
- failureReason: Error | null;
53067
- errorUpdateCount: number;
53068
- isFetched: boolean;
53069
- isFetchedAfterMount: boolean;
53070
- isFetching: boolean;
53071
- isInitialLoading: boolean;
53072
- isPaused: boolean;
53073
- isRefetching: boolean;
53074
- isStale: boolean;
53075
- isEnabled: boolean;
53076
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
53077
- optionId: bigint;
53078
- id: string;
53079
- ownerAddr: Address;
53080
- marketAddr: Address;
53081
- perpDuration: number;
53082
- expiresAt: number;
53083
- closed: boolean;
53084
- }[] | undefined, Error>>;
53085
- fetchStatus: _tanstack_query_core0.FetchStatus;
53086
- promise: Promise<{
53087
- optionId: bigint;
53088
- id: string;
53089
- ownerAddr: Address;
53090
- marketAddr: Address;
53091
- perpDuration: number;
53092
- expiresAt: number;
53093
- closed: boolean;
53094
- }[] | undefined>;
53095
- data: {
53096
- optionId: bigint;
53097
- id: string;
53098
- ownerAddr: Address;
53099
- marketAddr: Address;
53100
- perpDuration: number;
53101
- expiresAt: number;
53102
- closed: boolean;
53103
- }[];
49373
+ declare const useUserOptions: (userAddr: Address | undefined, marketAddr: Address | "*" | undefined, active?: boolean) => _tanstack_react_query0.UseQueryResult<{
49374
+ optionId: bigint;
49375
+ marketAddr: Address;
49376
+ ownerAddr: Address;
49377
+ optionType: "CALL" | "PUT";
49378
+ createdAt: Date;
49379
+ expiresAt: Date;
49380
+ premium: bigint;
49381
+ protocolFee: bigint;
49382
+ realizedPayout: bigint;
49383
+ liquiditiesAtOpen: bigint[];
49384
+ liquiditiesCurrent: bigint[];
49385
+ positionSizeAtOpen: bigint;
49386
+ positionSizeCurrent: bigint;
49387
+ strikePrice: bigint;
49388
+ entryPrice: bigint;
49389
+ __typename: "UserOption";
49390
+ id: string;
49391
+ strikeTick: number;
49392
+ startTick: number;
49393
+ fullyExercised: boolean;
49394
+ owner?: {
49395
+ __typename: "TimelockMarketUser";
49396
+ address: string;
49397
+ } | null;
49398
+ market?: {
49399
+ __typename: "TimelockMarket";
49400
+ address: string;
49401
+ } | null;
49402
+ }[], Error>;
49403
+ declare const useActiveUserOptions: (userAddr?: Address, marketAddr?: Address | "*") => _tanstack_react_query0.UseQueryResult<{
49404
+ optionId: bigint;
49405
+ marketAddr: Address;
49406
+ ownerAddr: Address;
49407
+ optionType: "CALL" | "PUT";
49408
+ createdAt: Date;
49409
+ expiresAt: Date;
49410
+ premium: bigint;
49411
+ protocolFee: bigint;
49412
+ realizedPayout: bigint;
49413
+ liquiditiesAtOpen: bigint[];
49414
+ liquiditiesCurrent: bigint[];
49415
+ positionSizeAtOpen: bigint;
49416
+ positionSizeCurrent: bigint;
49417
+ strikePrice: bigint;
49418
+ entryPrice: bigint;
49419
+ __typename: "UserOption";
49420
+ id: string;
49421
+ strikeTick: number;
49422
+ startTick: number;
49423
+ fullyExercised: boolean;
49424
+ owner?: {
49425
+ __typename: "TimelockMarketUser";
49426
+ address: string;
49427
+ } | null;
49428
+ market?: {
49429
+ __typename: "TimelockMarket";
49430
+ address: string;
49431
+ } | null;
49432
+ }[], Error>;
49433
+ declare const useClosedUserOptions: (userAddr?: Address, marketAddr?: Address | "*") => _tanstack_react_query0.UseQueryResult<{
49434
+ optionId: bigint;
49435
+ marketAddr: Address;
49436
+ ownerAddr: Address;
49437
+ optionType: "CALL" | "PUT";
49438
+ createdAt: Date;
49439
+ expiresAt: Date;
49440
+ premium: bigint;
49441
+ protocolFee: bigint;
49442
+ realizedPayout: bigint;
49443
+ liquiditiesAtOpen: bigint[];
49444
+ liquiditiesCurrent: bigint[];
49445
+ positionSizeAtOpen: bigint;
49446
+ positionSizeCurrent: bigint;
49447
+ strikePrice: bigint;
49448
+ entryPrice: bigint;
49449
+ __typename: "UserOption";
49450
+ id: string;
49451
+ strikeTick: number;
49452
+ startTick: number;
49453
+ fullyExercised: boolean;
49454
+ owner?: {
49455
+ __typename: "TimelockMarketUser";
49456
+ address: string;
49457
+ } | null;
49458
+ market?: {
49459
+ __typename: "TimelockMarket";
49460
+ address: string;
49461
+ } | null;
49462
+ }[], Error>;
49463
+ //#endregion
49464
+ //#region src/hooks/options/useExerciseOption.d.ts
49465
+ declare const useExerciseOption: (marketAddr: Address | undefined) => _tanstack_react_query0.UseMutationResult<`0x${string}`, Error, {
49466
+ option: OptionData;
49467
+ liquidities: readonly bigint[];
49468
+ }, unknown>;
49469
+ //#endregion
49470
+ //#region src/hooks/options/useOptionPnl.d.ts
49471
+ declare const useOptionPnl: (option: OptionData) => {
49472
+ unrealizedPayout: Amount | undefined;
49473
+ displayPnl: Amount | undefined;
49474
+ };
49475
+ //#endregion
49476
+ //#region src/hooks/options/useOptionPremium.d.ts
49477
+ declare const useOptionPremium: (marketAddr: Address | undefined, optionType: "CALL" | "PUT", optionAmount?: bigint, addedDuration?: number, remainingDuration?: number, strikeTick?: number) => {
49478
+ premium?: undefined;
49479
+ protocolFee?: undefined;
49480
+ totalPremium?: undefined;
53104
49481
  } | {
53105
- error: null;
53106
- isError: false;
53107
- isPending: true;
53108
- isLoading: true;
53109
- isLoadingError: false;
53110
- isRefetchError: false;
53111
- isSuccess: false;
53112
- isPlaceholderData: false;
53113
- status: "pending";
53114
- dataUpdatedAt: number;
53115
- errorUpdatedAt: number;
53116
- failureCount: number;
53117
- failureReason: Error | null;
53118
- errorUpdateCount: number;
53119
- isFetched: boolean;
53120
- isFetchedAfterMount: boolean;
53121
- isFetching: boolean;
53122
- isInitialLoading: boolean;
53123
- isPaused: boolean;
53124
- isRefetching: boolean;
53125
- isStale: boolean;
53126
- isEnabled: boolean;
53127
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
53128
- optionId: bigint;
53129
- id: string;
53130
- ownerAddr: Address;
53131
- marketAddr: Address;
53132
- perpDuration: number;
53133
- expiresAt: number;
53134
- closed: boolean;
53135
- }[] | undefined, Error>>;
53136
- fetchStatus: _tanstack_query_core0.FetchStatus;
53137
- promise: Promise<{
53138
- optionId: bigint;
53139
- id: string;
53140
- ownerAddr: Address;
53141
- marketAddr: Address;
53142
- perpDuration: number;
53143
- expiresAt: number;
53144
- closed: boolean;
53145
- }[] | undefined>;
49482
+ premium: Amount;
49483
+ protocolFee: Amount;
49484
+ totalPremium: Amount;
49485
+ };
49486
+ //#endregion
49487
+ //#region src/hooks/options/useExtendOption.d.ts
49488
+ declare const useExtendOption: (marketAddr: Address | undefined) => _tanstack_react_query0.UseMutationResult<`0x${string}`, Error, {
49489
+ option: OptionData;
49490
+ duration: number;
49491
+ }, unknown>;
49492
+ //#endregion
49493
+ //#region src/hooks/options/useOptionTimeline.d.ts
49494
+ type OptionEvent = NonUndefinedGuard<ReturnType<typeof useOptionTimeline>['data']>[number];
49495
+ type MintOptionEvent = Extract<OptionEvent, {
49496
+ type: 'mint';
49497
+ }>;
49498
+ type ExerciseOptionEvent = Extract<OptionEvent, {
49499
+ type: 'exercise';
49500
+ }>;
49501
+ type ExtendEvent = Extract<OptionEvent, {
49502
+ type: 'extend';
49503
+ }>;
49504
+ declare const useOptionTimeline: (marketAddr: Address | undefined, optionId: bigint | undefined) => _tanstack_react_query0.UseQueryResult<({
49505
+ type: "mint";
53146
49506
  data: {
53147
- optionId: bigint;
53148
49507
  id: string;
53149
- ownerAddr: Address;
53150
- marketAddr: Address;
53151
- perpDuration: number;
53152
- expiresAt: number;
53153
- closed: boolean;
53154
- }[];
49508
+ optionType: 0 | 1;
49509
+ strikeTick: number;
49510
+ price: bigint;
49511
+ premium: bigint;
49512
+ protocolFee: bigint;
49513
+ liquidities: bigint[];
49514
+ timestamp: Date;
49515
+ expiresAt: Date;
49516
+ blockNumber: bigint;
49517
+ transactionHash: string;
49518
+ };
53155
49519
  } | {
53156
- error: null;
53157
- isError: false;
53158
- isPending: true;
53159
- isLoadingError: false;
53160
- isRefetchError: false;
53161
- isSuccess: false;
53162
- isPlaceholderData: false;
53163
- status: "pending";
53164
- dataUpdatedAt: number;
53165
- errorUpdatedAt: number;
53166
- failureCount: number;
53167
- failureReason: Error | null;
53168
- errorUpdateCount: number;
53169
- isFetched: boolean;
53170
- isFetchedAfterMount: boolean;
53171
- isFetching: boolean;
53172
- isLoading: boolean;
53173
- isInitialLoading: boolean;
53174
- isPaused: boolean;
53175
- isRefetching: boolean;
53176
- isStale: boolean;
53177
- isEnabled: boolean;
53178
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
53179
- optionId: bigint;
53180
- id: string;
53181
- ownerAddr: Address;
53182
- marketAddr: Address;
53183
- perpDuration: number;
53184
- expiresAt: number;
53185
- closed: boolean;
53186
- }[] | undefined, Error>>;
53187
- fetchStatus: _tanstack_query_core0.FetchStatus;
53188
- promise: Promise<{
53189
- optionId: bigint;
53190
- id: string;
53191
- ownerAddr: Address;
53192
- marketAddr: Address;
53193
- perpDuration: number;
53194
- expiresAt: number;
53195
- closed: boolean;
53196
- }[] | undefined>;
49520
+ type: "exercise";
53197
49521
  data: {
53198
- optionId: bigint;
53199
49522
  id: string;
53200
- ownerAddr: Address;
53201
- marketAddr: Address;
53202
- perpDuration: number;
53203
- expiresAt: number;
53204
- closed: boolean;
53205
- }[];
49523
+ payout: bigint;
49524
+ price: bigint;
49525
+ liquidities: bigint[];
49526
+ timestamp: Date;
49527
+ blockNumber: bigint;
49528
+ transactionHash: string;
49529
+ };
53206
49530
  } | {
53207
- isError: false;
53208
- error: null;
53209
- isPending: false;
53210
- isLoading: false;
53211
- isLoadingError: false;
53212
- isRefetchError: false;
53213
- isSuccess: true;
53214
- isPlaceholderData: true;
53215
- status: "success";
53216
- dataUpdatedAt: number;
53217
- errorUpdatedAt: number;
53218
- failureCount: number;
53219
- failureReason: Error | null;
53220
- errorUpdateCount: number;
53221
- isFetched: boolean;
53222
- isFetchedAfterMount: boolean;
53223
- isFetching: boolean;
53224
- isInitialLoading: boolean;
53225
- isPaused: boolean;
53226
- isRefetching: boolean;
53227
- isStale: boolean;
53228
- isEnabled: boolean;
53229
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
53230
- optionId: bigint;
53231
- id: string;
53232
- ownerAddr: Address;
53233
- marketAddr: Address;
53234
- perpDuration: number;
53235
- expiresAt: number;
53236
- closed: boolean;
53237
- }[] | undefined, Error>>;
53238
- fetchStatus: _tanstack_query_core0.FetchStatus;
53239
- promise: Promise<{
53240
- optionId: bigint;
53241
- id: string;
53242
- ownerAddr: Address;
53243
- marketAddr: Address;
53244
- perpDuration: number;
53245
- expiresAt: number;
53246
- closed: boolean;
53247
- }[] | undefined>;
49531
+ type: "extend";
53248
49532
  data: {
53249
- optionId: bigint;
53250
49533
  id: string;
53251
- ownerAddr: Address;
53252
- marketAddr: Address;
53253
- perpDuration: number;
53254
- expiresAt: number;
53255
- closed: boolean;
53256
- }[];
49534
+ premium: bigint;
49535
+ protocolFee: bigint;
49536
+ price: bigint;
49537
+ addedDuration: bigint;
49538
+ timestamp: Date;
49539
+ blockNumber: bigint;
49540
+ transactionHash: string;
49541
+ };
49542
+ })[], Error>;
49543
+ //#endregion
49544
+ //#region src/hooks/perps/useMintPerp.d.ts
49545
+ declare const useMintPerp: (marketAddr: Address | undefined) => _tanstack_react_query0.UseMutationResult<void, Error, {
49546
+ optionType: "CALL" | "PUT";
49547
+ amount: bigint;
49548
+ duration: number;
49549
+ strikeTick?: number;
49550
+ }, unknown>;
49551
+ //#endregion
49552
+ //#region src/hooks/perps/useClosePerp.d.ts
49553
+ declare const useClosePerp: () => _tanstack_react_query0.UseMutationResult<void, Error, ExercisePerpBody, unknown>;
49554
+ //#endregion
49555
+ //#region src/hooks/perps/usePerpsOperator.d.ts
49556
+ declare const usePerpsOperator: () => {
49557
+ operator: PerpsOperator | undefined;
49558
+ address: `0x${string}` | undefined;
49559
+ signMessage: _tanstack_react_query0.UseMutationResult<void, Error, void, unknown>;
53257
49560
  };
53258
49561
  //#endregion
49562
+ //#region src/hooks/perps/useUserPerps.d.ts
49563
+ declare const useUserPerps: (marketAddr: Address | undefined, userAddr: Address | undefined, type: "active" | "closed" | undefined) => _tanstack_react_query0.UseQueryResult<{
49564
+ optionId: bigint;
49565
+ id: string;
49566
+ ownerAddr: Address;
49567
+ marketAddr: Address;
49568
+ perpDuration: number;
49569
+ expiresAt: number;
49570
+ closed: boolean;
49571
+ }[] | undefined, Error>;
49572
+ declare const useActiveUserPerps: (marketAddr: Address | undefined, userAddr: Address | undefined) => _tanstack_react_query0.UseQueryResult<{
49573
+ optionId: bigint;
49574
+ id: string;
49575
+ ownerAddr: Address;
49576
+ marketAddr: Address;
49577
+ perpDuration: number;
49578
+ expiresAt: number;
49579
+ closed: boolean;
49580
+ }[] | undefined, Error>;
49581
+ declare const useClosedUserPerps: (marketAddr: Address | undefined, userAddr: Address | undefined) => _tanstack_react_query0.UseQueryResult<{
49582
+ optionId: bigint;
49583
+ id: string;
49584
+ ownerAddr: Address;
49585
+ marketAddr: Address;
49586
+ perpDuration: number;
49587
+ expiresAt: number;
49588
+ closed: boolean;
49589
+ }[] | undefined, Error>;
49590
+ //#endregion
53259
49591
  //#region src/hooks/operators/useOperatorPerms.d.ts
53260
49592
  declare const useOperatorPerms: (marketAddr?: Address, userAddr?: Address, operatorAddr?: Address) => {
53261
49593
  error: viem491.ReadContractErrorType;
@@ -53470,403 +49802,20 @@ declare const useOperatorPerms: (marketAddr?: Address, userAddr?: Address, opera
53470
49802
  };
53471
49803
  //#endregion
53472
49804
  //#region src/hooks/operators/useUserOperators.d.ts
53473
- declare const useUserOperators: (userAddr?: Address, marketAddr?: Address) => {
53474
- data: {
53475
- spendingApproval: bigint;
53476
- operatorAddr: string;
53477
- __typename: "UserMarketOperator";
53478
- id: string;
53479
- canExtend: boolean;
53480
- canExercise: boolean;
53481
- canTransfer: boolean;
53482
- canMint: boolean;
53483
- operator?: {
53484
- __typename: "MarketOperator";
53485
- address: string;
53486
- } | null;
53487
- }[];
53488
- error: Error;
53489
- isError: true;
53490
- isPending: false;
53491
- isLoading: false;
53492
- isLoadingError: false;
53493
- isRefetchError: true;
53494
- isSuccess: false;
53495
- isPlaceholderData: false;
53496
- status: "error";
53497
- dataUpdatedAt: number;
53498
- errorUpdatedAt: number;
53499
- failureCount: number;
53500
- failureReason: Error | null;
53501
- errorUpdateCount: number;
53502
- isFetched: boolean;
53503
- isFetchedAfterMount: boolean;
53504
- isFetching: boolean;
53505
- isInitialLoading: boolean;
53506
- isPaused: boolean;
53507
- isRefetching: boolean;
53508
- isStale: boolean;
53509
- isEnabled: boolean;
53510
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
53511
- spendingApproval: bigint;
53512
- operatorAddr: string;
53513
- __typename: "UserMarketOperator";
53514
- id: string;
53515
- canExtend: boolean;
53516
- canExercise: boolean;
53517
- canTransfer: boolean;
53518
- canMint: boolean;
53519
- operator?: {
53520
- __typename: "MarketOperator";
53521
- address: string;
53522
- } | null;
53523
- }[] | undefined, Error>>;
53524
- fetchStatus: _tanstack_query_core0.FetchStatus;
53525
- promise: Promise<{
53526
- spendingApproval: bigint;
53527
- operatorAddr: string;
53528
- __typename: "UserMarketOperator";
53529
- id: string;
53530
- canExtend: boolean;
53531
- canExercise: boolean;
53532
- canTransfer: boolean;
53533
- canMint: boolean;
53534
- operator?: {
53535
- __typename: "MarketOperator";
53536
- address: string;
53537
- } | null;
53538
- }[] | undefined>;
53539
- } | {
53540
- data: {
53541
- spendingApproval: bigint;
53542
- operatorAddr: string;
53543
- __typename: "UserMarketOperator";
53544
- id: string;
53545
- canExtend: boolean;
53546
- canExercise: boolean;
53547
- canTransfer: boolean;
53548
- canMint: boolean;
53549
- operator?: {
53550
- __typename: "MarketOperator";
53551
- address: string;
53552
- } | null;
53553
- }[];
53554
- error: null;
53555
- isError: false;
53556
- isPending: false;
53557
- isLoading: false;
53558
- isLoadingError: false;
53559
- isRefetchError: false;
53560
- isSuccess: true;
53561
- isPlaceholderData: false;
53562
- status: "success";
53563
- dataUpdatedAt: number;
53564
- errorUpdatedAt: number;
53565
- failureCount: number;
53566
- failureReason: Error | null;
53567
- errorUpdateCount: number;
53568
- isFetched: boolean;
53569
- isFetchedAfterMount: boolean;
53570
- isFetching: boolean;
53571
- isInitialLoading: boolean;
53572
- isPaused: boolean;
53573
- isRefetching: boolean;
53574
- isStale: boolean;
53575
- isEnabled: boolean;
53576
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
53577
- spendingApproval: bigint;
53578
- operatorAddr: string;
53579
- __typename: "UserMarketOperator";
53580
- id: string;
53581
- canExtend: boolean;
53582
- canExercise: boolean;
53583
- canTransfer: boolean;
53584
- canMint: boolean;
53585
- operator?: {
53586
- __typename: "MarketOperator";
53587
- address: string;
53588
- } | null;
53589
- }[] | undefined, Error>>;
53590
- fetchStatus: _tanstack_query_core0.FetchStatus;
53591
- promise: Promise<{
53592
- spendingApproval: bigint;
53593
- operatorAddr: string;
53594
- __typename: "UserMarketOperator";
53595
- id: string;
53596
- canExtend: boolean;
53597
- canExercise: boolean;
53598
- canTransfer: boolean;
53599
- canMint: boolean;
53600
- operator?: {
53601
- __typename: "MarketOperator";
53602
- address: string;
53603
- } | null;
53604
- }[] | undefined>;
53605
- } | {
53606
- data: {
53607
- spendingApproval: bigint;
53608
- operatorAddr: string;
53609
- __typename: "UserMarketOperator";
53610
- id: string;
53611
- canExtend: boolean;
53612
- canExercise: boolean;
53613
- canTransfer: boolean;
53614
- canMint: boolean;
53615
- operator?: {
53616
- __typename: "MarketOperator";
53617
- address: string;
53618
- } | null;
53619
- }[];
53620
- error: Error;
53621
- isError: true;
53622
- isPending: false;
53623
- isLoading: false;
53624
- isLoadingError: true;
53625
- isRefetchError: false;
53626
- isSuccess: false;
53627
- isPlaceholderData: false;
53628
- status: "error";
53629
- dataUpdatedAt: number;
53630
- errorUpdatedAt: number;
53631
- failureCount: number;
53632
- failureReason: Error | null;
53633
- errorUpdateCount: number;
53634
- isFetched: boolean;
53635
- isFetchedAfterMount: boolean;
53636
- isFetching: boolean;
53637
- isInitialLoading: boolean;
53638
- isPaused: boolean;
53639
- isRefetching: boolean;
53640
- isStale: boolean;
53641
- isEnabled: boolean;
53642
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
53643
- spendingApproval: bigint;
53644
- operatorAddr: string;
53645
- __typename: "UserMarketOperator";
53646
- id: string;
53647
- canExtend: boolean;
53648
- canExercise: boolean;
53649
- canTransfer: boolean;
53650
- canMint: boolean;
53651
- operator?: {
53652
- __typename: "MarketOperator";
53653
- address: string;
53654
- } | null;
53655
- }[] | undefined, Error>>;
53656
- fetchStatus: _tanstack_query_core0.FetchStatus;
53657
- promise: Promise<{
53658
- spendingApproval: bigint;
53659
- operatorAddr: string;
53660
- __typename: "UserMarketOperator";
53661
- id: string;
53662
- canExtend: boolean;
53663
- canExercise: boolean;
53664
- canTransfer: boolean;
53665
- canMint: boolean;
53666
- operator?: {
53667
- __typename: "MarketOperator";
53668
- address: string;
53669
- } | null;
53670
- }[] | undefined>;
53671
- } | {
53672
- data: {
53673
- spendingApproval: bigint;
53674
- operatorAddr: string;
53675
- __typename: "UserMarketOperator";
53676
- id: string;
53677
- canExtend: boolean;
53678
- canExercise: boolean;
53679
- canTransfer: boolean;
53680
- canMint: boolean;
53681
- operator?: {
53682
- __typename: "MarketOperator";
53683
- address: string;
53684
- } | null;
53685
- }[];
53686
- error: null;
53687
- isError: false;
53688
- isPending: true;
53689
- isLoading: true;
53690
- isLoadingError: false;
53691
- isRefetchError: false;
53692
- isSuccess: false;
53693
- isPlaceholderData: false;
53694
- status: "pending";
53695
- dataUpdatedAt: number;
53696
- errorUpdatedAt: number;
53697
- failureCount: number;
53698
- failureReason: Error | null;
53699
- errorUpdateCount: number;
53700
- isFetched: boolean;
53701
- isFetchedAfterMount: boolean;
53702
- isFetching: boolean;
53703
- isInitialLoading: boolean;
53704
- isPaused: boolean;
53705
- isRefetching: boolean;
53706
- isStale: boolean;
53707
- isEnabled: boolean;
53708
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
53709
- spendingApproval: bigint;
53710
- operatorAddr: string;
53711
- __typename: "UserMarketOperator";
53712
- id: string;
53713
- canExtend: boolean;
53714
- canExercise: boolean;
53715
- canTransfer: boolean;
53716
- canMint: boolean;
53717
- operator?: {
53718
- __typename: "MarketOperator";
53719
- address: string;
53720
- } | null;
53721
- }[] | undefined, Error>>;
53722
- fetchStatus: _tanstack_query_core0.FetchStatus;
53723
- promise: Promise<{
53724
- spendingApproval: bigint;
53725
- operatorAddr: string;
53726
- __typename: "UserMarketOperator";
53727
- id: string;
53728
- canExtend: boolean;
53729
- canExercise: boolean;
53730
- canTransfer: boolean;
53731
- canMint: boolean;
53732
- operator?: {
53733
- __typename: "MarketOperator";
53734
- address: string;
53735
- } | null;
53736
- }[] | undefined>;
53737
- } | {
53738
- data: {
53739
- spendingApproval: bigint;
53740
- operatorAddr: string;
53741
- __typename: "UserMarketOperator";
53742
- id: string;
53743
- canExtend: boolean;
53744
- canExercise: boolean;
53745
- canTransfer: boolean;
53746
- canMint: boolean;
53747
- operator?: {
53748
- __typename: "MarketOperator";
53749
- address: string;
53750
- } | null;
53751
- }[];
53752
- error: null;
53753
- isError: false;
53754
- isPending: true;
53755
- isLoadingError: false;
53756
- isRefetchError: false;
53757
- isSuccess: false;
53758
- isPlaceholderData: false;
53759
- status: "pending";
53760
- dataUpdatedAt: number;
53761
- errorUpdatedAt: number;
53762
- failureCount: number;
53763
- failureReason: Error | null;
53764
- errorUpdateCount: number;
53765
- isFetched: boolean;
53766
- isFetchedAfterMount: boolean;
53767
- isFetching: boolean;
53768
- isLoading: boolean;
53769
- isInitialLoading: boolean;
53770
- isPaused: boolean;
53771
- isRefetching: boolean;
53772
- isStale: boolean;
53773
- isEnabled: boolean;
53774
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
53775
- spendingApproval: bigint;
53776
- operatorAddr: string;
53777
- __typename: "UserMarketOperator";
53778
- id: string;
53779
- canExtend: boolean;
53780
- canExercise: boolean;
53781
- canTransfer: boolean;
53782
- canMint: boolean;
53783
- operator?: {
53784
- __typename: "MarketOperator";
53785
- address: string;
53786
- } | null;
53787
- }[] | undefined, Error>>;
53788
- fetchStatus: _tanstack_query_core0.FetchStatus;
53789
- promise: Promise<{
53790
- spendingApproval: bigint;
53791
- operatorAddr: string;
53792
- __typename: "UserMarketOperator";
53793
- id: string;
53794
- canExtend: boolean;
53795
- canExercise: boolean;
53796
- canTransfer: boolean;
53797
- canMint: boolean;
53798
- operator?: {
53799
- __typename: "MarketOperator";
53800
- address: string;
53801
- } | null;
53802
- }[] | undefined>;
53803
- } | {
53804
- data: {
53805
- spendingApproval: bigint;
53806
- operatorAddr: string;
53807
- __typename: "UserMarketOperator";
53808
- id: string;
53809
- canExtend: boolean;
53810
- canExercise: boolean;
53811
- canTransfer: boolean;
53812
- canMint: boolean;
53813
- operator?: {
53814
- __typename: "MarketOperator";
53815
- address: string;
53816
- } | null;
53817
- }[];
53818
- isError: false;
53819
- error: null;
53820
- isPending: false;
53821
- isLoading: false;
53822
- isLoadingError: false;
53823
- isRefetchError: false;
53824
- isSuccess: true;
53825
- isPlaceholderData: true;
53826
- status: "success";
53827
- dataUpdatedAt: number;
53828
- errorUpdatedAt: number;
53829
- failureCount: number;
53830
- failureReason: Error | null;
53831
- errorUpdateCount: number;
53832
- isFetched: boolean;
53833
- isFetchedAfterMount: boolean;
53834
- isFetching: boolean;
53835
- isInitialLoading: boolean;
53836
- isPaused: boolean;
53837
- isRefetching: boolean;
53838
- isStale: boolean;
53839
- isEnabled: boolean;
53840
- refetch: (options?: _tanstack_query_core0.RefetchOptions) => Promise<_tanstack_query_core0.QueryObserverResult<{
53841
- spendingApproval: bigint;
53842
- operatorAddr: string;
53843
- __typename: "UserMarketOperator";
53844
- id: string;
53845
- canExtend: boolean;
53846
- canExercise: boolean;
53847
- canTransfer: boolean;
53848
- canMint: boolean;
53849
- operator?: {
53850
- __typename: "MarketOperator";
53851
- address: string;
53852
- } | null;
53853
- }[] | undefined, Error>>;
53854
- fetchStatus: _tanstack_query_core0.FetchStatus;
53855
- promise: Promise<{
53856
- spendingApproval: bigint;
53857
- operatorAddr: string;
53858
- __typename: "UserMarketOperator";
53859
- id: string;
53860
- canExtend: boolean;
53861
- canExercise: boolean;
53862
- canTransfer: boolean;
53863
- canMint: boolean;
53864
- operator?: {
53865
- __typename: "MarketOperator";
53866
- address: string;
53867
- } | null;
53868
- }[] | undefined>;
53869
- };
49805
+ declare const useUserOperators: (userAddr?: Address, marketAddr?: Address) => _tanstack_react_query0.UseQueryResult<{
49806
+ spendingApproval: bigint;
49807
+ operatorAddr: string;
49808
+ __typename: "UserMarketOperator";
49809
+ id: string;
49810
+ canExtend: boolean;
49811
+ canExercise: boolean;
49812
+ canTransfer: boolean;
49813
+ canMint: boolean;
49814
+ operator?: {
49815
+ __typename: "MarketOperator";
49816
+ address: string;
49817
+ } | null;
49818
+ }[] | undefined, Error>;
53870
49819
  //#endregion
53871
49820
  //#region src/hooks/operators/useSetOperatorPerms.d.ts
53872
49821
  declare const useSetOperatorPerms: (marketAddr: Address | undefined) => _tanstack_react_query0.UseMutationResult<`0x${string}`, Error, {
@@ -101587,5 +97536,5 @@ declare const useLens: () => {
101587
97536
  } | undefined;
101588
97537
  };
101589
97538
  //#endregion
101590
- export { PriceResolution as $, stateViews as $t, useCurrentPrice as A, formatVagueAmount as At, getPriceAtTick as B, useMarketVolume as Bt, useLiquidityBlocks as C, useMintOption as Ct, usePriceAtSqrtPriceX96 as D, formatAmount as Dt, usePriceHistory as E, EMPTY_ARRAY as Et, getPayoutAtTick as F, wrapAmount as Ft, liquiditiesToAmounts as G, useTimelockConfig as Gt, getTickAtPrice as H, useMarketData as Ht, PRICE_PRECISION as I, wrapAmountUnscaled as It, token0ToToken1AtTick as J, TimelockMarketData as Jt, roundTick as K, TimelockLens as Kt, getAmountsFromLiquidity as L, wrapPrice as Lt, UniswapPoolData as M, scalePrice as Mt, usePoolData as N, unscaleAmount as Nt, usePriceAtTick as O, formatCondensed as Ot, getPayoutAtPrice as P, unscalePrice as Pt, PriceDataPoint as Q, getTimelockMarket as Qt, getNearestValidStrikeTick as R, wrapPriceUnscaled as Rt, LiquidityBlockData as S, useClosedUserOptions as St, useMarketPriceHistory as T, Amount as Tt, liquiditiesToAmount0 as U, TimelockProvider as Ut, getSqrtPriceX96AtPrice as V, useMarketState as Vt, liquiditiesToAmount1 as W, useCurrentMarket as Wt, token1ToToken0AtTick as X, getStateView as Xt, token1ToToken0 as Y, getErc20 as Yt, PriceData as Z, getTimelockLens as Zt, useTokenData as _, useOptionPremium as _t, OptionPricingParams as a, useActiveUserPerps as at, batchGetAmountsFromLiquidity as b, OptionData as bt, usePricingParams as c, usePerpsOperator as ct, usePauseMarketTrading as d, ExerciseOptionEvent as dt, swapRouters as en, getCurrentPrice as et, usePauseGlobalTrading as f, ExtendEvent as ft, TokenData as g, useExtendOption as gt, useTokenBalance as h, useOptionTimeline as ht, useOptionPricingParams as i, useOperatorPerms as it, PoolKey as j, scaleAmount as jt, useCurrentTick as k, formatUSD as kt, useUpdateMarketFees as l, useClosePerp as lt, useApproval as m, OptionEvent as mt, useUpdateMarketPricing as n, timelockFactories as nn, useSetOperatorPerms as nt, PricingParams as o, useClosedUserPerps as ot, useGuardianGlobalState as p, MintOptionEvent as pt, token0ToToken1 as q, TimelockMarket as qt, useStaticPricingParams as r, timelockLenses as rn, useUserOperators as rt, StaticPricingParams as s, useUserPerps as st, useLens as t, swappers as tn, getPriceHistory as tt, useFeeRates as u, useMintPerp as ut, useVaultTVL as v, useOptionPnl as vt, useBurnLiquidity as w, useMaxPositionSize as wt, useMintLiquidity as x, useActiveUserOptions as xt, useVaultData as y, useExerciseOption as yt, getPriceAtSqrtPriceX96 as z, zero as zt };
101591
- //# sourceMappingURL=client-BFfw9ee6.d.cts.map
97539
+ export { PriceResolution as $, swapRouters as $t, useCurrentPrice as A, scaleAmount as At, getPriceAtTick as B, useMarketState as Bt, useLiquidityBlocks as C, useMintOption as Ct, usePriceAtSqrtPriceX96 as D, formatCondensed as Dt, usePriceHistory as E, formatAmount as Et, getPayoutAtTick as F, wrapAmountUnscaled as Ft, liquiditiesToAmounts as G, TimelockLens as Gt, getTickAtPrice as H, TimelockProvider as Ht, PRICE_PRECISION as I, wrapPrice as It, token0ToToken1AtTick as J, getErc20 as Jt, roundTick as K, TimelockMarket as Kt, getAmountsFromLiquidity as L, wrapPriceUnscaled as Lt, UniswapPoolData as M, unscaleAmount as Mt, usePoolData as N, unscalePrice as Nt, usePriceAtTick as O, formatUSD as Ot, getPayoutAtPrice as P, wrapAmount as Pt, PriceDataPoint as Q, stateViews as Qt, getNearestValidStrikeTick as R, zero as Rt, LiquidityBlockData as S, useClosedUserOptions as St, useMarketPriceHistory as T, Amount as Tt, liquiditiesToAmount0 as U, useCurrentMarket as Ut, getSqrtPriceX96AtPrice as V, useMarketData as Vt, liquiditiesToAmount1 as W, useTimelockConfig as Wt, token1ToToken0AtTick as X, getTimelockLens as Xt, token1ToToken0 as Y, getStateView as Yt, PriceData as Z, getTimelockMarket as Zt, useTokenData as _, useOptionPremium as _t, OptionPricingParams as a, useActiveUserPerps as at, batchGetAmountsFromLiquidity as b, OptionData as bt, usePricingParams as c, usePerpsOperator as ct, usePauseMarketTrading as d, ExerciseOptionEvent as dt, swappers as en, getCurrentPrice as et, usePauseGlobalTrading as f, ExtendEvent as ft, TokenData as g, useExtendOption as gt, useTokenBalance as h, useOptionTimeline as ht, useOptionPricingParams as i, useOperatorPerms as it, PoolKey as j, scalePrice as jt, useCurrentTick as k, formatVagueAmount as kt, useUpdateMarketFees as l, useClosePerp as lt, useApproval as m, OptionEvent as mt, useUpdateMarketPricing as n, timelockLenses as nn, useSetOperatorPerms as nt, PricingParams as o, useClosedUserPerps as ot, useGuardianGlobalState as p, MintOptionEvent as pt, token0ToToken1 as q, TimelockMarketData as qt, useStaticPricingParams as r, useUserOperators as rt, StaticPricingParams as s, useUserPerps as st, useLens as t, timelockFactories as tn, getPriceHistory as tt, useFeeRates as u, useMintPerp as ut, useVaultTVL as v, useOptionPnl as vt, useBurnLiquidity as w, useMaxPositionSize as wt, useMintLiquidity as x, useActiveUserOptions as xt, useVaultData as y, useExerciseOption as yt, getPriceAtSqrtPriceX96 as z, useMarketVolume as zt };
97540
+ //# sourceMappingURL=client-8sps6WQZ.d.cts.map