@pythnetwork/hermes-client 1.0.4 → 1.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +1 -1
- package/lib/HermesClient.d.ts +17 -1
- package/lib/HermesClient.d.ts.map +1 -1
- package/lib/HermesClient.js +18 -0
- package/lib/examples/HermesClient.js +1 -1
- package/lib/zodSchemas.d.ts +483 -1
- package/lib/zodSchemas.d.ts.map +1 -1
- package/lib/zodSchemas.js +38 -3
- package/package.json +2 -2
package/LICENSE
CHANGED
package/lib/HermesClient.d.ts
CHANGED
|
@@ -2,11 +2,12 @@ import EventSource from "eventsource";
|
|
|
2
2
|
import { schemas } from "./zodSchemas";
|
|
3
3
|
import { z } from "zod";
|
|
4
4
|
export type AssetType = z.infer<typeof schemas.AssetType>;
|
|
5
|
-
export type BinaryPriceUpdate = z.infer<typeof schemas.
|
|
5
|
+
export type BinaryPriceUpdate = z.infer<typeof schemas.BinaryUpdate>;
|
|
6
6
|
export type EncodingType = z.infer<typeof schemas.EncodingType>;
|
|
7
7
|
export type PriceFeedMetadata = z.infer<typeof schemas.PriceFeedMetadata>;
|
|
8
8
|
export type PriceIdInput = z.infer<typeof schemas.PriceIdInput>;
|
|
9
9
|
export type PriceUpdate = z.infer<typeof schemas.PriceUpdate>;
|
|
10
|
+
export type PublisherCaps = z.infer<typeof schemas.LatestPublisherStakeCapsUpdateDataResponse>;
|
|
10
11
|
export type UnixTimestamp = number;
|
|
11
12
|
export type DurationInSeconds = number;
|
|
12
13
|
export type HexString = string;
|
|
@@ -53,6 +54,21 @@ export declare class HermesClient {
|
|
|
53
54
|
query?: string;
|
|
54
55
|
filter?: string;
|
|
55
56
|
}): Promise<PriceFeedMetadata[]>;
|
|
57
|
+
/**
|
|
58
|
+
* Fetch the latest publisher stake caps.
|
|
59
|
+
* This endpoint can be customized by specifying the encoding type and whether the results should also return the parsed publisher caps.
|
|
60
|
+
* This will throw an error if there is a network problem or the price service returns a non-ok response.
|
|
61
|
+
*
|
|
62
|
+
* @param options Optional parameters:
|
|
63
|
+
* - encoding: Encoding type. If specified, return the publisher caps in the encoding specified by the encoding parameter. Default is hex.
|
|
64
|
+
* - parsed: Boolean to specify if the parsed publisher caps should be included in the response. Default is false.
|
|
65
|
+
*
|
|
66
|
+
* @returns PublisherCaps object containing the latest publisher stake caps.
|
|
67
|
+
*/
|
|
68
|
+
getLatestPublisherCaps(options?: {
|
|
69
|
+
encoding?: EncodingType;
|
|
70
|
+
parsed?: boolean;
|
|
71
|
+
}): Promise<PublisherCaps>;
|
|
56
72
|
/**
|
|
57
73
|
* Fetch the latest price updates for a set of price feed IDs.
|
|
58
74
|
* This endpoint can be customized by specifying the encoding type and whether the results should also return the parsed price update using the options object.
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"HermesClient.d.ts","sourceRoot":"","sources":["../src/HermesClient.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,SAAS,CAAC,CAAC;AAC1D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,
|
|
1
|
+
{"version":3,"file":"HermesClient.d.ts","sourceRoot":"","sources":["../src/HermesClient.ts"],"names":[],"mappings":"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"}
|
package/lib/HermesClient.js
CHANGED
|
@@ -75,6 +75,24 @@ class HermesClient {
|
|
|
75
75
|
}
|
|
76
76
|
return await this.httpRequest(url.toString(), zodSchemas_1.schemas.PriceFeedMetadata.array());
|
|
77
77
|
}
|
|
78
|
+
/**
|
|
79
|
+
* Fetch the latest publisher stake caps.
|
|
80
|
+
* This endpoint can be customized by specifying the encoding type and whether the results should also return the parsed publisher caps.
|
|
81
|
+
* This will throw an error if there is a network problem or the price service returns a non-ok response.
|
|
82
|
+
*
|
|
83
|
+
* @param options Optional parameters:
|
|
84
|
+
* - encoding: Encoding type. If specified, return the publisher caps in the encoding specified by the encoding parameter. Default is hex.
|
|
85
|
+
* - parsed: Boolean to specify if the parsed publisher caps should be included in the response. Default is false.
|
|
86
|
+
*
|
|
87
|
+
* @returns PublisherCaps object containing the latest publisher stake caps.
|
|
88
|
+
*/
|
|
89
|
+
async getLatestPublisherCaps(options) {
|
|
90
|
+
const url = new URL("v2/updates/publisher_stake_caps/latest", this.baseURL);
|
|
91
|
+
if (options) {
|
|
92
|
+
this.appendUrlSearchParams(url, options);
|
|
93
|
+
}
|
|
94
|
+
return await this.httpRequest(url.toString(), zodSchemas_1.schemas.LatestPublisherStakeCapsUpdateDataResponse);
|
|
95
|
+
}
|
|
78
96
|
/**
|
|
79
97
|
* Fetch the latest price updates for a set of price feed IDs.
|
|
80
98
|
* This endpoint can be customized by specifying the encoding type and whether the results should also return the parsed price update using the options object.
|
package/lib/zodSchemas.d.ts
CHANGED
|
@@ -16,7 +16,7 @@ export declare const schemas: {
|
|
|
16
16
|
}, z.ZodTypeAny, "passthrough">>;
|
|
17
17
|
PriceIdInput: z.ZodString;
|
|
18
18
|
EncodingType: z.ZodEnum<["hex", "base64"]>;
|
|
19
|
-
|
|
19
|
+
BinaryUpdate: z.ZodObject<{
|
|
20
20
|
data: z.ZodArray<z.ZodString, "many">;
|
|
21
21
|
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
22
22
|
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
@@ -657,6 +657,186 @@ export declare const schemas: {
|
|
|
657
657
|
}, z.ZodTypeAny, "passthrough">>;
|
|
658
658
|
}, z.ZodTypeAny, "passthrough">>, "many">>>;
|
|
659
659
|
}, z.ZodTypeAny, "passthrough">>;
|
|
660
|
+
ParsedPublisherStakeCap: z.ZodObject<{
|
|
661
|
+
cap: z.ZodNumber;
|
|
662
|
+
publisher: z.ZodString;
|
|
663
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
664
|
+
cap: z.ZodNumber;
|
|
665
|
+
publisher: z.ZodString;
|
|
666
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
667
|
+
cap: z.ZodNumber;
|
|
668
|
+
publisher: z.ZodString;
|
|
669
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
670
|
+
ParsedPublisherStakeCapsUpdate: z.ZodObject<{
|
|
671
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
672
|
+
cap: z.ZodNumber;
|
|
673
|
+
publisher: z.ZodString;
|
|
674
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
675
|
+
cap: z.ZodNumber;
|
|
676
|
+
publisher: z.ZodString;
|
|
677
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
678
|
+
cap: z.ZodNumber;
|
|
679
|
+
publisher: z.ZodString;
|
|
680
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
681
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
682
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
683
|
+
cap: z.ZodNumber;
|
|
684
|
+
publisher: z.ZodString;
|
|
685
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
686
|
+
cap: z.ZodNumber;
|
|
687
|
+
publisher: z.ZodString;
|
|
688
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
689
|
+
cap: z.ZodNumber;
|
|
690
|
+
publisher: z.ZodString;
|
|
691
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
692
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
693
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
694
|
+
cap: z.ZodNumber;
|
|
695
|
+
publisher: z.ZodString;
|
|
696
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
697
|
+
cap: z.ZodNumber;
|
|
698
|
+
publisher: z.ZodString;
|
|
699
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
700
|
+
cap: z.ZodNumber;
|
|
701
|
+
publisher: z.ZodString;
|
|
702
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
703
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
704
|
+
LatestPublisherStakeCapsUpdateDataResponse: z.ZodObject<{
|
|
705
|
+
binary: z.ZodObject<{
|
|
706
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
707
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
708
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
709
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
710
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
711
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
712
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
713
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
714
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
715
|
+
parsed: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
|
|
716
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
717
|
+
cap: z.ZodNumber;
|
|
718
|
+
publisher: z.ZodString;
|
|
719
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
720
|
+
cap: z.ZodNumber;
|
|
721
|
+
publisher: z.ZodString;
|
|
722
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
723
|
+
cap: z.ZodNumber;
|
|
724
|
+
publisher: z.ZodString;
|
|
725
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
726
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
727
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
728
|
+
cap: z.ZodNumber;
|
|
729
|
+
publisher: z.ZodString;
|
|
730
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
731
|
+
cap: z.ZodNumber;
|
|
732
|
+
publisher: z.ZodString;
|
|
733
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
734
|
+
cap: z.ZodNumber;
|
|
735
|
+
publisher: z.ZodString;
|
|
736
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
737
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
738
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
739
|
+
cap: z.ZodNumber;
|
|
740
|
+
publisher: z.ZodString;
|
|
741
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
742
|
+
cap: z.ZodNumber;
|
|
743
|
+
publisher: z.ZodString;
|
|
744
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
745
|
+
cap: z.ZodNumber;
|
|
746
|
+
publisher: z.ZodString;
|
|
747
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
748
|
+
}, z.ZodTypeAny, "passthrough">>, "many">>>;
|
|
749
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
750
|
+
binary: z.ZodObject<{
|
|
751
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
752
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
753
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
754
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
755
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
756
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
757
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
758
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
759
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
760
|
+
parsed: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
|
|
761
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
762
|
+
cap: z.ZodNumber;
|
|
763
|
+
publisher: z.ZodString;
|
|
764
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
765
|
+
cap: z.ZodNumber;
|
|
766
|
+
publisher: z.ZodString;
|
|
767
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
768
|
+
cap: z.ZodNumber;
|
|
769
|
+
publisher: z.ZodString;
|
|
770
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
771
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
772
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
773
|
+
cap: z.ZodNumber;
|
|
774
|
+
publisher: z.ZodString;
|
|
775
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
776
|
+
cap: z.ZodNumber;
|
|
777
|
+
publisher: z.ZodString;
|
|
778
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
779
|
+
cap: z.ZodNumber;
|
|
780
|
+
publisher: z.ZodString;
|
|
781
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
782
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
783
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
784
|
+
cap: z.ZodNumber;
|
|
785
|
+
publisher: z.ZodString;
|
|
786
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
787
|
+
cap: z.ZodNumber;
|
|
788
|
+
publisher: z.ZodString;
|
|
789
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
790
|
+
cap: z.ZodNumber;
|
|
791
|
+
publisher: z.ZodString;
|
|
792
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
793
|
+
}, z.ZodTypeAny, "passthrough">>, "many">>>;
|
|
794
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
795
|
+
binary: z.ZodObject<{
|
|
796
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
797
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
798
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
799
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
800
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
801
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
802
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
803
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
804
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
805
|
+
parsed: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
|
|
806
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
807
|
+
cap: z.ZodNumber;
|
|
808
|
+
publisher: z.ZodString;
|
|
809
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
810
|
+
cap: z.ZodNumber;
|
|
811
|
+
publisher: z.ZodString;
|
|
812
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
813
|
+
cap: z.ZodNumber;
|
|
814
|
+
publisher: z.ZodString;
|
|
815
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
816
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
817
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
818
|
+
cap: z.ZodNumber;
|
|
819
|
+
publisher: z.ZodString;
|
|
820
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
821
|
+
cap: z.ZodNumber;
|
|
822
|
+
publisher: z.ZodString;
|
|
823
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
824
|
+
cap: z.ZodNumber;
|
|
825
|
+
publisher: z.ZodString;
|
|
826
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
827
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
828
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
829
|
+
cap: z.ZodNumber;
|
|
830
|
+
publisher: z.ZodString;
|
|
831
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
832
|
+
cap: z.ZodNumber;
|
|
833
|
+
publisher: z.ZodString;
|
|
834
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
835
|
+
cap: z.ZodNumber;
|
|
836
|
+
publisher: z.ZodString;
|
|
837
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
838
|
+
}, z.ZodTypeAny, "passthrough">>, "many">>>;
|
|
839
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
660
840
|
};
|
|
661
841
|
export declare const api: import("@zodios/core").ZodiosInstance<[{
|
|
662
842
|
method: "get";
|
|
@@ -2147,6 +2327,157 @@ export declare const api: import("@zodios/core").ZodiosInstance<[{
|
|
|
2147
2327
|
description: string;
|
|
2148
2328
|
schema: z.ZodVoid;
|
|
2149
2329
|
}];
|
|
2330
|
+
}, {
|
|
2331
|
+
method: "get";
|
|
2332
|
+
path: "/v2/updates/publisher_stake_caps/latest";
|
|
2333
|
+
alias: "latest_publisher_stake_caps";
|
|
2334
|
+
description: "Get the most recent publisher stake caps update data.";
|
|
2335
|
+
requestFormat: "json";
|
|
2336
|
+
parameters: [{
|
|
2337
|
+
name: "encoding";
|
|
2338
|
+
type: "Query";
|
|
2339
|
+
schema: z.ZodOptional<z.ZodEnum<["hex", "base64"]>>;
|
|
2340
|
+
}, {
|
|
2341
|
+
name: "parsed";
|
|
2342
|
+
type: "Query";
|
|
2343
|
+
schema: z.ZodOptional<z.ZodBoolean>;
|
|
2344
|
+
}];
|
|
2345
|
+
response: z.ZodObject<{
|
|
2346
|
+
binary: z.ZodObject<{
|
|
2347
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
2348
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
2349
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2350
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
2351
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
2352
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2353
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
2354
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
2355
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
2356
|
+
parsed: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
|
|
2357
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
2358
|
+
cap: z.ZodNumber;
|
|
2359
|
+
publisher: z.ZodString;
|
|
2360
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2361
|
+
cap: z.ZodNumber;
|
|
2362
|
+
publisher: z.ZodString;
|
|
2363
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2364
|
+
cap: z.ZodNumber;
|
|
2365
|
+
publisher: z.ZodString;
|
|
2366
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
2367
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2368
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
2369
|
+
cap: z.ZodNumber;
|
|
2370
|
+
publisher: z.ZodString;
|
|
2371
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2372
|
+
cap: z.ZodNumber;
|
|
2373
|
+
publisher: z.ZodString;
|
|
2374
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2375
|
+
cap: z.ZodNumber;
|
|
2376
|
+
publisher: z.ZodString;
|
|
2377
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
2378
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2379
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
2380
|
+
cap: z.ZodNumber;
|
|
2381
|
+
publisher: z.ZodString;
|
|
2382
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2383
|
+
cap: z.ZodNumber;
|
|
2384
|
+
publisher: z.ZodString;
|
|
2385
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2386
|
+
cap: z.ZodNumber;
|
|
2387
|
+
publisher: z.ZodString;
|
|
2388
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
2389
|
+
}, z.ZodTypeAny, "passthrough">>, "many">>>;
|
|
2390
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2391
|
+
binary: z.ZodObject<{
|
|
2392
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
2393
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
2394
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2395
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
2396
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
2397
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2398
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
2399
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
2400
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
2401
|
+
parsed: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
|
|
2402
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
2403
|
+
cap: z.ZodNumber;
|
|
2404
|
+
publisher: z.ZodString;
|
|
2405
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2406
|
+
cap: z.ZodNumber;
|
|
2407
|
+
publisher: z.ZodString;
|
|
2408
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2409
|
+
cap: z.ZodNumber;
|
|
2410
|
+
publisher: z.ZodString;
|
|
2411
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
2412
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2413
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
2414
|
+
cap: z.ZodNumber;
|
|
2415
|
+
publisher: z.ZodString;
|
|
2416
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2417
|
+
cap: z.ZodNumber;
|
|
2418
|
+
publisher: z.ZodString;
|
|
2419
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2420
|
+
cap: z.ZodNumber;
|
|
2421
|
+
publisher: z.ZodString;
|
|
2422
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
2423
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2424
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
2425
|
+
cap: z.ZodNumber;
|
|
2426
|
+
publisher: z.ZodString;
|
|
2427
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2428
|
+
cap: z.ZodNumber;
|
|
2429
|
+
publisher: z.ZodString;
|
|
2430
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2431
|
+
cap: z.ZodNumber;
|
|
2432
|
+
publisher: z.ZodString;
|
|
2433
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
2434
|
+
}, z.ZodTypeAny, "passthrough">>, "many">>>;
|
|
2435
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2436
|
+
binary: z.ZodObject<{
|
|
2437
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
2438
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
2439
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2440
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
2441
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
2442
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2443
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
2444
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
2445
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
2446
|
+
parsed: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
|
|
2447
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
2448
|
+
cap: z.ZodNumber;
|
|
2449
|
+
publisher: z.ZodString;
|
|
2450
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2451
|
+
cap: z.ZodNumber;
|
|
2452
|
+
publisher: z.ZodString;
|
|
2453
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2454
|
+
cap: z.ZodNumber;
|
|
2455
|
+
publisher: z.ZodString;
|
|
2456
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
2457
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2458
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
2459
|
+
cap: z.ZodNumber;
|
|
2460
|
+
publisher: z.ZodString;
|
|
2461
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2462
|
+
cap: z.ZodNumber;
|
|
2463
|
+
publisher: z.ZodString;
|
|
2464
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2465
|
+
cap: z.ZodNumber;
|
|
2466
|
+
publisher: z.ZodString;
|
|
2467
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
2468
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2469
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
2470
|
+
cap: z.ZodNumber;
|
|
2471
|
+
publisher: z.ZodString;
|
|
2472
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
2473
|
+
cap: z.ZodNumber;
|
|
2474
|
+
publisher: z.ZodString;
|
|
2475
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
2476
|
+
cap: z.ZodNumber;
|
|
2477
|
+
publisher: z.ZodString;
|
|
2478
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
2479
|
+
}, z.ZodTypeAny, "passthrough">>, "many">>>;
|
|
2480
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
2150
2481
|
}]>;
|
|
2151
2482
|
export declare function createApiClient(baseUrl: string, options?: ZodiosOptions): import("@zodios/core").ZodiosInstance<[{
|
|
2152
2483
|
method: "get";
|
|
@@ -3637,5 +3968,156 @@ export declare function createApiClient(baseUrl: string, options?: ZodiosOptions
|
|
|
3637
3968
|
description: string;
|
|
3638
3969
|
schema: z.ZodVoid;
|
|
3639
3970
|
}];
|
|
3971
|
+
}, {
|
|
3972
|
+
method: "get";
|
|
3973
|
+
path: "/v2/updates/publisher_stake_caps/latest";
|
|
3974
|
+
alias: "latest_publisher_stake_caps";
|
|
3975
|
+
description: "Get the most recent publisher stake caps update data.";
|
|
3976
|
+
requestFormat: "json";
|
|
3977
|
+
parameters: [{
|
|
3978
|
+
name: "encoding";
|
|
3979
|
+
type: "Query";
|
|
3980
|
+
schema: z.ZodOptional<z.ZodEnum<["hex", "base64"]>>;
|
|
3981
|
+
}, {
|
|
3982
|
+
name: "parsed";
|
|
3983
|
+
type: "Query";
|
|
3984
|
+
schema: z.ZodOptional<z.ZodBoolean>;
|
|
3985
|
+
}];
|
|
3986
|
+
response: z.ZodObject<{
|
|
3987
|
+
binary: z.ZodObject<{
|
|
3988
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
3989
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
3990
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
3991
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
3992
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
3993
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
3994
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
3995
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
3996
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
3997
|
+
parsed: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
|
|
3998
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
3999
|
+
cap: z.ZodNumber;
|
|
4000
|
+
publisher: z.ZodString;
|
|
4001
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4002
|
+
cap: z.ZodNumber;
|
|
4003
|
+
publisher: z.ZodString;
|
|
4004
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4005
|
+
cap: z.ZodNumber;
|
|
4006
|
+
publisher: z.ZodString;
|
|
4007
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
4008
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4009
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
4010
|
+
cap: z.ZodNumber;
|
|
4011
|
+
publisher: z.ZodString;
|
|
4012
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4013
|
+
cap: z.ZodNumber;
|
|
4014
|
+
publisher: z.ZodString;
|
|
4015
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4016
|
+
cap: z.ZodNumber;
|
|
4017
|
+
publisher: z.ZodString;
|
|
4018
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
4019
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4020
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
4021
|
+
cap: z.ZodNumber;
|
|
4022
|
+
publisher: z.ZodString;
|
|
4023
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4024
|
+
cap: z.ZodNumber;
|
|
4025
|
+
publisher: z.ZodString;
|
|
4026
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4027
|
+
cap: z.ZodNumber;
|
|
4028
|
+
publisher: z.ZodString;
|
|
4029
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
4030
|
+
}, z.ZodTypeAny, "passthrough">>, "many">>>;
|
|
4031
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4032
|
+
binary: z.ZodObject<{
|
|
4033
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
4034
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
4035
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4036
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
4037
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
4038
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4039
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
4040
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
4041
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
4042
|
+
parsed: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
|
|
4043
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
4044
|
+
cap: z.ZodNumber;
|
|
4045
|
+
publisher: z.ZodString;
|
|
4046
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4047
|
+
cap: z.ZodNumber;
|
|
4048
|
+
publisher: z.ZodString;
|
|
4049
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4050
|
+
cap: z.ZodNumber;
|
|
4051
|
+
publisher: z.ZodString;
|
|
4052
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
4053
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4054
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
4055
|
+
cap: z.ZodNumber;
|
|
4056
|
+
publisher: z.ZodString;
|
|
4057
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4058
|
+
cap: z.ZodNumber;
|
|
4059
|
+
publisher: z.ZodString;
|
|
4060
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4061
|
+
cap: z.ZodNumber;
|
|
4062
|
+
publisher: z.ZodString;
|
|
4063
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
4064
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4065
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
4066
|
+
cap: z.ZodNumber;
|
|
4067
|
+
publisher: z.ZodString;
|
|
4068
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4069
|
+
cap: z.ZodNumber;
|
|
4070
|
+
publisher: z.ZodString;
|
|
4071
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4072
|
+
cap: z.ZodNumber;
|
|
4073
|
+
publisher: z.ZodString;
|
|
4074
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
4075
|
+
}, z.ZodTypeAny, "passthrough">>, "many">>>;
|
|
4076
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4077
|
+
binary: z.ZodObject<{
|
|
4078
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
4079
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
4080
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4081
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
4082
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
4083
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4084
|
+
data: z.ZodArray<z.ZodString, "many">;
|
|
4085
|
+
encoding: z.ZodEnum<["hex", "base64"]>;
|
|
4086
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
4087
|
+
parsed: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
|
|
4088
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
4089
|
+
cap: z.ZodNumber;
|
|
4090
|
+
publisher: z.ZodString;
|
|
4091
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4092
|
+
cap: z.ZodNumber;
|
|
4093
|
+
publisher: z.ZodString;
|
|
4094
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4095
|
+
cap: z.ZodNumber;
|
|
4096
|
+
publisher: z.ZodString;
|
|
4097
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
4098
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4099
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
4100
|
+
cap: z.ZodNumber;
|
|
4101
|
+
publisher: z.ZodString;
|
|
4102
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4103
|
+
cap: z.ZodNumber;
|
|
4104
|
+
publisher: z.ZodString;
|
|
4105
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4106
|
+
cap: z.ZodNumber;
|
|
4107
|
+
publisher: z.ZodString;
|
|
4108
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
4109
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4110
|
+
publisher_stake_caps: z.ZodArray<z.ZodObject<{
|
|
4111
|
+
cap: z.ZodNumber;
|
|
4112
|
+
publisher: z.ZodString;
|
|
4113
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
4114
|
+
cap: z.ZodNumber;
|
|
4115
|
+
publisher: z.ZodString;
|
|
4116
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
4117
|
+
cap: z.ZodNumber;
|
|
4118
|
+
publisher: z.ZodString;
|
|
4119
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
4120
|
+
}, z.ZodTypeAny, "passthrough">>, "many">>>;
|
|
4121
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
3640
4122
|
}]>;
|
|
3641
4123
|
//# sourceMappingURL=zodSchemas.d.ts.map
|
package/lib/zodSchemas.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"zodSchemas.d.ts","sourceRoot":"","sources":["../src/zodSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;
|
|
1
|
+
{"version":3,"file":"zodSchemas.d.ts","sourceRoot":"","sources":["../src/zodSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwDxB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAenB,CAAC;AAmKF,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAwB,CAAC;AAEzC,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEvE"}
|
package/lib/zodSchemas.js
CHANGED
|
@@ -11,7 +11,7 @@ const PriceFeedMetadata = zod_1.z
|
|
|
11
11
|
.passthrough();
|
|
12
12
|
const PriceIdInput = zod_1.z.string();
|
|
13
13
|
const EncodingType = zod_1.z.enum(["hex", "base64"]);
|
|
14
|
-
const
|
|
14
|
+
const BinaryUpdate = zod_1.z
|
|
15
15
|
.object({ data: zod_1.z.array(zod_1.z.string()), encoding: EncodingType })
|
|
16
16
|
.passthrough();
|
|
17
17
|
const RpcPrice = zod_1.z
|
|
@@ -40,10 +40,22 @@ const ParsedPriceUpdate = zod_1.z
|
|
|
40
40
|
.passthrough();
|
|
41
41
|
const PriceUpdate = zod_1.z
|
|
42
42
|
.object({
|
|
43
|
-
binary:
|
|
43
|
+
binary: BinaryUpdate,
|
|
44
44
|
parsed: zod_1.z.array(ParsedPriceUpdate).nullish(),
|
|
45
45
|
})
|
|
46
46
|
.passthrough();
|
|
47
|
+
const ParsedPublisherStakeCap = zod_1.z
|
|
48
|
+
.object({ cap: zod_1.z.number().int().gte(0), publisher: zod_1.z.string() })
|
|
49
|
+
.passthrough();
|
|
50
|
+
const ParsedPublisherStakeCapsUpdate = zod_1.z
|
|
51
|
+
.object({ publisher_stake_caps: zod_1.z.array(ParsedPublisherStakeCap) })
|
|
52
|
+
.passthrough();
|
|
53
|
+
const LatestPublisherStakeCapsUpdateDataResponse = zod_1.z
|
|
54
|
+
.object({
|
|
55
|
+
binary: BinaryUpdate,
|
|
56
|
+
parsed: zod_1.z.array(ParsedPublisherStakeCapsUpdate).nullish(),
|
|
57
|
+
})
|
|
58
|
+
.passthrough();
|
|
47
59
|
exports.schemas = {
|
|
48
60
|
AssetType,
|
|
49
61
|
asset_type,
|
|
@@ -51,11 +63,14 @@ exports.schemas = {
|
|
|
51
63
|
PriceFeedMetadata,
|
|
52
64
|
PriceIdInput,
|
|
53
65
|
EncodingType,
|
|
54
|
-
|
|
66
|
+
BinaryUpdate,
|
|
55
67
|
RpcPrice,
|
|
56
68
|
RpcPriceFeedMetadataV2,
|
|
57
69
|
ParsedPriceUpdate,
|
|
58
70
|
PriceUpdate,
|
|
71
|
+
ParsedPublisherStakeCap,
|
|
72
|
+
ParsedPublisherStakeCapsUpdate,
|
|
73
|
+
LatestPublisherStakeCapsUpdateDataResponse,
|
|
59
74
|
};
|
|
60
75
|
const endpoints = (0, core_1.makeApi)([
|
|
61
76
|
{
|
|
@@ -196,6 +211,26 @@ Given a collection of price feed ids, retrieve the latest Pyth price for each pr
|
|
|
196
211
|
},
|
|
197
212
|
],
|
|
198
213
|
},
|
|
214
|
+
{
|
|
215
|
+
method: "get",
|
|
216
|
+
path: "/v2/updates/publisher_stake_caps/latest",
|
|
217
|
+
alias: "latest_publisher_stake_caps",
|
|
218
|
+
description: `Get the most recent publisher stake caps update data.`,
|
|
219
|
+
requestFormat: "json",
|
|
220
|
+
parameters: [
|
|
221
|
+
{
|
|
222
|
+
name: "encoding",
|
|
223
|
+
type: "Query",
|
|
224
|
+
schema: zod_1.z.enum(["hex", "base64"]).optional(),
|
|
225
|
+
},
|
|
226
|
+
{
|
|
227
|
+
name: "parsed",
|
|
228
|
+
type: "Query",
|
|
229
|
+
schema: zod_1.z.boolean().optional(),
|
|
230
|
+
},
|
|
231
|
+
],
|
|
232
|
+
response: LatestPublisherStakeCapsUpdateDataResponse,
|
|
233
|
+
},
|
|
199
234
|
]);
|
|
200
235
|
exports.api = new core_1.Zodios(endpoints);
|
|
201
236
|
function createApiClient(baseUrl, options) {
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@pythnetwork/hermes-client",
|
|
3
|
-
"version": "1.0
|
|
3
|
+
"version": "1.1.0",
|
|
4
4
|
"description": "Pyth Hermes Client",
|
|
5
5
|
"author": {
|
|
6
6
|
"name": "Pyth Data Association"
|
|
@@ -57,5 +57,5 @@
|
|
|
57
57
|
"eventsource": "^2.0.2",
|
|
58
58
|
"zod": "^3.23.8"
|
|
59
59
|
},
|
|
60
|
-
"gitHead": "
|
|
60
|
+
"gitHead": "525ad190de4dfcc1e95502ec056ad446fa6041f5"
|
|
61
61
|
}
|