@pythnetwork/hermes-client 1.0.3 → 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 +22 -1
- package/lib/HermesClient.d.ts.map +1 -1
- package/lib/HermesClient.js +27 -3
- package/lib/examples/HermesClient.js +19 -2
- 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;
|
|
@@ -20,11 +21,16 @@ export type HermesClientConfig = {
|
|
|
20
21
|
* it will timeout regardless of the retries at the configured `timeout` time.
|
|
21
22
|
*/
|
|
22
23
|
httpRetries?: number;
|
|
24
|
+
/**
|
|
25
|
+
* Optional headers to be included in every request.
|
|
26
|
+
*/
|
|
27
|
+
headers?: HeadersInit;
|
|
23
28
|
};
|
|
24
29
|
export declare class HermesClient {
|
|
25
30
|
private baseURL;
|
|
26
31
|
private timeout;
|
|
27
32
|
private httpRetries;
|
|
33
|
+
private headers;
|
|
28
34
|
/**
|
|
29
35
|
* Constructs a new Connection.
|
|
30
36
|
*
|
|
@@ -48,6 +54,21 @@ export declare class HermesClient {
|
|
|
48
54
|
query?: string;
|
|
49
55
|
filter?: string;
|
|
50
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>;
|
|
51
72
|
/**
|
|
52
73
|
* Fetch the latest price updates for a set of price feed IDs.
|
|
53
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
|
@@ -13,6 +13,7 @@ class HermesClient {
|
|
|
13
13
|
baseURL;
|
|
14
14
|
timeout;
|
|
15
15
|
httpRetries;
|
|
16
|
+
headers;
|
|
16
17
|
/**
|
|
17
18
|
* Constructs a new Connection.
|
|
18
19
|
*
|
|
@@ -23,12 +24,17 @@ class HermesClient {
|
|
|
23
24
|
this.baseURL = endpoint;
|
|
24
25
|
this.timeout = config?.timeout ?? DEFAULT_TIMEOUT;
|
|
25
26
|
this.httpRetries = config?.httpRetries ?? DEFAULT_HTTP_RETRIES;
|
|
27
|
+
this.headers = config?.headers ?? {};
|
|
26
28
|
}
|
|
27
29
|
async httpRequest(url, schema, options, retries = this.httpRetries, backoff = 100 + Math.floor(Math.random() * 100), // Adding randomness to the initial backoff to avoid "thundering herd" scenario where a lot of clients that get kicked off all at the same time (say some script or something) and fail to connect all retry at exactly the same time too
|
|
28
30
|
externalAbortController) {
|
|
29
31
|
const controller = externalAbortController ?? new AbortController();
|
|
30
32
|
const { signal } = controller;
|
|
31
|
-
options = {
|
|
33
|
+
options = {
|
|
34
|
+
...options,
|
|
35
|
+
signal,
|
|
36
|
+
headers: { ...this.headers, ...options?.headers },
|
|
37
|
+
}; // Merge any existing options with the signal and headers
|
|
32
38
|
// Set a timeout to abort the request if it takes too long
|
|
33
39
|
const timeout = setTimeout(() => controller.abort(), this.timeout);
|
|
34
40
|
try {
|
|
@@ -69,6 +75,24 @@ class HermesClient {
|
|
|
69
75
|
}
|
|
70
76
|
return await this.httpRequest(url.toString(), zodSchemas_1.schemas.PriceFeedMetadata.array());
|
|
71
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
|
+
}
|
|
72
96
|
/**
|
|
73
97
|
* Fetch the latest price updates for a set of price feed IDs.
|
|
74
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.
|
|
@@ -82,7 +106,7 @@ class HermesClient {
|
|
|
82
106
|
* @returns PriceUpdate object containing the latest updates.
|
|
83
107
|
*/
|
|
84
108
|
async getLatestPriceUpdates(ids, options) {
|
|
85
|
-
const url = new URL(
|
|
109
|
+
const url = new URL("v2/updates/price/latest", this.baseURL);
|
|
86
110
|
for (const id of ids) {
|
|
87
111
|
url.searchParams.append("ids[]", id);
|
|
88
112
|
}
|
|
@@ -138,7 +162,7 @@ class HermesClient {
|
|
|
138
162
|
const transformedOptions = (0, utils_1.camelToSnakeCaseObject)(options);
|
|
139
163
|
this.appendUrlSearchParams(url, transformedOptions);
|
|
140
164
|
}
|
|
141
|
-
return new eventsource_1.default(url.toString());
|
|
165
|
+
return new eventsource_1.default(url.toString(), { headers: this.headers });
|
|
142
166
|
}
|
|
143
167
|
appendUrlSearchParams(url, params) {
|
|
144
168
|
Object.entries(params).forEach(([key, value]) => {
|
|
@@ -27,8 +27,25 @@ const argv = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
|
|
|
27
27
|
"parse-numbers": false,
|
|
28
28
|
})
|
|
29
29
|
.parseSync();
|
|
30
|
+
/**
|
|
31
|
+
* Extracts the endpoint and basic authorization headers from a given URL string.
|
|
32
|
+
*
|
|
33
|
+
* @param {string} urlString - The URL string containing the endpoint and optional basic auth credentials.
|
|
34
|
+
* @returns {{ endpoint: string; headers: HeadersInit }} An object containing the endpoint URL and headers.
|
|
35
|
+
*/
|
|
36
|
+
function extractBasicAuthorizationHeadersFromUrl(urlString) {
|
|
37
|
+
const url = new URL(urlString);
|
|
38
|
+
const headers = {};
|
|
39
|
+
if (url.username && url.password) {
|
|
40
|
+
headers["Authorization"] = `Basic ${btoa(`${url.username}:${url.password}`)}`;
|
|
41
|
+
url.username = "";
|
|
42
|
+
url.password = "";
|
|
43
|
+
}
|
|
44
|
+
return { endpoint: url.toString(), headers };
|
|
45
|
+
}
|
|
30
46
|
async function run() {
|
|
31
|
-
const
|
|
47
|
+
const { endpoint, headers } = extractBasicAuthorizationHeadersFromUrl(argv.endpoint);
|
|
48
|
+
const connection = new HermesClient_1.HermesClient(endpoint, { headers });
|
|
32
49
|
const priceIds = argv.priceIds;
|
|
33
50
|
// Get price feeds
|
|
34
51
|
const priceFeeds = await connection.getPriceFeeds({
|
|
@@ -43,7 +60,7 @@ async function run() {
|
|
|
43
60
|
const eventSource = await connection.getPriceUpdatesStream(priceIds, {
|
|
44
61
|
encoding: "hex",
|
|
45
62
|
parsed: true,
|
|
46
|
-
allowUnordered:
|
|
63
|
+
allowUnordered: false,
|
|
47
64
|
benchmarksOnly: true,
|
|
48
65
|
});
|
|
49
66
|
eventSource.onmessage = (event) => {
|
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
|
}
|