@ensnode/ensnode-sdk 1.13.1 → 1.15.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.cjs +70 -12
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +36 -1257
- package/dist/index.d.ts +36 -1257
- package/dist/index.js +70 -12
- package/dist/index.js.map +1 -1
- package/dist/internal.cjs +3409 -0
- package/dist/internal.cjs.map +1 -0
- package/dist/internal.d.cts +4198 -0
- package/dist/internal.d.ts +4198 -0
- package/dist/internal.js +3410 -0
- package/dist/internal.js.map +1 -0
- package/dist/namespace-specific-value-CPvcFpGI.d.cts +1260 -0
- package/dist/namespace-specific-value-CPvcFpGI.d.ts +1260 -0
- package/package.json +16 -6
|
@@ -0,0 +1,4198 @@
|
|
|
1
|
+
import { a as EnsIndexerPublicConfig, r as CurrencyId, i as PriceEth, I as RegistrarActionPricingAvailable, J as RegistrarActionPricingUnknown, p as SerializedPriceEth, N as NamespaceSpecificValue, T as TheGraphFallback, g as PriceDai, h as PriceEnsTokens, j as PriceUsdc } from './namespace-specific-value-CPvcFpGI.cjs';
|
|
2
|
+
export { a4 as TheGraphCannotFallbackReason, a5 as TheGraphCannotFallbackReasonSchema, a6 as TheGraphFallbackSchema, ad as interpretAddress, ae as interpretAddressRecordValue, af as interpretContenthashValue, ag as interpretDnszonehashValue, ah as interpretNameRecordValue, ai as interpretPubkeyValue, aj as interpretTextRecordKey, ak as interpretTextRecordValue, ap as makeENSApiPublicConfigSchema, aq as makeEnsApiPublicConfigSchema, m as makeErrorResponseSchema, ar as makeSerializedEnsApiPublicConfigSchema } from './namespace-specific-value-CPvcFpGI.cjs';
|
|
3
|
+
import { z } from 'zod/v4';
|
|
4
|
+
import * as enssdk from 'enssdk';
|
|
5
|
+
import { InterpretedName, InterfaceId, Address, ChainId, ChainIdString, AccountId, DomainId, RegistryId } from 'enssdk';
|
|
6
|
+
import { ENSNamespaceId, Datasource, ContractConfig } from '@ensnode/datasources';
|
|
7
|
+
import 'viem';
|
|
8
|
+
|
|
9
|
+
/**
|
|
10
|
+
* Zod `.check()` function input.
|
|
11
|
+
*/
|
|
12
|
+
type ZodCheckFnInput<T> = z.core.ParsePayload<T>;
|
|
13
|
+
|
|
14
|
+
/**
|
|
15
|
+
* All zod schemas we define must remain internal implementation details.
|
|
16
|
+
* We want the freedom to move away from zod in the future without impacting
|
|
17
|
+
* any users of the ensnode-sdk package.
|
|
18
|
+
*
|
|
19
|
+
* The only way to share Zod schemas is to re-export them from
|
|
20
|
+
* `./src/internal.ts` file.
|
|
21
|
+
*/
|
|
22
|
+
|
|
23
|
+
/**
|
|
24
|
+
* Makes a schema for parsing {@link IndexedChainIds}.
|
|
25
|
+
*/
|
|
26
|
+
declare const makeIndexedChainIdsSchema: (valueLabel?: string) => z.ZodSet<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
27
|
+
declare const makeSerializedIndexedChainIdsSchema: (valueLabel?: string) => z.ZodArray<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
28
|
+
/**
|
|
29
|
+
* Makes a schema for parsing a list of strings that (for future-proofing)
|
|
30
|
+
* may or may not be current {@link PluginName} values.
|
|
31
|
+
*
|
|
32
|
+
* The list is guaranteed to include at least one string and no duplicates.
|
|
33
|
+
*/
|
|
34
|
+
declare const makePluginsListSchema: (valueLabel?: string) => z.ZodArray<z.ZodString>;
|
|
35
|
+
/**
|
|
36
|
+
* Makes a schema for parsing a name for a database schema.
|
|
37
|
+
*
|
|
38
|
+
* The name is guaranteed to be a non-empty string.
|
|
39
|
+
*/
|
|
40
|
+
declare const makeEnsIndexerSchemaNameSchema: (valueLabel?: string) => z.ZodString;
|
|
41
|
+
/**
|
|
42
|
+
* Makes a schema for parsing a label set where both label set ID and label set version are required.
|
|
43
|
+
*
|
|
44
|
+
* @param valueLabel - The label to use in error messages (e.g., "Label set", "LABEL_SET")
|
|
45
|
+
*/
|
|
46
|
+
declare const makeFullyPinnedLabelSetSchema: (valueLabel?: string) => z.ZodObject<{
|
|
47
|
+
labelSetId: z.ZodString;
|
|
48
|
+
labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
|
|
49
|
+
}, z.core.$strip>;
|
|
50
|
+
declare const makeEnsIndexerVersionInfoSchema: (valueLabel?: string) => z.ZodObject<{
|
|
51
|
+
ponder: z.ZodString;
|
|
52
|
+
ensDb: z.ZodString;
|
|
53
|
+
ensIndexer: z.ZodString;
|
|
54
|
+
ensNormalize: z.ZodString;
|
|
55
|
+
}, z.core.$strip>;
|
|
56
|
+
/**
|
|
57
|
+
* @deprecated Use {@link makeEnsIndexerVersionInfoSchema} instead.
|
|
58
|
+
*/
|
|
59
|
+
declare const makeENSIndexerVersionInfoSchema: (valueLabel?: string) => z.ZodObject<{
|
|
60
|
+
ponder: z.ZodString;
|
|
61
|
+
ensDb: z.ZodString;
|
|
62
|
+
ensIndexer: z.ZodString;
|
|
63
|
+
ensNormalize: z.ZodString;
|
|
64
|
+
}, z.core.$strip>;
|
|
65
|
+
declare function invariant_isSubgraphCompatibleRequirements(ctx: ZodCheckFnInput<Pick<EnsIndexerPublicConfig, "namespace" | "plugins" | "isSubgraphCompatible" | "clientLabelSet">>): void;
|
|
66
|
+
declare function invariant_ensRainbowSupportedLabelSetAndVersion(ctx: ZodCheckFnInput<Pick<EnsIndexerPublicConfig, "clientLabelSet" | "ensRainbowPublicConfig">>): void;
|
|
67
|
+
/**
|
|
68
|
+
* ENSIndexer Public Config Schema
|
|
69
|
+
*
|
|
70
|
+
* Makes a Zod schema definition for validating all important settings used
|
|
71
|
+
* during runtime of the ENSIndexer instance.
|
|
72
|
+
*/
|
|
73
|
+
declare const makeEnsIndexerPublicConfigSchema: (valueLabel?: string) => z.ZodObject<{
|
|
74
|
+
ensIndexerSchemaName: z.ZodString;
|
|
75
|
+
ensRainbowPublicConfig: z.ZodObject<{
|
|
76
|
+
serverLabelSet: z.ZodObject<{
|
|
77
|
+
labelSetId: z.ZodString;
|
|
78
|
+
highestLabelSetVersion: z.ZodInt;
|
|
79
|
+
}, z.core.$strip>;
|
|
80
|
+
versionInfo: z.ZodObject<{
|
|
81
|
+
ensRainbow: z.ZodString;
|
|
82
|
+
}, z.core.$strip>;
|
|
83
|
+
}, z.core.$strip>;
|
|
84
|
+
indexedChainIds: z.ZodSet<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
85
|
+
isSubgraphCompatible: z.ZodBoolean;
|
|
86
|
+
clientLabelSet: z.ZodObject<{
|
|
87
|
+
labelSetId: z.ZodString;
|
|
88
|
+
labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
|
|
89
|
+
}, z.core.$strip>;
|
|
90
|
+
namespace: z.ZodEnum<{
|
|
91
|
+
readonly Mainnet: "mainnet";
|
|
92
|
+
readonly Sepolia: "sepolia";
|
|
93
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
94
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
95
|
+
}>;
|
|
96
|
+
plugins: z.ZodArray<z.ZodString>;
|
|
97
|
+
versionInfo: z.ZodObject<{
|
|
98
|
+
ponder: z.ZodString;
|
|
99
|
+
ensDb: z.ZodString;
|
|
100
|
+
ensIndexer: z.ZodString;
|
|
101
|
+
ensNormalize: z.ZodString;
|
|
102
|
+
}, z.core.$strip>;
|
|
103
|
+
}, z.core.$strip>;
|
|
104
|
+
/**
|
|
105
|
+
* ENSIndexer Public Config Schema
|
|
106
|
+
*
|
|
107
|
+
* @deprecated Use {@link makeEnsIndexerPublicConfigSchema} instead.
|
|
108
|
+
*/
|
|
109
|
+
declare const makeENSIndexerPublicConfigSchema: (valueLabel?: string) => z.ZodObject<{
|
|
110
|
+
ensIndexerSchemaName: z.ZodString;
|
|
111
|
+
ensRainbowPublicConfig: z.ZodObject<{
|
|
112
|
+
serverLabelSet: z.ZodObject<{
|
|
113
|
+
labelSetId: z.ZodString;
|
|
114
|
+
highestLabelSetVersion: z.ZodInt;
|
|
115
|
+
}, z.core.$strip>;
|
|
116
|
+
versionInfo: z.ZodObject<{
|
|
117
|
+
ensRainbow: z.ZodString;
|
|
118
|
+
}, z.core.$strip>;
|
|
119
|
+
}, z.core.$strip>;
|
|
120
|
+
indexedChainIds: z.ZodSet<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
121
|
+
isSubgraphCompatible: z.ZodBoolean;
|
|
122
|
+
clientLabelSet: z.ZodObject<{
|
|
123
|
+
labelSetId: z.ZodString;
|
|
124
|
+
labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
|
|
125
|
+
}, z.core.$strip>;
|
|
126
|
+
namespace: z.ZodEnum<{
|
|
127
|
+
readonly Mainnet: "mainnet";
|
|
128
|
+
readonly Sepolia: "sepolia";
|
|
129
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
130
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
131
|
+
}>;
|
|
132
|
+
plugins: z.ZodArray<z.ZodString>;
|
|
133
|
+
versionInfo: z.ZodObject<{
|
|
134
|
+
ponder: z.ZodString;
|
|
135
|
+
ensDb: z.ZodString;
|
|
136
|
+
ensIndexer: z.ZodString;
|
|
137
|
+
ensNormalize: z.ZodString;
|
|
138
|
+
}, z.core.$strip>;
|
|
139
|
+
}, z.core.$strip>;
|
|
140
|
+
declare const makeSerializedEnsIndexerPublicConfigSchema: (valueLabel?: string) => z.ZodObject<{
|
|
141
|
+
ensIndexerSchemaName: z.ZodString;
|
|
142
|
+
ensRainbowPublicConfig: z.ZodObject<{
|
|
143
|
+
serverLabelSet: z.ZodObject<{
|
|
144
|
+
labelSetId: z.ZodString;
|
|
145
|
+
highestLabelSetVersion: z.ZodInt;
|
|
146
|
+
}, z.core.$strip>;
|
|
147
|
+
versionInfo: z.ZodObject<{
|
|
148
|
+
ensRainbow: z.ZodString;
|
|
149
|
+
}, z.core.$strip>;
|
|
150
|
+
}, z.core.$strip>;
|
|
151
|
+
indexedChainIds: z.ZodArray<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
152
|
+
isSubgraphCompatible: z.ZodBoolean;
|
|
153
|
+
clientLabelSet: z.ZodObject<{
|
|
154
|
+
labelSetId: z.ZodString;
|
|
155
|
+
labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
|
|
156
|
+
}, z.core.$strip>;
|
|
157
|
+
namespace: z.ZodEnum<{
|
|
158
|
+
readonly Mainnet: "mainnet";
|
|
159
|
+
readonly Sepolia: "sepolia";
|
|
160
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
161
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
162
|
+
}>;
|
|
163
|
+
plugins: z.ZodArray<z.ZodString>;
|
|
164
|
+
versionInfo: z.ZodObject<{
|
|
165
|
+
ponder: z.ZodString;
|
|
166
|
+
ensDb: z.ZodString;
|
|
167
|
+
ensIndexer: z.ZodString;
|
|
168
|
+
ensNormalize: z.ZodString;
|
|
169
|
+
}, z.core.$strip>;
|
|
170
|
+
}, z.core.$strip>;
|
|
171
|
+
|
|
172
|
+
/**
|
|
173
|
+
* Schema for {@link EnsApiIndexingStatusResponseOk}
|
|
174
|
+
**/
|
|
175
|
+
declare const makeEnsApiIndexingStatusResponseOkSchema: (valueLabel?: string) => z.ZodObject<{
|
|
176
|
+
responseCode: z.ZodLiteral<"ok">;
|
|
177
|
+
realtimeProjection: z.ZodObject<{
|
|
178
|
+
projectedAt: z.ZodInt;
|
|
179
|
+
worstCaseDistance: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
180
|
+
snapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
181
|
+
strategy: z.ZodLiteral<"omnichain">;
|
|
182
|
+
slowestChainIndexingCursor: z.ZodInt;
|
|
183
|
+
snapshotTime: z.ZodInt;
|
|
184
|
+
omnichainSnapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
185
|
+
omnichainStatus: z.ZodLiteral<"omnichain-unstarted">;
|
|
186
|
+
chains: z.ZodMap<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
187
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
188
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
189
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
190
|
+
startBlock: z.ZodObject<{
|
|
191
|
+
timestamp: z.ZodInt;
|
|
192
|
+
number: z.ZodInt;
|
|
193
|
+
}, z.core.$strict>;
|
|
194
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
195
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
196
|
+
startBlock: z.ZodObject<{
|
|
197
|
+
timestamp: z.ZodInt;
|
|
198
|
+
number: z.ZodInt;
|
|
199
|
+
}, z.core.$strict>;
|
|
200
|
+
endBlock: z.ZodObject<{
|
|
201
|
+
timestamp: z.ZodInt;
|
|
202
|
+
number: z.ZodInt;
|
|
203
|
+
}, z.core.$strict>;
|
|
204
|
+
}, z.core.$strip>], "rangeType">;
|
|
205
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
206
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
207
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
208
|
+
omnichainStatus: z.ZodLiteral<"omnichain-backfill">;
|
|
209
|
+
chains: z.ZodMap<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
210
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
211
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
212
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
213
|
+
startBlock: z.ZodObject<{
|
|
214
|
+
timestamp: z.ZodInt;
|
|
215
|
+
number: z.ZodInt;
|
|
216
|
+
}, z.core.$strict>;
|
|
217
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
218
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
219
|
+
startBlock: z.ZodObject<{
|
|
220
|
+
timestamp: z.ZodInt;
|
|
221
|
+
number: z.ZodInt;
|
|
222
|
+
}, z.core.$strict>;
|
|
223
|
+
endBlock: z.ZodObject<{
|
|
224
|
+
timestamp: z.ZodInt;
|
|
225
|
+
number: z.ZodInt;
|
|
226
|
+
}, z.core.$strict>;
|
|
227
|
+
}, z.core.$strip>], "rangeType">;
|
|
228
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
229
|
+
chainStatus: z.ZodLiteral<"chain-backfill">;
|
|
230
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
231
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
232
|
+
startBlock: z.ZodObject<{
|
|
233
|
+
timestamp: z.ZodInt;
|
|
234
|
+
number: z.ZodInt;
|
|
235
|
+
}, z.core.$strict>;
|
|
236
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
237
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
238
|
+
startBlock: z.ZodObject<{
|
|
239
|
+
timestamp: z.ZodInt;
|
|
240
|
+
number: z.ZodInt;
|
|
241
|
+
}, z.core.$strict>;
|
|
242
|
+
endBlock: z.ZodObject<{
|
|
243
|
+
timestamp: z.ZodInt;
|
|
244
|
+
number: z.ZodInt;
|
|
245
|
+
}, z.core.$strict>;
|
|
246
|
+
}, z.core.$strip>], "rangeType">;
|
|
247
|
+
latestIndexedBlock: z.ZodObject<{
|
|
248
|
+
timestamp: z.ZodInt;
|
|
249
|
+
number: z.ZodInt;
|
|
250
|
+
}, z.core.$strict>;
|
|
251
|
+
backfillEndBlock: z.ZodObject<{
|
|
252
|
+
timestamp: z.ZodInt;
|
|
253
|
+
number: z.ZodInt;
|
|
254
|
+
}, z.core.$strict>;
|
|
255
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
256
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
257
|
+
config: z.ZodObject<{
|
|
258
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
259
|
+
startBlock: z.ZodObject<{
|
|
260
|
+
timestamp: z.ZodInt;
|
|
261
|
+
number: z.ZodInt;
|
|
262
|
+
}, z.core.$strict>;
|
|
263
|
+
endBlock: z.ZodObject<{
|
|
264
|
+
timestamp: z.ZodInt;
|
|
265
|
+
number: z.ZodInt;
|
|
266
|
+
}, z.core.$strict>;
|
|
267
|
+
}, z.core.$strip>;
|
|
268
|
+
latestIndexedBlock: z.ZodObject<{
|
|
269
|
+
timestamp: z.ZodInt;
|
|
270
|
+
number: z.ZodInt;
|
|
271
|
+
}, z.core.$strict>;
|
|
272
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
273
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
274
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
275
|
+
omnichainStatus: z.ZodLiteral<"omnichain-completed">;
|
|
276
|
+
chains: z.ZodMap<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
277
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
278
|
+
config: z.ZodObject<{
|
|
279
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
280
|
+
startBlock: z.ZodObject<{
|
|
281
|
+
timestamp: z.ZodInt;
|
|
282
|
+
number: z.ZodInt;
|
|
283
|
+
}, z.core.$strict>;
|
|
284
|
+
endBlock: z.ZodObject<{
|
|
285
|
+
timestamp: z.ZodInt;
|
|
286
|
+
number: z.ZodInt;
|
|
287
|
+
}, z.core.$strict>;
|
|
288
|
+
}, z.core.$strip>;
|
|
289
|
+
latestIndexedBlock: z.ZodObject<{
|
|
290
|
+
timestamp: z.ZodInt;
|
|
291
|
+
number: z.ZodInt;
|
|
292
|
+
}, z.core.$strict>;
|
|
293
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
294
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
295
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
296
|
+
omnichainStatus: z.ZodLiteral<"omnichain-following">;
|
|
297
|
+
chains: z.ZodMap<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
298
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
299
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
300
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
301
|
+
startBlock: z.ZodObject<{
|
|
302
|
+
timestamp: z.ZodInt;
|
|
303
|
+
number: z.ZodInt;
|
|
304
|
+
}, z.core.$strict>;
|
|
305
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
306
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
307
|
+
startBlock: z.ZodObject<{
|
|
308
|
+
timestamp: z.ZodInt;
|
|
309
|
+
number: z.ZodInt;
|
|
310
|
+
}, z.core.$strict>;
|
|
311
|
+
endBlock: z.ZodObject<{
|
|
312
|
+
timestamp: z.ZodInt;
|
|
313
|
+
number: z.ZodInt;
|
|
314
|
+
}, z.core.$strict>;
|
|
315
|
+
}, z.core.$strip>], "rangeType">;
|
|
316
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
317
|
+
chainStatus: z.ZodLiteral<"chain-backfill">;
|
|
318
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
319
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
320
|
+
startBlock: z.ZodObject<{
|
|
321
|
+
timestamp: z.ZodInt;
|
|
322
|
+
number: z.ZodInt;
|
|
323
|
+
}, z.core.$strict>;
|
|
324
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
325
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
326
|
+
startBlock: z.ZodObject<{
|
|
327
|
+
timestamp: z.ZodInt;
|
|
328
|
+
number: z.ZodInt;
|
|
329
|
+
}, z.core.$strict>;
|
|
330
|
+
endBlock: z.ZodObject<{
|
|
331
|
+
timestamp: z.ZodInt;
|
|
332
|
+
number: z.ZodInt;
|
|
333
|
+
}, z.core.$strict>;
|
|
334
|
+
}, z.core.$strip>], "rangeType">;
|
|
335
|
+
latestIndexedBlock: z.ZodObject<{
|
|
336
|
+
timestamp: z.ZodInt;
|
|
337
|
+
number: z.ZodInt;
|
|
338
|
+
}, z.core.$strict>;
|
|
339
|
+
backfillEndBlock: z.ZodObject<{
|
|
340
|
+
timestamp: z.ZodInt;
|
|
341
|
+
number: z.ZodInt;
|
|
342
|
+
}, z.core.$strict>;
|
|
343
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
344
|
+
chainStatus: z.ZodLiteral<"chain-following">;
|
|
345
|
+
config: z.ZodObject<{
|
|
346
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
347
|
+
startBlock: z.ZodObject<{
|
|
348
|
+
timestamp: z.ZodInt;
|
|
349
|
+
number: z.ZodInt;
|
|
350
|
+
}, z.core.$strict>;
|
|
351
|
+
}, z.core.$strip>;
|
|
352
|
+
latestIndexedBlock: z.ZodObject<{
|
|
353
|
+
timestamp: z.ZodInt;
|
|
354
|
+
number: z.ZodInt;
|
|
355
|
+
}, z.core.$strict>;
|
|
356
|
+
latestKnownBlock: z.ZodObject<{
|
|
357
|
+
timestamp: z.ZodInt;
|
|
358
|
+
number: z.ZodInt;
|
|
359
|
+
}, z.core.$strict>;
|
|
360
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
361
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
362
|
+
config: z.ZodObject<{
|
|
363
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
364
|
+
startBlock: z.ZodObject<{
|
|
365
|
+
timestamp: z.ZodInt;
|
|
366
|
+
number: z.ZodInt;
|
|
367
|
+
}, z.core.$strict>;
|
|
368
|
+
endBlock: z.ZodObject<{
|
|
369
|
+
timestamp: z.ZodInt;
|
|
370
|
+
number: z.ZodInt;
|
|
371
|
+
}, z.core.$strict>;
|
|
372
|
+
}, z.core.$strip>;
|
|
373
|
+
latestIndexedBlock: z.ZodObject<{
|
|
374
|
+
timestamp: z.ZodInt;
|
|
375
|
+
number: z.ZodInt;
|
|
376
|
+
}, z.core.$strict>;
|
|
377
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
378
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
379
|
+
}, z.core.$strip>], "omnichainStatus">;
|
|
380
|
+
}, z.core.$strip>], "strategy">;
|
|
381
|
+
}, z.core.$strip>;
|
|
382
|
+
stackInfo: z.ZodObject<{
|
|
383
|
+
ensDb: z.ZodObject<{
|
|
384
|
+
versionInfo: z.ZodObject<{
|
|
385
|
+
postgresql: z.ZodString;
|
|
386
|
+
}, z.core.$strip>;
|
|
387
|
+
}, z.core.$strip>;
|
|
388
|
+
ensIndexer: z.ZodObject<{
|
|
389
|
+
ensIndexerSchemaName: z.ZodString;
|
|
390
|
+
ensRainbowPublicConfig: z.ZodObject<{
|
|
391
|
+
serverLabelSet: z.ZodObject<{
|
|
392
|
+
labelSetId: z.ZodString;
|
|
393
|
+
highestLabelSetVersion: z.ZodInt;
|
|
394
|
+
}, z.core.$strip>;
|
|
395
|
+
versionInfo: z.ZodObject<{
|
|
396
|
+
ensRainbow: z.ZodString;
|
|
397
|
+
}, z.core.$strip>;
|
|
398
|
+
}, z.core.$strip>;
|
|
399
|
+
indexedChainIds: z.ZodSet<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
400
|
+
isSubgraphCompatible: z.ZodBoolean;
|
|
401
|
+
clientLabelSet: z.ZodObject<{
|
|
402
|
+
labelSetId: z.ZodString;
|
|
403
|
+
labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
|
|
404
|
+
}, z.core.$strip>;
|
|
405
|
+
namespace: z.ZodEnum<{
|
|
406
|
+
readonly Mainnet: "mainnet";
|
|
407
|
+
readonly Sepolia: "sepolia";
|
|
408
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
409
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
410
|
+
}>;
|
|
411
|
+
plugins: z.ZodArray<z.ZodString>;
|
|
412
|
+
versionInfo: z.ZodObject<{
|
|
413
|
+
ponder: z.ZodString;
|
|
414
|
+
ensDb: z.ZodString;
|
|
415
|
+
ensIndexer: z.ZodString;
|
|
416
|
+
ensNormalize: z.ZodString;
|
|
417
|
+
}, z.core.$strip>;
|
|
418
|
+
}, z.core.$strip>;
|
|
419
|
+
ensRainbow: z.ZodObject<{
|
|
420
|
+
serverLabelSet: z.ZodObject<{
|
|
421
|
+
labelSetId: z.ZodString;
|
|
422
|
+
highestLabelSetVersion: z.ZodInt;
|
|
423
|
+
}, z.core.$strip>;
|
|
424
|
+
versionInfo: z.ZodObject<{
|
|
425
|
+
ensRainbow: z.ZodString;
|
|
426
|
+
}, z.core.$strip>;
|
|
427
|
+
}, z.core.$strip>;
|
|
428
|
+
ensApi: z.ZodObject<{
|
|
429
|
+
theGraphFallback: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
430
|
+
canFallback: z.ZodLiteral<true>;
|
|
431
|
+
url: z.ZodString;
|
|
432
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
433
|
+
canFallback: z.ZodLiteral<false>;
|
|
434
|
+
reason: z.ZodEnum<{
|
|
435
|
+
readonly NotSubgraphCompatible: "not-subgraph-compatible";
|
|
436
|
+
readonly NoApiKey: "no-api-key";
|
|
437
|
+
readonly NoSubgraphUrl: "no-subgraph-url";
|
|
438
|
+
}>;
|
|
439
|
+
}, z.core.$strict>], "canFallback">;
|
|
440
|
+
ensIndexerPublicConfig: z.ZodObject<{
|
|
441
|
+
ensIndexerSchemaName: z.ZodString;
|
|
442
|
+
ensRainbowPublicConfig: z.ZodObject<{
|
|
443
|
+
serverLabelSet: z.ZodObject<{
|
|
444
|
+
labelSetId: z.ZodString;
|
|
445
|
+
highestLabelSetVersion: z.ZodInt;
|
|
446
|
+
}, z.core.$strip>;
|
|
447
|
+
versionInfo: z.ZodObject<{
|
|
448
|
+
ensRainbow: z.ZodString;
|
|
449
|
+
}, z.core.$strip>;
|
|
450
|
+
}, z.core.$strip>;
|
|
451
|
+
indexedChainIds: z.ZodSet<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
452
|
+
isSubgraphCompatible: z.ZodBoolean;
|
|
453
|
+
clientLabelSet: z.ZodObject<{
|
|
454
|
+
labelSetId: z.ZodString;
|
|
455
|
+
labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
|
|
456
|
+
}, z.core.$strip>;
|
|
457
|
+
namespace: z.ZodEnum<{
|
|
458
|
+
readonly Mainnet: "mainnet";
|
|
459
|
+
readonly Sepolia: "sepolia";
|
|
460
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
461
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
462
|
+
}>;
|
|
463
|
+
plugins: z.ZodArray<z.ZodString>;
|
|
464
|
+
versionInfo: z.ZodObject<{
|
|
465
|
+
ponder: z.ZodString;
|
|
466
|
+
ensDb: z.ZodString;
|
|
467
|
+
ensIndexer: z.ZodString;
|
|
468
|
+
ensNormalize: z.ZodString;
|
|
469
|
+
}, z.core.$strip>;
|
|
470
|
+
}, z.core.$strip>;
|
|
471
|
+
versionInfo: z.ZodObject<{
|
|
472
|
+
ensApi: z.ZodString;
|
|
473
|
+
ensNormalize: z.ZodString;
|
|
474
|
+
}, z.core.$strip>;
|
|
475
|
+
}, z.core.$strip>;
|
|
476
|
+
}, z.core.$strip>;
|
|
477
|
+
}, z.core.$strict>;
|
|
478
|
+
/**
|
|
479
|
+
* Schema for {@link EnsApiIndexingStatusResponseError}
|
|
480
|
+
**/
|
|
481
|
+
declare const makeEnsApiIndexingStatusResponseErrorSchema: (_valueLabel?: string) => z.ZodObject<{
|
|
482
|
+
responseCode: z.ZodLiteral<"error">;
|
|
483
|
+
}, z.core.$strict>;
|
|
484
|
+
/**
|
|
485
|
+
* Schema for {@link EnsApiIndexingStatusResponse}
|
|
486
|
+
**/
|
|
487
|
+
declare const makeEnsApiIndexingStatusResponseSchema: (valueLabel?: string) => z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
488
|
+
responseCode: z.ZodLiteral<"ok">;
|
|
489
|
+
realtimeProjection: z.ZodObject<{
|
|
490
|
+
projectedAt: z.ZodInt;
|
|
491
|
+
worstCaseDistance: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
492
|
+
snapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
493
|
+
strategy: z.ZodLiteral<"omnichain">;
|
|
494
|
+
slowestChainIndexingCursor: z.ZodInt;
|
|
495
|
+
snapshotTime: z.ZodInt;
|
|
496
|
+
omnichainSnapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
497
|
+
omnichainStatus: z.ZodLiteral<"omnichain-unstarted">;
|
|
498
|
+
chains: z.ZodMap<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
499
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
500
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
501
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
502
|
+
startBlock: z.ZodObject<{
|
|
503
|
+
timestamp: z.ZodInt;
|
|
504
|
+
number: z.ZodInt;
|
|
505
|
+
}, z.core.$strict>;
|
|
506
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
507
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
508
|
+
startBlock: z.ZodObject<{
|
|
509
|
+
timestamp: z.ZodInt;
|
|
510
|
+
number: z.ZodInt;
|
|
511
|
+
}, z.core.$strict>;
|
|
512
|
+
endBlock: z.ZodObject<{
|
|
513
|
+
timestamp: z.ZodInt;
|
|
514
|
+
number: z.ZodInt;
|
|
515
|
+
}, z.core.$strict>;
|
|
516
|
+
}, z.core.$strip>], "rangeType">;
|
|
517
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
518
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
519
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
520
|
+
omnichainStatus: z.ZodLiteral<"omnichain-backfill">;
|
|
521
|
+
chains: z.ZodMap<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
522
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
523
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
524
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
525
|
+
startBlock: z.ZodObject<{
|
|
526
|
+
timestamp: z.ZodInt;
|
|
527
|
+
number: z.ZodInt;
|
|
528
|
+
}, z.core.$strict>;
|
|
529
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
530
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
531
|
+
startBlock: z.ZodObject<{
|
|
532
|
+
timestamp: z.ZodInt;
|
|
533
|
+
number: z.ZodInt;
|
|
534
|
+
}, z.core.$strict>;
|
|
535
|
+
endBlock: z.ZodObject<{
|
|
536
|
+
timestamp: z.ZodInt;
|
|
537
|
+
number: z.ZodInt;
|
|
538
|
+
}, z.core.$strict>;
|
|
539
|
+
}, z.core.$strip>], "rangeType">;
|
|
540
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
541
|
+
chainStatus: z.ZodLiteral<"chain-backfill">;
|
|
542
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
543
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
544
|
+
startBlock: z.ZodObject<{
|
|
545
|
+
timestamp: z.ZodInt;
|
|
546
|
+
number: z.ZodInt;
|
|
547
|
+
}, z.core.$strict>;
|
|
548
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
549
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
550
|
+
startBlock: z.ZodObject<{
|
|
551
|
+
timestamp: z.ZodInt;
|
|
552
|
+
number: z.ZodInt;
|
|
553
|
+
}, z.core.$strict>;
|
|
554
|
+
endBlock: z.ZodObject<{
|
|
555
|
+
timestamp: z.ZodInt;
|
|
556
|
+
number: z.ZodInt;
|
|
557
|
+
}, z.core.$strict>;
|
|
558
|
+
}, z.core.$strip>], "rangeType">;
|
|
559
|
+
latestIndexedBlock: z.ZodObject<{
|
|
560
|
+
timestamp: z.ZodInt;
|
|
561
|
+
number: z.ZodInt;
|
|
562
|
+
}, z.core.$strict>;
|
|
563
|
+
backfillEndBlock: z.ZodObject<{
|
|
564
|
+
timestamp: z.ZodInt;
|
|
565
|
+
number: z.ZodInt;
|
|
566
|
+
}, z.core.$strict>;
|
|
567
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
568
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
569
|
+
config: z.ZodObject<{
|
|
570
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
571
|
+
startBlock: z.ZodObject<{
|
|
572
|
+
timestamp: z.ZodInt;
|
|
573
|
+
number: z.ZodInt;
|
|
574
|
+
}, z.core.$strict>;
|
|
575
|
+
endBlock: z.ZodObject<{
|
|
576
|
+
timestamp: z.ZodInt;
|
|
577
|
+
number: z.ZodInt;
|
|
578
|
+
}, z.core.$strict>;
|
|
579
|
+
}, z.core.$strip>;
|
|
580
|
+
latestIndexedBlock: z.ZodObject<{
|
|
581
|
+
timestamp: z.ZodInt;
|
|
582
|
+
number: z.ZodInt;
|
|
583
|
+
}, z.core.$strict>;
|
|
584
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
585
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
586
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
587
|
+
omnichainStatus: z.ZodLiteral<"omnichain-completed">;
|
|
588
|
+
chains: z.ZodMap<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
589
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
590
|
+
config: z.ZodObject<{
|
|
591
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
592
|
+
startBlock: z.ZodObject<{
|
|
593
|
+
timestamp: z.ZodInt;
|
|
594
|
+
number: z.ZodInt;
|
|
595
|
+
}, z.core.$strict>;
|
|
596
|
+
endBlock: z.ZodObject<{
|
|
597
|
+
timestamp: z.ZodInt;
|
|
598
|
+
number: z.ZodInt;
|
|
599
|
+
}, z.core.$strict>;
|
|
600
|
+
}, z.core.$strip>;
|
|
601
|
+
latestIndexedBlock: z.ZodObject<{
|
|
602
|
+
timestamp: z.ZodInt;
|
|
603
|
+
number: z.ZodInt;
|
|
604
|
+
}, z.core.$strict>;
|
|
605
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
606
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
607
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
608
|
+
omnichainStatus: z.ZodLiteral<"omnichain-following">;
|
|
609
|
+
chains: z.ZodMap<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
610
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
611
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
612
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
613
|
+
startBlock: z.ZodObject<{
|
|
614
|
+
timestamp: z.ZodInt;
|
|
615
|
+
number: z.ZodInt;
|
|
616
|
+
}, z.core.$strict>;
|
|
617
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
618
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
619
|
+
startBlock: z.ZodObject<{
|
|
620
|
+
timestamp: z.ZodInt;
|
|
621
|
+
number: z.ZodInt;
|
|
622
|
+
}, z.core.$strict>;
|
|
623
|
+
endBlock: z.ZodObject<{
|
|
624
|
+
timestamp: z.ZodInt;
|
|
625
|
+
number: z.ZodInt;
|
|
626
|
+
}, z.core.$strict>;
|
|
627
|
+
}, z.core.$strip>], "rangeType">;
|
|
628
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
629
|
+
chainStatus: z.ZodLiteral<"chain-backfill">;
|
|
630
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
631
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
632
|
+
startBlock: z.ZodObject<{
|
|
633
|
+
timestamp: z.ZodInt;
|
|
634
|
+
number: z.ZodInt;
|
|
635
|
+
}, z.core.$strict>;
|
|
636
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
637
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
638
|
+
startBlock: z.ZodObject<{
|
|
639
|
+
timestamp: z.ZodInt;
|
|
640
|
+
number: z.ZodInt;
|
|
641
|
+
}, z.core.$strict>;
|
|
642
|
+
endBlock: z.ZodObject<{
|
|
643
|
+
timestamp: z.ZodInt;
|
|
644
|
+
number: z.ZodInt;
|
|
645
|
+
}, z.core.$strict>;
|
|
646
|
+
}, z.core.$strip>], "rangeType">;
|
|
647
|
+
latestIndexedBlock: z.ZodObject<{
|
|
648
|
+
timestamp: z.ZodInt;
|
|
649
|
+
number: z.ZodInt;
|
|
650
|
+
}, z.core.$strict>;
|
|
651
|
+
backfillEndBlock: z.ZodObject<{
|
|
652
|
+
timestamp: z.ZodInt;
|
|
653
|
+
number: z.ZodInt;
|
|
654
|
+
}, z.core.$strict>;
|
|
655
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
656
|
+
chainStatus: z.ZodLiteral<"chain-following">;
|
|
657
|
+
config: z.ZodObject<{
|
|
658
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
659
|
+
startBlock: z.ZodObject<{
|
|
660
|
+
timestamp: z.ZodInt;
|
|
661
|
+
number: z.ZodInt;
|
|
662
|
+
}, z.core.$strict>;
|
|
663
|
+
}, z.core.$strip>;
|
|
664
|
+
latestIndexedBlock: z.ZodObject<{
|
|
665
|
+
timestamp: z.ZodInt;
|
|
666
|
+
number: z.ZodInt;
|
|
667
|
+
}, z.core.$strict>;
|
|
668
|
+
latestKnownBlock: z.ZodObject<{
|
|
669
|
+
timestamp: z.ZodInt;
|
|
670
|
+
number: z.ZodInt;
|
|
671
|
+
}, z.core.$strict>;
|
|
672
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
673
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
674
|
+
config: z.ZodObject<{
|
|
675
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
676
|
+
startBlock: z.ZodObject<{
|
|
677
|
+
timestamp: z.ZodInt;
|
|
678
|
+
number: z.ZodInt;
|
|
679
|
+
}, z.core.$strict>;
|
|
680
|
+
endBlock: z.ZodObject<{
|
|
681
|
+
timestamp: z.ZodInt;
|
|
682
|
+
number: z.ZodInt;
|
|
683
|
+
}, z.core.$strict>;
|
|
684
|
+
}, z.core.$strip>;
|
|
685
|
+
latestIndexedBlock: z.ZodObject<{
|
|
686
|
+
timestamp: z.ZodInt;
|
|
687
|
+
number: z.ZodInt;
|
|
688
|
+
}, z.core.$strict>;
|
|
689
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
690
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
691
|
+
}, z.core.$strip>], "omnichainStatus">;
|
|
692
|
+
}, z.core.$strip>], "strategy">;
|
|
693
|
+
}, z.core.$strip>;
|
|
694
|
+
stackInfo: z.ZodObject<{
|
|
695
|
+
ensDb: z.ZodObject<{
|
|
696
|
+
versionInfo: z.ZodObject<{
|
|
697
|
+
postgresql: z.ZodString;
|
|
698
|
+
}, z.core.$strip>;
|
|
699
|
+
}, z.core.$strip>;
|
|
700
|
+
ensIndexer: z.ZodObject<{
|
|
701
|
+
ensIndexerSchemaName: z.ZodString;
|
|
702
|
+
ensRainbowPublicConfig: z.ZodObject<{
|
|
703
|
+
serverLabelSet: z.ZodObject<{
|
|
704
|
+
labelSetId: z.ZodString;
|
|
705
|
+
highestLabelSetVersion: z.ZodInt;
|
|
706
|
+
}, z.core.$strip>;
|
|
707
|
+
versionInfo: z.ZodObject<{
|
|
708
|
+
ensRainbow: z.ZodString;
|
|
709
|
+
}, z.core.$strip>;
|
|
710
|
+
}, z.core.$strip>;
|
|
711
|
+
indexedChainIds: z.ZodSet<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
712
|
+
isSubgraphCompatible: z.ZodBoolean;
|
|
713
|
+
clientLabelSet: z.ZodObject<{
|
|
714
|
+
labelSetId: z.ZodString;
|
|
715
|
+
labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
|
|
716
|
+
}, z.core.$strip>;
|
|
717
|
+
namespace: z.ZodEnum<{
|
|
718
|
+
readonly Mainnet: "mainnet";
|
|
719
|
+
readonly Sepolia: "sepolia";
|
|
720
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
721
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
722
|
+
}>;
|
|
723
|
+
plugins: z.ZodArray<z.ZodString>;
|
|
724
|
+
versionInfo: z.ZodObject<{
|
|
725
|
+
ponder: z.ZodString;
|
|
726
|
+
ensDb: z.ZodString;
|
|
727
|
+
ensIndexer: z.ZodString;
|
|
728
|
+
ensNormalize: z.ZodString;
|
|
729
|
+
}, z.core.$strip>;
|
|
730
|
+
}, z.core.$strip>;
|
|
731
|
+
ensRainbow: z.ZodObject<{
|
|
732
|
+
serverLabelSet: z.ZodObject<{
|
|
733
|
+
labelSetId: z.ZodString;
|
|
734
|
+
highestLabelSetVersion: z.ZodInt;
|
|
735
|
+
}, z.core.$strip>;
|
|
736
|
+
versionInfo: z.ZodObject<{
|
|
737
|
+
ensRainbow: z.ZodString;
|
|
738
|
+
}, z.core.$strip>;
|
|
739
|
+
}, z.core.$strip>;
|
|
740
|
+
ensApi: z.ZodObject<{
|
|
741
|
+
theGraphFallback: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
742
|
+
canFallback: z.ZodLiteral<true>;
|
|
743
|
+
url: z.ZodString;
|
|
744
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
745
|
+
canFallback: z.ZodLiteral<false>;
|
|
746
|
+
reason: z.ZodEnum<{
|
|
747
|
+
readonly NotSubgraphCompatible: "not-subgraph-compatible";
|
|
748
|
+
readonly NoApiKey: "no-api-key";
|
|
749
|
+
readonly NoSubgraphUrl: "no-subgraph-url";
|
|
750
|
+
}>;
|
|
751
|
+
}, z.core.$strict>], "canFallback">;
|
|
752
|
+
ensIndexerPublicConfig: z.ZodObject<{
|
|
753
|
+
ensIndexerSchemaName: z.ZodString;
|
|
754
|
+
ensRainbowPublicConfig: z.ZodObject<{
|
|
755
|
+
serverLabelSet: z.ZodObject<{
|
|
756
|
+
labelSetId: z.ZodString;
|
|
757
|
+
highestLabelSetVersion: z.ZodInt;
|
|
758
|
+
}, z.core.$strip>;
|
|
759
|
+
versionInfo: z.ZodObject<{
|
|
760
|
+
ensRainbow: z.ZodString;
|
|
761
|
+
}, z.core.$strip>;
|
|
762
|
+
}, z.core.$strip>;
|
|
763
|
+
indexedChainIds: z.ZodSet<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
764
|
+
isSubgraphCompatible: z.ZodBoolean;
|
|
765
|
+
clientLabelSet: z.ZodObject<{
|
|
766
|
+
labelSetId: z.ZodString;
|
|
767
|
+
labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
|
|
768
|
+
}, z.core.$strip>;
|
|
769
|
+
namespace: z.ZodEnum<{
|
|
770
|
+
readonly Mainnet: "mainnet";
|
|
771
|
+
readonly Sepolia: "sepolia";
|
|
772
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
773
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
774
|
+
}>;
|
|
775
|
+
plugins: z.ZodArray<z.ZodString>;
|
|
776
|
+
versionInfo: z.ZodObject<{
|
|
777
|
+
ponder: z.ZodString;
|
|
778
|
+
ensDb: z.ZodString;
|
|
779
|
+
ensIndexer: z.ZodString;
|
|
780
|
+
ensNormalize: z.ZodString;
|
|
781
|
+
}, z.core.$strip>;
|
|
782
|
+
}, z.core.$strip>;
|
|
783
|
+
versionInfo: z.ZodObject<{
|
|
784
|
+
ensApi: z.ZodString;
|
|
785
|
+
ensNormalize: z.ZodString;
|
|
786
|
+
}, z.core.$strip>;
|
|
787
|
+
}, z.core.$strip>;
|
|
788
|
+
}, z.core.$strip>;
|
|
789
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
790
|
+
responseCode: z.ZodLiteral<"error">;
|
|
791
|
+
}, z.core.$strict>], "responseCode">;
|
|
792
|
+
/**
|
|
793
|
+
* Schema for {@link EnsApiIndexingStatusResponse}
|
|
794
|
+
* @deprecated Use {@link makeEnsApiIndexingStatusResponseSchema} instead.
|
|
795
|
+
*/
|
|
796
|
+
declare const makeIndexingStatusResponseSchema: (valueLabel?: string) => z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
797
|
+
responseCode: z.ZodLiteral<"ok">;
|
|
798
|
+
realtimeProjection: z.ZodObject<{
|
|
799
|
+
projectedAt: z.ZodInt;
|
|
800
|
+
worstCaseDistance: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
801
|
+
snapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
802
|
+
strategy: z.ZodLiteral<"omnichain">;
|
|
803
|
+
slowestChainIndexingCursor: z.ZodInt;
|
|
804
|
+
snapshotTime: z.ZodInt;
|
|
805
|
+
omnichainSnapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
806
|
+
omnichainStatus: z.ZodLiteral<"omnichain-unstarted">;
|
|
807
|
+
chains: z.ZodMap<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
808
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
809
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
810
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
811
|
+
startBlock: z.ZodObject<{
|
|
812
|
+
timestamp: z.ZodInt;
|
|
813
|
+
number: z.ZodInt;
|
|
814
|
+
}, z.core.$strict>;
|
|
815
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
816
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
817
|
+
startBlock: z.ZodObject<{
|
|
818
|
+
timestamp: z.ZodInt;
|
|
819
|
+
number: z.ZodInt;
|
|
820
|
+
}, z.core.$strict>;
|
|
821
|
+
endBlock: z.ZodObject<{
|
|
822
|
+
timestamp: z.ZodInt;
|
|
823
|
+
number: z.ZodInt;
|
|
824
|
+
}, z.core.$strict>;
|
|
825
|
+
}, z.core.$strip>], "rangeType">;
|
|
826
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
827
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
828
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
829
|
+
omnichainStatus: z.ZodLiteral<"omnichain-backfill">;
|
|
830
|
+
chains: z.ZodMap<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
831
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
832
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
833
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
834
|
+
startBlock: z.ZodObject<{
|
|
835
|
+
timestamp: z.ZodInt;
|
|
836
|
+
number: z.ZodInt;
|
|
837
|
+
}, z.core.$strict>;
|
|
838
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
839
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
840
|
+
startBlock: z.ZodObject<{
|
|
841
|
+
timestamp: z.ZodInt;
|
|
842
|
+
number: z.ZodInt;
|
|
843
|
+
}, z.core.$strict>;
|
|
844
|
+
endBlock: z.ZodObject<{
|
|
845
|
+
timestamp: z.ZodInt;
|
|
846
|
+
number: z.ZodInt;
|
|
847
|
+
}, z.core.$strict>;
|
|
848
|
+
}, z.core.$strip>], "rangeType">;
|
|
849
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
850
|
+
chainStatus: z.ZodLiteral<"chain-backfill">;
|
|
851
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
852
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
853
|
+
startBlock: z.ZodObject<{
|
|
854
|
+
timestamp: z.ZodInt;
|
|
855
|
+
number: z.ZodInt;
|
|
856
|
+
}, z.core.$strict>;
|
|
857
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
858
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
859
|
+
startBlock: z.ZodObject<{
|
|
860
|
+
timestamp: z.ZodInt;
|
|
861
|
+
number: z.ZodInt;
|
|
862
|
+
}, z.core.$strict>;
|
|
863
|
+
endBlock: z.ZodObject<{
|
|
864
|
+
timestamp: z.ZodInt;
|
|
865
|
+
number: z.ZodInt;
|
|
866
|
+
}, z.core.$strict>;
|
|
867
|
+
}, z.core.$strip>], "rangeType">;
|
|
868
|
+
latestIndexedBlock: z.ZodObject<{
|
|
869
|
+
timestamp: z.ZodInt;
|
|
870
|
+
number: z.ZodInt;
|
|
871
|
+
}, z.core.$strict>;
|
|
872
|
+
backfillEndBlock: z.ZodObject<{
|
|
873
|
+
timestamp: z.ZodInt;
|
|
874
|
+
number: z.ZodInt;
|
|
875
|
+
}, z.core.$strict>;
|
|
876
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
877
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
878
|
+
config: z.ZodObject<{
|
|
879
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
880
|
+
startBlock: z.ZodObject<{
|
|
881
|
+
timestamp: z.ZodInt;
|
|
882
|
+
number: z.ZodInt;
|
|
883
|
+
}, z.core.$strict>;
|
|
884
|
+
endBlock: z.ZodObject<{
|
|
885
|
+
timestamp: z.ZodInt;
|
|
886
|
+
number: z.ZodInt;
|
|
887
|
+
}, z.core.$strict>;
|
|
888
|
+
}, z.core.$strip>;
|
|
889
|
+
latestIndexedBlock: z.ZodObject<{
|
|
890
|
+
timestamp: z.ZodInt;
|
|
891
|
+
number: z.ZodInt;
|
|
892
|
+
}, z.core.$strict>;
|
|
893
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
894
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
895
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
896
|
+
omnichainStatus: z.ZodLiteral<"omnichain-completed">;
|
|
897
|
+
chains: z.ZodMap<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
898
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
899
|
+
config: z.ZodObject<{
|
|
900
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
901
|
+
startBlock: z.ZodObject<{
|
|
902
|
+
timestamp: z.ZodInt;
|
|
903
|
+
number: z.ZodInt;
|
|
904
|
+
}, z.core.$strict>;
|
|
905
|
+
endBlock: z.ZodObject<{
|
|
906
|
+
timestamp: z.ZodInt;
|
|
907
|
+
number: z.ZodInt;
|
|
908
|
+
}, z.core.$strict>;
|
|
909
|
+
}, z.core.$strip>;
|
|
910
|
+
latestIndexedBlock: z.ZodObject<{
|
|
911
|
+
timestamp: z.ZodInt;
|
|
912
|
+
number: z.ZodInt;
|
|
913
|
+
}, z.core.$strict>;
|
|
914
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
915
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
916
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
917
|
+
omnichainStatus: z.ZodLiteral<"omnichain-following">;
|
|
918
|
+
chains: z.ZodMap<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
919
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
920
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
921
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
922
|
+
startBlock: z.ZodObject<{
|
|
923
|
+
timestamp: z.ZodInt;
|
|
924
|
+
number: z.ZodInt;
|
|
925
|
+
}, z.core.$strict>;
|
|
926
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
927
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
928
|
+
startBlock: z.ZodObject<{
|
|
929
|
+
timestamp: z.ZodInt;
|
|
930
|
+
number: z.ZodInt;
|
|
931
|
+
}, z.core.$strict>;
|
|
932
|
+
endBlock: z.ZodObject<{
|
|
933
|
+
timestamp: z.ZodInt;
|
|
934
|
+
number: z.ZodInt;
|
|
935
|
+
}, z.core.$strict>;
|
|
936
|
+
}, z.core.$strip>], "rangeType">;
|
|
937
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
938
|
+
chainStatus: z.ZodLiteral<"chain-backfill">;
|
|
939
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
940
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
941
|
+
startBlock: z.ZodObject<{
|
|
942
|
+
timestamp: z.ZodInt;
|
|
943
|
+
number: z.ZodInt;
|
|
944
|
+
}, z.core.$strict>;
|
|
945
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
946
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
947
|
+
startBlock: z.ZodObject<{
|
|
948
|
+
timestamp: z.ZodInt;
|
|
949
|
+
number: z.ZodInt;
|
|
950
|
+
}, z.core.$strict>;
|
|
951
|
+
endBlock: z.ZodObject<{
|
|
952
|
+
timestamp: z.ZodInt;
|
|
953
|
+
number: z.ZodInt;
|
|
954
|
+
}, z.core.$strict>;
|
|
955
|
+
}, z.core.$strip>], "rangeType">;
|
|
956
|
+
latestIndexedBlock: z.ZodObject<{
|
|
957
|
+
timestamp: z.ZodInt;
|
|
958
|
+
number: z.ZodInt;
|
|
959
|
+
}, z.core.$strict>;
|
|
960
|
+
backfillEndBlock: z.ZodObject<{
|
|
961
|
+
timestamp: z.ZodInt;
|
|
962
|
+
number: z.ZodInt;
|
|
963
|
+
}, z.core.$strict>;
|
|
964
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
965
|
+
chainStatus: z.ZodLiteral<"chain-following">;
|
|
966
|
+
config: z.ZodObject<{
|
|
967
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
968
|
+
startBlock: z.ZodObject<{
|
|
969
|
+
timestamp: z.ZodInt;
|
|
970
|
+
number: z.ZodInt;
|
|
971
|
+
}, z.core.$strict>;
|
|
972
|
+
}, z.core.$strip>;
|
|
973
|
+
latestIndexedBlock: z.ZodObject<{
|
|
974
|
+
timestamp: z.ZodInt;
|
|
975
|
+
number: z.ZodInt;
|
|
976
|
+
}, z.core.$strict>;
|
|
977
|
+
latestKnownBlock: z.ZodObject<{
|
|
978
|
+
timestamp: z.ZodInt;
|
|
979
|
+
number: z.ZodInt;
|
|
980
|
+
}, z.core.$strict>;
|
|
981
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
982
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
983
|
+
config: z.ZodObject<{
|
|
984
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
985
|
+
startBlock: z.ZodObject<{
|
|
986
|
+
timestamp: z.ZodInt;
|
|
987
|
+
number: z.ZodInt;
|
|
988
|
+
}, z.core.$strict>;
|
|
989
|
+
endBlock: z.ZodObject<{
|
|
990
|
+
timestamp: z.ZodInt;
|
|
991
|
+
number: z.ZodInt;
|
|
992
|
+
}, z.core.$strict>;
|
|
993
|
+
}, z.core.$strip>;
|
|
994
|
+
latestIndexedBlock: z.ZodObject<{
|
|
995
|
+
timestamp: z.ZodInt;
|
|
996
|
+
number: z.ZodInt;
|
|
997
|
+
}, z.core.$strict>;
|
|
998
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
999
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
1000
|
+
}, z.core.$strip>], "omnichainStatus">;
|
|
1001
|
+
}, z.core.$strip>], "strategy">;
|
|
1002
|
+
}, z.core.$strip>;
|
|
1003
|
+
stackInfo: z.ZodObject<{
|
|
1004
|
+
ensDb: z.ZodObject<{
|
|
1005
|
+
versionInfo: z.ZodObject<{
|
|
1006
|
+
postgresql: z.ZodString;
|
|
1007
|
+
}, z.core.$strip>;
|
|
1008
|
+
}, z.core.$strip>;
|
|
1009
|
+
ensIndexer: z.ZodObject<{
|
|
1010
|
+
ensIndexerSchemaName: z.ZodString;
|
|
1011
|
+
ensRainbowPublicConfig: z.ZodObject<{
|
|
1012
|
+
serverLabelSet: z.ZodObject<{
|
|
1013
|
+
labelSetId: z.ZodString;
|
|
1014
|
+
highestLabelSetVersion: z.ZodInt;
|
|
1015
|
+
}, z.core.$strip>;
|
|
1016
|
+
versionInfo: z.ZodObject<{
|
|
1017
|
+
ensRainbow: z.ZodString;
|
|
1018
|
+
}, z.core.$strip>;
|
|
1019
|
+
}, z.core.$strip>;
|
|
1020
|
+
indexedChainIds: z.ZodSet<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
1021
|
+
isSubgraphCompatible: z.ZodBoolean;
|
|
1022
|
+
clientLabelSet: z.ZodObject<{
|
|
1023
|
+
labelSetId: z.ZodString;
|
|
1024
|
+
labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
|
|
1025
|
+
}, z.core.$strip>;
|
|
1026
|
+
namespace: z.ZodEnum<{
|
|
1027
|
+
readonly Mainnet: "mainnet";
|
|
1028
|
+
readonly Sepolia: "sepolia";
|
|
1029
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
1030
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
1031
|
+
}>;
|
|
1032
|
+
plugins: z.ZodArray<z.ZodString>;
|
|
1033
|
+
versionInfo: z.ZodObject<{
|
|
1034
|
+
ponder: z.ZodString;
|
|
1035
|
+
ensDb: z.ZodString;
|
|
1036
|
+
ensIndexer: z.ZodString;
|
|
1037
|
+
ensNormalize: z.ZodString;
|
|
1038
|
+
}, z.core.$strip>;
|
|
1039
|
+
}, z.core.$strip>;
|
|
1040
|
+
ensRainbow: z.ZodObject<{
|
|
1041
|
+
serverLabelSet: z.ZodObject<{
|
|
1042
|
+
labelSetId: z.ZodString;
|
|
1043
|
+
highestLabelSetVersion: z.ZodInt;
|
|
1044
|
+
}, z.core.$strip>;
|
|
1045
|
+
versionInfo: z.ZodObject<{
|
|
1046
|
+
ensRainbow: z.ZodString;
|
|
1047
|
+
}, z.core.$strip>;
|
|
1048
|
+
}, z.core.$strip>;
|
|
1049
|
+
ensApi: z.ZodObject<{
|
|
1050
|
+
theGraphFallback: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1051
|
+
canFallback: z.ZodLiteral<true>;
|
|
1052
|
+
url: z.ZodString;
|
|
1053
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1054
|
+
canFallback: z.ZodLiteral<false>;
|
|
1055
|
+
reason: z.ZodEnum<{
|
|
1056
|
+
readonly NotSubgraphCompatible: "not-subgraph-compatible";
|
|
1057
|
+
readonly NoApiKey: "no-api-key";
|
|
1058
|
+
readonly NoSubgraphUrl: "no-subgraph-url";
|
|
1059
|
+
}>;
|
|
1060
|
+
}, z.core.$strict>], "canFallback">;
|
|
1061
|
+
ensIndexerPublicConfig: z.ZodObject<{
|
|
1062
|
+
ensIndexerSchemaName: z.ZodString;
|
|
1063
|
+
ensRainbowPublicConfig: z.ZodObject<{
|
|
1064
|
+
serverLabelSet: z.ZodObject<{
|
|
1065
|
+
labelSetId: z.ZodString;
|
|
1066
|
+
highestLabelSetVersion: z.ZodInt;
|
|
1067
|
+
}, z.core.$strip>;
|
|
1068
|
+
versionInfo: z.ZodObject<{
|
|
1069
|
+
ensRainbow: z.ZodString;
|
|
1070
|
+
}, z.core.$strip>;
|
|
1071
|
+
}, z.core.$strip>;
|
|
1072
|
+
indexedChainIds: z.ZodSet<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
1073
|
+
isSubgraphCompatible: z.ZodBoolean;
|
|
1074
|
+
clientLabelSet: z.ZodObject<{
|
|
1075
|
+
labelSetId: z.ZodString;
|
|
1076
|
+
labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
|
|
1077
|
+
}, z.core.$strip>;
|
|
1078
|
+
namespace: z.ZodEnum<{
|
|
1079
|
+
readonly Mainnet: "mainnet";
|
|
1080
|
+
readonly Sepolia: "sepolia";
|
|
1081
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
1082
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
1083
|
+
}>;
|
|
1084
|
+
plugins: z.ZodArray<z.ZodString>;
|
|
1085
|
+
versionInfo: z.ZodObject<{
|
|
1086
|
+
ponder: z.ZodString;
|
|
1087
|
+
ensDb: z.ZodString;
|
|
1088
|
+
ensIndexer: z.ZodString;
|
|
1089
|
+
ensNormalize: z.ZodString;
|
|
1090
|
+
}, z.core.$strip>;
|
|
1091
|
+
}, z.core.$strip>;
|
|
1092
|
+
versionInfo: z.ZodObject<{
|
|
1093
|
+
ensApi: z.ZodString;
|
|
1094
|
+
ensNormalize: z.ZodString;
|
|
1095
|
+
}, z.core.$strip>;
|
|
1096
|
+
}, z.core.$strip>;
|
|
1097
|
+
}, z.core.$strip>;
|
|
1098
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1099
|
+
responseCode: z.ZodLiteral<"error">;
|
|
1100
|
+
}, z.core.$strict>], "responseCode">;
|
|
1101
|
+
/**
|
|
1102
|
+
* Schema for {@link SerializedEnsApiIndexingStatusResponseOk}
|
|
1103
|
+
**/
|
|
1104
|
+
declare const makeSerializedEnsApiIndexingStatusResponseOkSchema: (valueLabel?: string) => z.ZodObject<{
|
|
1105
|
+
responseCode: z.ZodLiteral<"ok">;
|
|
1106
|
+
realtimeProjection: z.ZodObject<{
|
|
1107
|
+
snapshot: z.ZodObject<{
|
|
1108
|
+
strategy: z.ZodEnum<{
|
|
1109
|
+
readonly Omnichain: "omnichain";
|
|
1110
|
+
}>;
|
|
1111
|
+
slowestChainIndexingCursor: z.ZodInt;
|
|
1112
|
+
snapshotTime: z.ZodInt;
|
|
1113
|
+
omnichainSnapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1114
|
+
omnichainStatus: z.ZodLiteral<"omnichain-unstarted">;
|
|
1115
|
+
chains: z.ZodRecord<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodCoercedNumber<string>>, z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1116
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
1117
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1118
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
1119
|
+
startBlock: z.ZodObject<{
|
|
1120
|
+
timestamp: z.ZodInt;
|
|
1121
|
+
number: z.ZodInt;
|
|
1122
|
+
}, z.core.$strict>;
|
|
1123
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1124
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1125
|
+
startBlock: z.ZodObject<{
|
|
1126
|
+
timestamp: z.ZodInt;
|
|
1127
|
+
number: z.ZodInt;
|
|
1128
|
+
}, z.core.$strict>;
|
|
1129
|
+
endBlock: z.ZodObject<{
|
|
1130
|
+
timestamp: z.ZodInt;
|
|
1131
|
+
number: z.ZodInt;
|
|
1132
|
+
}, z.core.$strict>;
|
|
1133
|
+
}, z.core.$strip>], "rangeType">;
|
|
1134
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
1135
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
1136
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1137
|
+
omnichainStatus: z.ZodLiteral<"omnichain-backfill">;
|
|
1138
|
+
chains: z.ZodRecord<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodCoercedNumber<string>>, z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1139
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
1140
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1141
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
1142
|
+
startBlock: z.ZodObject<{
|
|
1143
|
+
timestamp: z.ZodInt;
|
|
1144
|
+
number: z.ZodInt;
|
|
1145
|
+
}, z.core.$strict>;
|
|
1146
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1147
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1148
|
+
startBlock: z.ZodObject<{
|
|
1149
|
+
timestamp: z.ZodInt;
|
|
1150
|
+
number: z.ZodInt;
|
|
1151
|
+
}, z.core.$strict>;
|
|
1152
|
+
endBlock: z.ZodObject<{
|
|
1153
|
+
timestamp: z.ZodInt;
|
|
1154
|
+
number: z.ZodInt;
|
|
1155
|
+
}, z.core.$strict>;
|
|
1156
|
+
}, z.core.$strip>], "rangeType">;
|
|
1157
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1158
|
+
chainStatus: z.ZodLiteral<"chain-backfill">;
|
|
1159
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1160
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
1161
|
+
startBlock: z.ZodObject<{
|
|
1162
|
+
timestamp: z.ZodInt;
|
|
1163
|
+
number: z.ZodInt;
|
|
1164
|
+
}, z.core.$strict>;
|
|
1165
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1166
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1167
|
+
startBlock: z.ZodObject<{
|
|
1168
|
+
timestamp: z.ZodInt;
|
|
1169
|
+
number: z.ZodInt;
|
|
1170
|
+
}, z.core.$strict>;
|
|
1171
|
+
endBlock: z.ZodObject<{
|
|
1172
|
+
timestamp: z.ZodInt;
|
|
1173
|
+
number: z.ZodInt;
|
|
1174
|
+
}, z.core.$strict>;
|
|
1175
|
+
}, z.core.$strip>], "rangeType">;
|
|
1176
|
+
latestIndexedBlock: z.ZodObject<{
|
|
1177
|
+
timestamp: z.ZodInt;
|
|
1178
|
+
number: z.ZodInt;
|
|
1179
|
+
}, z.core.$strict>;
|
|
1180
|
+
backfillEndBlock: z.ZodObject<{
|
|
1181
|
+
timestamp: z.ZodInt;
|
|
1182
|
+
number: z.ZodInt;
|
|
1183
|
+
}, z.core.$strict>;
|
|
1184
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1185
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
1186
|
+
config: z.ZodObject<{
|
|
1187
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1188
|
+
startBlock: z.ZodObject<{
|
|
1189
|
+
timestamp: z.ZodInt;
|
|
1190
|
+
number: z.ZodInt;
|
|
1191
|
+
}, z.core.$strict>;
|
|
1192
|
+
endBlock: z.ZodObject<{
|
|
1193
|
+
timestamp: z.ZodInt;
|
|
1194
|
+
number: z.ZodInt;
|
|
1195
|
+
}, z.core.$strict>;
|
|
1196
|
+
}, z.core.$strip>;
|
|
1197
|
+
latestIndexedBlock: z.ZodObject<{
|
|
1198
|
+
timestamp: z.ZodInt;
|
|
1199
|
+
number: z.ZodInt;
|
|
1200
|
+
}, z.core.$strict>;
|
|
1201
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
1202
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
1203
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1204
|
+
omnichainStatus: z.ZodLiteral<"omnichain-completed">;
|
|
1205
|
+
chains: z.ZodRecord<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodCoercedNumber<string>>, z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1206
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
1207
|
+
config: z.ZodObject<{
|
|
1208
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1209
|
+
startBlock: z.ZodObject<{
|
|
1210
|
+
timestamp: z.ZodInt;
|
|
1211
|
+
number: z.ZodInt;
|
|
1212
|
+
}, z.core.$strict>;
|
|
1213
|
+
endBlock: z.ZodObject<{
|
|
1214
|
+
timestamp: z.ZodInt;
|
|
1215
|
+
number: z.ZodInt;
|
|
1216
|
+
}, z.core.$strict>;
|
|
1217
|
+
}, z.core.$strip>;
|
|
1218
|
+
latestIndexedBlock: z.ZodObject<{
|
|
1219
|
+
timestamp: z.ZodInt;
|
|
1220
|
+
number: z.ZodInt;
|
|
1221
|
+
}, z.core.$strict>;
|
|
1222
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
1223
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
1224
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1225
|
+
omnichainStatus: z.ZodLiteral<"omnichain-following">;
|
|
1226
|
+
chains: z.ZodRecord<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodCoercedNumber<string>>, z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1227
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
1228
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1229
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
1230
|
+
startBlock: z.ZodObject<{
|
|
1231
|
+
timestamp: z.ZodInt;
|
|
1232
|
+
number: z.ZodInt;
|
|
1233
|
+
}, z.core.$strict>;
|
|
1234
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1235
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1236
|
+
startBlock: z.ZodObject<{
|
|
1237
|
+
timestamp: z.ZodInt;
|
|
1238
|
+
number: z.ZodInt;
|
|
1239
|
+
}, z.core.$strict>;
|
|
1240
|
+
endBlock: z.ZodObject<{
|
|
1241
|
+
timestamp: z.ZodInt;
|
|
1242
|
+
number: z.ZodInt;
|
|
1243
|
+
}, z.core.$strict>;
|
|
1244
|
+
}, z.core.$strip>], "rangeType">;
|
|
1245
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1246
|
+
chainStatus: z.ZodLiteral<"chain-backfill">;
|
|
1247
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1248
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
1249
|
+
startBlock: z.ZodObject<{
|
|
1250
|
+
timestamp: z.ZodInt;
|
|
1251
|
+
number: z.ZodInt;
|
|
1252
|
+
}, z.core.$strict>;
|
|
1253
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1254
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1255
|
+
startBlock: z.ZodObject<{
|
|
1256
|
+
timestamp: z.ZodInt;
|
|
1257
|
+
number: z.ZodInt;
|
|
1258
|
+
}, z.core.$strict>;
|
|
1259
|
+
endBlock: z.ZodObject<{
|
|
1260
|
+
timestamp: z.ZodInt;
|
|
1261
|
+
number: z.ZodInt;
|
|
1262
|
+
}, z.core.$strict>;
|
|
1263
|
+
}, z.core.$strip>], "rangeType">;
|
|
1264
|
+
latestIndexedBlock: z.ZodObject<{
|
|
1265
|
+
timestamp: z.ZodInt;
|
|
1266
|
+
number: z.ZodInt;
|
|
1267
|
+
}, z.core.$strict>;
|
|
1268
|
+
backfillEndBlock: z.ZodObject<{
|
|
1269
|
+
timestamp: z.ZodInt;
|
|
1270
|
+
number: z.ZodInt;
|
|
1271
|
+
}, z.core.$strict>;
|
|
1272
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1273
|
+
chainStatus: z.ZodLiteral<"chain-following">;
|
|
1274
|
+
config: z.ZodObject<{
|
|
1275
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
1276
|
+
startBlock: z.ZodObject<{
|
|
1277
|
+
timestamp: z.ZodInt;
|
|
1278
|
+
number: z.ZodInt;
|
|
1279
|
+
}, z.core.$strict>;
|
|
1280
|
+
}, z.core.$strip>;
|
|
1281
|
+
latestIndexedBlock: z.ZodObject<{
|
|
1282
|
+
timestamp: z.ZodInt;
|
|
1283
|
+
number: z.ZodInt;
|
|
1284
|
+
}, z.core.$strict>;
|
|
1285
|
+
latestKnownBlock: z.ZodObject<{
|
|
1286
|
+
timestamp: z.ZodInt;
|
|
1287
|
+
number: z.ZodInt;
|
|
1288
|
+
}, z.core.$strict>;
|
|
1289
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1290
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
1291
|
+
config: z.ZodObject<{
|
|
1292
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1293
|
+
startBlock: z.ZodObject<{
|
|
1294
|
+
timestamp: z.ZodInt;
|
|
1295
|
+
number: z.ZodInt;
|
|
1296
|
+
}, z.core.$strict>;
|
|
1297
|
+
endBlock: z.ZodObject<{
|
|
1298
|
+
timestamp: z.ZodInt;
|
|
1299
|
+
number: z.ZodInt;
|
|
1300
|
+
}, z.core.$strict>;
|
|
1301
|
+
}, z.core.$strip>;
|
|
1302
|
+
latestIndexedBlock: z.ZodObject<{
|
|
1303
|
+
timestamp: z.ZodInt;
|
|
1304
|
+
number: z.ZodInt;
|
|
1305
|
+
}, z.core.$strict>;
|
|
1306
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
1307
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
1308
|
+
}, z.core.$strip>], "omnichainStatus">;
|
|
1309
|
+
}, z.core.$strip>;
|
|
1310
|
+
projectedAt: z.ZodInt;
|
|
1311
|
+
worstCaseDistance: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
1312
|
+
}, z.core.$strip>;
|
|
1313
|
+
stackInfo: z.ZodObject<{
|
|
1314
|
+
ensDb: z.ZodObject<{
|
|
1315
|
+
versionInfo: z.ZodObject<{
|
|
1316
|
+
postgresql: z.ZodString;
|
|
1317
|
+
}, z.core.$strip>;
|
|
1318
|
+
}, z.core.$strip>;
|
|
1319
|
+
ensIndexer: z.ZodObject<{
|
|
1320
|
+
ensIndexerSchemaName: z.ZodString;
|
|
1321
|
+
ensRainbowPublicConfig: z.ZodObject<{
|
|
1322
|
+
serverLabelSet: z.ZodObject<{
|
|
1323
|
+
labelSetId: z.ZodString;
|
|
1324
|
+
highestLabelSetVersion: z.ZodInt;
|
|
1325
|
+
}, z.core.$strip>;
|
|
1326
|
+
versionInfo: z.ZodObject<{
|
|
1327
|
+
ensRainbow: z.ZodString;
|
|
1328
|
+
}, z.core.$strip>;
|
|
1329
|
+
}, z.core.$strip>;
|
|
1330
|
+
indexedChainIds: z.ZodArray<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
1331
|
+
isSubgraphCompatible: z.ZodBoolean;
|
|
1332
|
+
clientLabelSet: z.ZodObject<{
|
|
1333
|
+
labelSetId: z.ZodString;
|
|
1334
|
+
labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
|
|
1335
|
+
}, z.core.$strip>;
|
|
1336
|
+
namespace: z.ZodEnum<{
|
|
1337
|
+
readonly Mainnet: "mainnet";
|
|
1338
|
+
readonly Sepolia: "sepolia";
|
|
1339
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
1340
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
1341
|
+
}>;
|
|
1342
|
+
plugins: z.ZodArray<z.ZodString>;
|
|
1343
|
+
versionInfo: z.ZodObject<{
|
|
1344
|
+
ponder: z.ZodString;
|
|
1345
|
+
ensDb: z.ZodString;
|
|
1346
|
+
ensIndexer: z.ZodString;
|
|
1347
|
+
ensNormalize: z.ZodString;
|
|
1348
|
+
}, z.core.$strip>;
|
|
1349
|
+
}, z.core.$strip>;
|
|
1350
|
+
ensRainbow: z.ZodObject<{
|
|
1351
|
+
serverLabelSet: z.ZodObject<{
|
|
1352
|
+
labelSetId: z.ZodString;
|
|
1353
|
+
highestLabelSetVersion: z.ZodInt;
|
|
1354
|
+
}, z.core.$strip>;
|
|
1355
|
+
versionInfo: z.ZodObject<{
|
|
1356
|
+
ensRainbow: z.ZodString;
|
|
1357
|
+
}, z.core.$strip>;
|
|
1358
|
+
}, z.core.$strip>;
|
|
1359
|
+
ensApi: z.ZodObject<{
|
|
1360
|
+
ensIndexerPublicConfig: z.ZodObject<{
|
|
1361
|
+
ensIndexerSchemaName: z.ZodString;
|
|
1362
|
+
ensRainbowPublicConfig: z.ZodObject<{
|
|
1363
|
+
serverLabelSet: z.ZodObject<{
|
|
1364
|
+
labelSetId: z.ZodString;
|
|
1365
|
+
highestLabelSetVersion: z.ZodInt;
|
|
1366
|
+
}, z.core.$strip>;
|
|
1367
|
+
versionInfo: z.ZodObject<{
|
|
1368
|
+
ensRainbow: z.ZodString;
|
|
1369
|
+
}, z.core.$strip>;
|
|
1370
|
+
}, z.core.$strip>;
|
|
1371
|
+
indexedChainIds: z.ZodArray<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
1372
|
+
isSubgraphCompatible: z.ZodBoolean;
|
|
1373
|
+
clientLabelSet: z.ZodObject<{
|
|
1374
|
+
labelSetId: z.ZodString;
|
|
1375
|
+
labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
|
|
1376
|
+
}, z.core.$strip>;
|
|
1377
|
+
namespace: z.ZodEnum<{
|
|
1378
|
+
readonly Mainnet: "mainnet";
|
|
1379
|
+
readonly Sepolia: "sepolia";
|
|
1380
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
1381
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
1382
|
+
}>;
|
|
1383
|
+
plugins: z.ZodArray<z.ZodString>;
|
|
1384
|
+
versionInfo: z.ZodObject<{
|
|
1385
|
+
ponder: z.ZodString;
|
|
1386
|
+
ensDb: z.ZodString;
|
|
1387
|
+
ensIndexer: z.ZodString;
|
|
1388
|
+
ensNormalize: z.ZodString;
|
|
1389
|
+
}, z.core.$strip>;
|
|
1390
|
+
}, z.core.$strip>;
|
|
1391
|
+
theGraphFallback: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1392
|
+
canFallback: z.ZodLiteral<true>;
|
|
1393
|
+
url: z.ZodString;
|
|
1394
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1395
|
+
canFallback: z.ZodLiteral<false>;
|
|
1396
|
+
reason: z.ZodEnum<{
|
|
1397
|
+
readonly NotSubgraphCompatible: "not-subgraph-compatible";
|
|
1398
|
+
readonly NoApiKey: "no-api-key";
|
|
1399
|
+
readonly NoSubgraphUrl: "no-subgraph-url";
|
|
1400
|
+
}>;
|
|
1401
|
+
}, z.core.$strict>], "canFallback">;
|
|
1402
|
+
versionInfo: z.ZodObject<{
|
|
1403
|
+
ensApi: z.ZodString;
|
|
1404
|
+
ensNormalize: z.ZodString;
|
|
1405
|
+
}, z.core.$strip>;
|
|
1406
|
+
}, z.core.$strip>;
|
|
1407
|
+
}, z.core.$strip>;
|
|
1408
|
+
}, z.core.$strip>;
|
|
1409
|
+
/**
|
|
1410
|
+
* Schema for {@link SerializedEnsApiIndexingStatusResponse}
|
|
1411
|
+
**/
|
|
1412
|
+
declare const makeSerializedEnsApiIndexingStatusResponseSchema: (valueLabel?: string) => z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1413
|
+
responseCode: z.ZodLiteral<"ok">;
|
|
1414
|
+
realtimeProjection: z.ZodObject<{
|
|
1415
|
+
snapshot: z.ZodObject<{
|
|
1416
|
+
strategy: z.ZodEnum<{
|
|
1417
|
+
readonly Omnichain: "omnichain";
|
|
1418
|
+
}>;
|
|
1419
|
+
slowestChainIndexingCursor: z.ZodInt;
|
|
1420
|
+
snapshotTime: z.ZodInt;
|
|
1421
|
+
omnichainSnapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1422
|
+
omnichainStatus: z.ZodLiteral<"omnichain-unstarted">;
|
|
1423
|
+
chains: z.ZodRecord<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodCoercedNumber<string>>, z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1424
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
1425
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1426
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
1427
|
+
startBlock: z.ZodObject<{
|
|
1428
|
+
timestamp: z.ZodInt;
|
|
1429
|
+
number: z.ZodInt;
|
|
1430
|
+
}, z.core.$strict>;
|
|
1431
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1432
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1433
|
+
startBlock: z.ZodObject<{
|
|
1434
|
+
timestamp: z.ZodInt;
|
|
1435
|
+
number: z.ZodInt;
|
|
1436
|
+
}, z.core.$strict>;
|
|
1437
|
+
endBlock: z.ZodObject<{
|
|
1438
|
+
timestamp: z.ZodInt;
|
|
1439
|
+
number: z.ZodInt;
|
|
1440
|
+
}, z.core.$strict>;
|
|
1441
|
+
}, z.core.$strip>], "rangeType">;
|
|
1442
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
1443
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
1444
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1445
|
+
omnichainStatus: z.ZodLiteral<"omnichain-backfill">;
|
|
1446
|
+
chains: z.ZodRecord<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodCoercedNumber<string>>, z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1447
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
1448
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1449
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
1450
|
+
startBlock: z.ZodObject<{
|
|
1451
|
+
timestamp: z.ZodInt;
|
|
1452
|
+
number: z.ZodInt;
|
|
1453
|
+
}, z.core.$strict>;
|
|
1454
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1455
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1456
|
+
startBlock: z.ZodObject<{
|
|
1457
|
+
timestamp: z.ZodInt;
|
|
1458
|
+
number: z.ZodInt;
|
|
1459
|
+
}, z.core.$strict>;
|
|
1460
|
+
endBlock: z.ZodObject<{
|
|
1461
|
+
timestamp: z.ZodInt;
|
|
1462
|
+
number: z.ZodInt;
|
|
1463
|
+
}, z.core.$strict>;
|
|
1464
|
+
}, z.core.$strip>], "rangeType">;
|
|
1465
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1466
|
+
chainStatus: z.ZodLiteral<"chain-backfill">;
|
|
1467
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1468
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
1469
|
+
startBlock: z.ZodObject<{
|
|
1470
|
+
timestamp: z.ZodInt;
|
|
1471
|
+
number: z.ZodInt;
|
|
1472
|
+
}, z.core.$strict>;
|
|
1473
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1474
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1475
|
+
startBlock: z.ZodObject<{
|
|
1476
|
+
timestamp: z.ZodInt;
|
|
1477
|
+
number: z.ZodInt;
|
|
1478
|
+
}, z.core.$strict>;
|
|
1479
|
+
endBlock: z.ZodObject<{
|
|
1480
|
+
timestamp: z.ZodInt;
|
|
1481
|
+
number: z.ZodInt;
|
|
1482
|
+
}, z.core.$strict>;
|
|
1483
|
+
}, z.core.$strip>], "rangeType">;
|
|
1484
|
+
latestIndexedBlock: z.ZodObject<{
|
|
1485
|
+
timestamp: z.ZodInt;
|
|
1486
|
+
number: z.ZodInt;
|
|
1487
|
+
}, z.core.$strict>;
|
|
1488
|
+
backfillEndBlock: z.ZodObject<{
|
|
1489
|
+
timestamp: z.ZodInt;
|
|
1490
|
+
number: z.ZodInt;
|
|
1491
|
+
}, z.core.$strict>;
|
|
1492
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1493
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
1494
|
+
config: z.ZodObject<{
|
|
1495
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1496
|
+
startBlock: z.ZodObject<{
|
|
1497
|
+
timestamp: z.ZodInt;
|
|
1498
|
+
number: z.ZodInt;
|
|
1499
|
+
}, z.core.$strict>;
|
|
1500
|
+
endBlock: z.ZodObject<{
|
|
1501
|
+
timestamp: z.ZodInt;
|
|
1502
|
+
number: z.ZodInt;
|
|
1503
|
+
}, z.core.$strict>;
|
|
1504
|
+
}, z.core.$strip>;
|
|
1505
|
+
latestIndexedBlock: z.ZodObject<{
|
|
1506
|
+
timestamp: z.ZodInt;
|
|
1507
|
+
number: z.ZodInt;
|
|
1508
|
+
}, z.core.$strict>;
|
|
1509
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
1510
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
1511
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1512
|
+
omnichainStatus: z.ZodLiteral<"omnichain-completed">;
|
|
1513
|
+
chains: z.ZodRecord<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodCoercedNumber<string>>, z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1514
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
1515
|
+
config: z.ZodObject<{
|
|
1516
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1517
|
+
startBlock: z.ZodObject<{
|
|
1518
|
+
timestamp: z.ZodInt;
|
|
1519
|
+
number: z.ZodInt;
|
|
1520
|
+
}, z.core.$strict>;
|
|
1521
|
+
endBlock: z.ZodObject<{
|
|
1522
|
+
timestamp: z.ZodInt;
|
|
1523
|
+
number: z.ZodInt;
|
|
1524
|
+
}, z.core.$strict>;
|
|
1525
|
+
}, z.core.$strip>;
|
|
1526
|
+
latestIndexedBlock: z.ZodObject<{
|
|
1527
|
+
timestamp: z.ZodInt;
|
|
1528
|
+
number: z.ZodInt;
|
|
1529
|
+
}, z.core.$strict>;
|
|
1530
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
1531
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
1532
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1533
|
+
omnichainStatus: z.ZodLiteral<"omnichain-following">;
|
|
1534
|
+
chains: z.ZodRecord<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodCoercedNumber<string>>, z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1535
|
+
chainStatus: z.ZodLiteral<"chain-queued">;
|
|
1536
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1537
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
1538
|
+
startBlock: z.ZodObject<{
|
|
1539
|
+
timestamp: z.ZodInt;
|
|
1540
|
+
number: z.ZodInt;
|
|
1541
|
+
}, z.core.$strict>;
|
|
1542
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1543
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1544
|
+
startBlock: z.ZodObject<{
|
|
1545
|
+
timestamp: z.ZodInt;
|
|
1546
|
+
number: z.ZodInt;
|
|
1547
|
+
}, z.core.$strict>;
|
|
1548
|
+
endBlock: z.ZodObject<{
|
|
1549
|
+
timestamp: z.ZodInt;
|
|
1550
|
+
number: z.ZodInt;
|
|
1551
|
+
}, z.core.$strict>;
|
|
1552
|
+
}, z.core.$strip>], "rangeType">;
|
|
1553
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1554
|
+
chainStatus: z.ZodLiteral<"chain-backfill">;
|
|
1555
|
+
config: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1556
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
1557
|
+
startBlock: z.ZodObject<{
|
|
1558
|
+
timestamp: z.ZodInt;
|
|
1559
|
+
number: z.ZodInt;
|
|
1560
|
+
}, z.core.$strict>;
|
|
1561
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1562
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1563
|
+
startBlock: z.ZodObject<{
|
|
1564
|
+
timestamp: z.ZodInt;
|
|
1565
|
+
number: z.ZodInt;
|
|
1566
|
+
}, z.core.$strict>;
|
|
1567
|
+
endBlock: z.ZodObject<{
|
|
1568
|
+
timestamp: z.ZodInt;
|
|
1569
|
+
number: z.ZodInt;
|
|
1570
|
+
}, z.core.$strict>;
|
|
1571
|
+
}, z.core.$strip>], "rangeType">;
|
|
1572
|
+
latestIndexedBlock: z.ZodObject<{
|
|
1573
|
+
timestamp: z.ZodInt;
|
|
1574
|
+
number: z.ZodInt;
|
|
1575
|
+
}, z.core.$strict>;
|
|
1576
|
+
backfillEndBlock: z.ZodObject<{
|
|
1577
|
+
timestamp: z.ZodInt;
|
|
1578
|
+
number: z.ZodInt;
|
|
1579
|
+
}, z.core.$strict>;
|
|
1580
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1581
|
+
chainStatus: z.ZodLiteral<"chain-following">;
|
|
1582
|
+
config: z.ZodObject<{
|
|
1583
|
+
rangeType: z.ZodLiteral<"left-bounded">;
|
|
1584
|
+
startBlock: z.ZodObject<{
|
|
1585
|
+
timestamp: z.ZodInt;
|
|
1586
|
+
number: z.ZodInt;
|
|
1587
|
+
}, z.core.$strict>;
|
|
1588
|
+
}, z.core.$strip>;
|
|
1589
|
+
latestIndexedBlock: z.ZodObject<{
|
|
1590
|
+
timestamp: z.ZodInt;
|
|
1591
|
+
number: z.ZodInt;
|
|
1592
|
+
}, z.core.$strict>;
|
|
1593
|
+
latestKnownBlock: z.ZodObject<{
|
|
1594
|
+
timestamp: z.ZodInt;
|
|
1595
|
+
number: z.ZodInt;
|
|
1596
|
+
}, z.core.$strict>;
|
|
1597
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1598
|
+
chainStatus: z.ZodLiteral<"chain-completed">;
|
|
1599
|
+
config: z.ZodObject<{
|
|
1600
|
+
rangeType: z.ZodLiteral<"bounded">;
|
|
1601
|
+
startBlock: z.ZodObject<{
|
|
1602
|
+
timestamp: z.ZodInt;
|
|
1603
|
+
number: z.ZodInt;
|
|
1604
|
+
}, z.core.$strict>;
|
|
1605
|
+
endBlock: z.ZodObject<{
|
|
1606
|
+
timestamp: z.ZodInt;
|
|
1607
|
+
number: z.ZodInt;
|
|
1608
|
+
}, z.core.$strict>;
|
|
1609
|
+
}, z.core.$strip>;
|
|
1610
|
+
latestIndexedBlock: z.ZodObject<{
|
|
1611
|
+
timestamp: z.ZodInt;
|
|
1612
|
+
number: z.ZodInt;
|
|
1613
|
+
}, z.core.$strict>;
|
|
1614
|
+
}, z.core.$strip>], "chainStatus">>;
|
|
1615
|
+
omnichainIndexingCursor: z.ZodInt;
|
|
1616
|
+
}, z.core.$strip>], "omnichainStatus">;
|
|
1617
|
+
}, z.core.$strip>;
|
|
1618
|
+
projectedAt: z.ZodInt;
|
|
1619
|
+
worstCaseDistance: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
1620
|
+
}, z.core.$strip>;
|
|
1621
|
+
stackInfo: z.ZodObject<{
|
|
1622
|
+
ensDb: z.ZodObject<{
|
|
1623
|
+
versionInfo: z.ZodObject<{
|
|
1624
|
+
postgresql: z.ZodString;
|
|
1625
|
+
}, z.core.$strip>;
|
|
1626
|
+
}, z.core.$strip>;
|
|
1627
|
+
ensIndexer: z.ZodObject<{
|
|
1628
|
+
ensIndexerSchemaName: z.ZodString;
|
|
1629
|
+
ensRainbowPublicConfig: z.ZodObject<{
|
|
1630
|
+
serverLabelSet: z.ZodObject<{
|
|
1631
|
+
labelSetId: z.ZodString;
|
|
1632
|
+
highestLabelSetVersion: z.ZodInt;
|
|
1633
|
+
}, z.core.$strip>;
|
|
1634
|
+
versionInfo: z.ZodObject<{
|
|
1635
|
+
ensRainbow: z.ZodString;
|
|
1636
|
+
}, z.core.$strip>;
|
|
1637
|
+
}, z.core.$strip>;
|
|
1638
|
+
indexedChainIds: z.ZodArray<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
1639
|
+
isSubgraphCompatible: z.ZodBoolean;
|
|
1640
|
+
clientLabelSet: z.ZodObject<{
|
|
1641
|
+
labelSetId: z.ZodString;
|
|
1642
|
+
labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
|
|
1643
|
+
}, z.core.$strip>;
|
|
1644
|
+
namespace: z.ZodEnum<{
|
|
1645
|
+
readonly Mainnet: "mainnet";
|
|
1646
|
+
readonly Sepolia: "sepolia";
|
|
1647
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
1648
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
1649
|
+
}>;
|
|
1650
|
+
plugins: z.ZodArray<z.ZodString>;
|
|
1651
|
+
versionInfo: z.ZodObject<{
|
|
1652
|
+
ponder: z.ZodString;
|
|
1653
|
+
ensDb: z.ZodString;
|
|
1654
|
+
ensIndexer: z.ZodString;
|
|
1655
|
+
ensNormalize: z.ZodString;
|
|
1656
|
+
}, z.core.$strip>;
|
|
1657
|
+
}, z.core.$strip>;
|
|
1658
|
+
ensRainbow: z.ZodObject<{
|
|
1659
|
+
serverLabelSet: z.ZodObject<{
|
|
1660
|
+
labelSetId: z.ZodString;
|
|
1661
|
+
highestLabelSetVersion: z.ZodInt;
|
|
1662
|
+
}, z.core.$strip>;
|
|
1663
|
+
versionInfo: z.ZodObject<{
|
|
1664
|
+
ensRainbow: z.ZodString;
|
|
1665
|
+
}, z.core.$strip>;
|
|
1666
|
+
}, z.core.$strip>;
|
|
1667
|
+
ensApi: z.ZodObject<{
|
|
1668
|
+
ensIndexerPublicConfig: z.ZodObject<{
|
|
1669
|
+
ensIndexerSchemaName: z.ZodString;
|
|
1670
|
+
ensRainbowPublicConfig: z.ZodObject<{
|
|
1671
|
+
serverLabelSet: z.ZodObject<{
|
|
1672
|
+
labelSetId: z.ZodString;
|
|
1673
|
+
highestLabelSetVersion: z.ZodInt;
|
|
1674
|
+
}, z.core.$strip>;
|
|
1675
|
+
versionInfo: z.ZodObject<{
|
|
1676
|
+
ensRainbow: z.ZodString;
|
|
1677
|
+
}, z.core.$strip>;
|
|
1678
|
+
}, z.core.$strip>;
|
|
1679
|
+
indexedChainIds: z.ZodArray<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
1680
|
+
isSubgraphCompatible: z.ZodBoolean;
|
|
1681
|
+
clientLabelSet: z.ZodObject<{
|
|
1682
|
+
labelSetId: z.ZodString;
|
|
1683
|
+
labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
|
|
1684
|
+
}, z.core.$strip>;
|
|
1685
|
+
namespace: z.ZodEnum<{
|
|
1686
|
+
readonly Mainnet: "mainnet";
|
|
1687
|
+
readonly Sepolia: "sepolia";
|
|
1688
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
1689
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
1690
|
+
}>;
|
|
1691
|
+
plugins: z.ZodArray<z.ZodString>;
|
|
1692
|
+
versionInfo: z.ZodObject<{
|
|
1693
|
+
ponder: z.ZodString;
|
|
1694
|
+
ensDb: z.ZodString;
|
|
1695
|
+
ensIndexer: z.ZodString;
|
|
1696
|
+
ensNormalize: z.ZodString;
|
|
1697
|
+
}, z.core.$strip>;
|
|
1698
|
+
}, z.core.$strip>;
|
|
1699
|
+
theGraphFallback: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1700
|
+
canFallback: z.ZodLiteral<true>;
|
|
1701
|
+
url: z.ZodString;
|
|
1702
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1703
|
+
canFallback: z.ZodLiteral<false>;
|
|
1704
|
+
reason: z.ZodEnum<{
|
|
1705
|
+
readonly NotSubgraphCompatible: "not-subgraph-compatible";
|
|
1706
|
+
readonly NoApiKey: "no-api-key";
|
|
1707
|
+
readonly NoSubgraphUrl: "no-subgraph-url";
|
|
1708
|
+
}>;
|
|
1709
|
+
}, z.core.$strict>], "canFallback">;
|
|
1710
|
+
versionInfo: z.ZodObject<{
|
|
1711
|
+
ensApi: z.ZodString;
|
|
1712
|
+
ensNormalize: z.ZodString;
|
|
1713
|
+
}, z.core.$strip>;
|
|
1714
|
+
}, z.core.$strip>;
|
|
1715
|
+
}, z.core.$strip>;
|
|
1716
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1717
|
+
responseCode: z.ZodLiteral<"error">;
|
|
1718
|
+
}, z.core.$strict>], "responseCode">;
|
|
1719
|
+
|
|
1720
|
+
/**
|
|
1721
|
+
* Example value for {@link SerializedNameTokensResponseOk}, for use in OpenAPI documentation.
|
|
1722
|
+
*
|
|
1723
|
+
* - domainId and tokenId correspond to "vitalik.eth"
|
|
1724
|
+
* - contract is the ENS BaseRegistrar (ERC-721) on Ethereum mainnet
|
|
1725
|
+
*/
|
|
1726
|
+
declare const nameTokensResponseOkExample: {
|
|
1727
|
+
responseCode: "ok";
|
|
1728
|
+
registeredNameTokens: {
|
|
1729
|
+
domainId: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835";
|
|
1730
|
+
name: InterpretedName;
|
|
1731
|
+
tokens: {
|
|
1732
|
+
token: {
|
|
1733
|
+
assetNamespace: "erc721";
|
|
1734
|
+
contract: {
|
|
1735
|
+
chainId: number;
|
|
1736
|
+
address: "0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85";
|
|
1737
|
+
};
|
|
1738
|
+
tokenId: string;
|
|
1739
|
+
};
|
|
1740
|
+
ownership: {
|
|
1741
|
+
ownershipType: "fully-onchain";
|
|
1742
|
+
owner: {
|
|
1743
|
+
chainId: number;
|
|
1744
|
+
address: "0x220866b1a2219f40e72f5c628b65d54268ca3a9d";
|
|
1745
|
+
};
|
|
1746
|
+
};
|
|
1747
|
+
mintStatus: "minted";
|
|
1748
|
+
}[];
|
|
1749
|
+
expiresAt: number;
|
|
1750
|
+
accurateAsOf: number;
|
|
1751
|
+
};
|
|
1752
|
+
};
|
|
1753
|
+
/**
|
|
1754
|
+
* Example value for {@link SerializedNameTokensResponseError} representing a 503 Service Unavailable
|
|
1755
|
+
* when the Name Tokens API prerequisites are not met, for use in OpenAPI documentation.
|
|
1756
|
+
*/
|
|
1757
|
+
declare const nameTokensServiceUnavailableExample: {
|
|
1758
|
+
responseCode: "error";
|
|
1759
|
+
errorCode: "unsupported-ensindexer-config";
|
|
1760
|
+
error: {
|
|
1761
|
+
message: string;
|
|
1762
|
+
details: string;
|
|
1763
|
+
};
|
|
1764
|
+
};
|
|
1765
|
+
/**
|
|
1766
|
+
* Example value for {@link NameTokensResponseErrorNameTokensNotIndexed} representing a 404 Not Found
|
|
1767
|
+
* when no name tokens are indexed for the requested name or domainId, for use in OpenAPI documentation.
|
|
1768
|
+
*/
|
|
1769
|
+
declare const nameTokensNotIndexedExample: {
|
|
1770
|
+
responseCode: "error";
|
|
1771
|
+
errorCode: "name-tokens-not-indexed";
|
|
1772
|
+
error: {
|
|
1773
|
+
message: string;
|
|
1774
|
+
details: string;
|
|
1775
|
+
};
|
|
1776
|
+
};
|
|
1777
|
+
|
|
1778
|
+
/**
|
|
1779
|
+
* Schema for {@link RegisteredNameTokens}.
|
|
1780
|
+
*/
|
|
1781
|
+
declare const makeRegisteredNameTokenSchema: <const SerializableType extends boolean>(valueLabel?: string, serializable?: SerializableType) => z.ZodObject<{
|
|
1782
|
+
domainId: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1783
|
+
name: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<enssdk.InterpretedName, string>>, z.ZodTransform<enssdk.InterpretedName, enssdk.InterpretedName>>;
|
|
1784
|
+
tokens: z.ZodArray<z.ZodObject<{
|
|
1785
|
+
token: z.ZodObject<{
|
|
1786
|
+
assetNamespace: z.ZodEnum<{
|
|
1787
|
+
readonly ERC721: "erc721";
|
|
1788
|
+
readonly ERC1155: "erc1155";
|
|
1789
|
+
}>;
|
|
1790
|
+
contract: z.ZodObject<{
|
|
1791
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1792
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1793
|
+
}, z.core.$strict>;
|
|
1794
|
+
tokenId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBigInt> | (SerializableType extends true ? z.ZodString : z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBigInt>);
|
|
1795
|
+
}, z.core.$strip>;
|
|
1796
|
+
ownership: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1797
|
+
ownershipType: z.ZodLiteral<"namewrapper">;
|
|
1798
|
+
owner: z.ZodObject<{
|
|
1799
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1800
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1801
|
+
}, z.core.$strict>;
|
|
1802
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1803
|
+
ownershipType: z.ZodLiteral<"fully-onchain">;
|
|
1804
|
+
owner: z.ZodObject<{
|
|
1805
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1806
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1807
|
+
}, z.core.$strict>;
|
|
1808
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1809
|
+
ownershipType: z.ZodLiteral<"burned">;
|
|
1810
|
+
owner: z.ZodObject<{
|
|
1811
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1812
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1813
|
+
}, z.core.$strict>;
|
|
1814
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1815
|
+
ownershipType: z.ZodLiteral<"unknown">;
|
|
1816
|
+
owner: z.ZodObject<{
|
|
1817
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1818
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1819
|
+
}, z.core.$strict>;
|
|
1820
|
+
}, z.core.$strip>], "ownershipType">;
|
|
1821
|
+
mintStatus: z.ZodEnum<{
|
|
1822
|
+
readonly Minted: "minted";
|
|
1823
|
+
readonly Burned: "burned";
|
|
1824
|
+
}>;
|
|
1825
|
+
}, z.core.$strip>>;
|
|
1826
|
+
expiresAt: z.ZodInt;
|
|
1827
|
+
accurateAsOf: z.ZodInt;
|
|
1828
|
+
}, z.core.$strip>;
|
|
1829
|
+
/**
|
|
1830
|
+
* Schema for {@link NameTokensResponseOk}
|
|
1831
|
+
*/
|
|
1832
|
+
declare const makeNameTokensResponseOkSchema: <const SerializableType extends boolean>(valueLabel?: string, serializable?: SerializableType) => z.ZodObject<{
|
|
1833
|
+
responseCode: z.ZodLiteral<"ok">;
|
|
1834
|
+
registeredNameTokens: z.ZodObject<{
|
|
1835
|
+
domainId: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1836
|
+
name: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<enssdk.InterpretedName, string>>, z.ZodTransform<enssdk.InterpretedName, enssdk.InterpretedName>>;
|
|
1837
|
+
tokens: z.ZodArray<z.ZodObject<{
|
|
1838
|
+
token: z.ZodObject<{
|
|
1839
|
+
assetNamespace: z.ZodEnum<{
|
|
1840
|
+
readonly ERC721: "erc721";
|
|
1841
|
+
readonly ERC1155: "erc1155";
|
|
1842
|
+
}>;
|
|
1843
|
+
contract: z.ZodObject<{
|
|
1844
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1845
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1846
|
+
}, z.core.$strict>;
|
|
1847
|
+
tokenId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBigInt> | (SerializableType extends true ? z.ZodString : z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBigInt>);
|
|
1848
|
+
}, z.core.$strip>;
|
|
1849
|
+
ownership: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1850
|
+
ownershipType: z.ZodLiteral<"namewrapper">;
|
|
1851
|
+
owner: z.ZodObject<{
|
|
1852
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1853
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1854
|
+
}, z.core.$strict>;
|
|
1855
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1856
|
+
ownershipType: z.ZodLiteral<"fully-onchain">;
|
|
1857
|
+
owner: z.ZodObject<{
|
|
1858
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1859
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1860
|
+
}, z.core.$strict>;
|
|
1861
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1862
|
+
ownershipType: z.ZodLiteral<"burned">;
|
|
1863
|
+
owner: z.ZodObject<{
|
|
1864
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1865
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1866
|
+
}, z.core.$strict>;
|
|
1867
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1868
|
+
ownershipType: z.ZodLiteral<"unknown">;
|
|
1869
|
+
owner: z.ZodObject<{
|
|
1870
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1871
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1872
|
+
}, z.core.$strict>;
|
|
1873
|
+
}, z.core.$strip>], "ownershipType">;
|
|
1874
|
+
mintStatus: z.ZodEnum<{
|
|
1875
|
+
readonly Minted: "minted";
|
|
1876
|
+
readonly Burned: "burned";
|
|
1877
|
+
}>;
|
|
1878
|
+
}, z.core.$strip>>;
|
|
1879
|
+
expiresAt: z.ZodInt;
|
|
1880
|
+
accurateAsOf: z.ZodInt;
|
|
1881
|
+
}, z.core.$strip>;
|
|
1882
|
+
}, z.core.$strict>;
|
|
1883
|
+
/**
|
|
1884
|
+
* Schema for {@link NameTokensResponseErrorNameTokensNotIndexed}
|
|
1885
|
+
*/
|
|
1886
|
+
declare const makeNameTokensResponseErrorNameTokensNotIndexedSchema: (_valueLabel?: string) => z.ZodObject<{
|
|
1887
|
+
responseCode: z.ZodLiteral<"error">;
|
|
1888
|
+
errorCode: z.ZodLiteral<"name-tokens-not-indexed">;
|
|
1889
|
+
error: z.ZodObject<{
|
|
1890
|
+
message: z.ZodString;
|
|
1891
|
+
details: z.ZodOptional<z.ZodUnknown>;
|
|
1892
|
+
}, z.core.$strip>;
|
|
1893
|
+
}, z.core.$strict>;
|
|
1894
|
+
/**
|
|
1895
|
+
* Schema for {@link NameTokensResponseErrorEnsIndexerConfigUnsupported}
|
|
1896
|
+
*/
|
|
1897
|
+
declare const makeNameTokensResponseErrorEnsIndexerConfigUnsupported: (_valueLabel?: string) => z.ZodObject<{
|
|
1898
|
+
responseCode: z.ZodLiteral<"error">;
|
|
1899
|
+
errorCode: z.ZodLiteral<"unsupported-ensindexer-config">;
|
|
1900
|
+
error: z.ZodObject<{
|
|
1901
|
+
message: z.ZodString;
|
|
1902
|
+
details: z.ZodOptional<z.ZodUnknown>;
|
|
1903
|
+
}, z.core.$strip>;
|
|
1904
|
+
}, z.core.$strict>;
|
|
1905
|
+
/**
|
|
1906
|
+
* Schema for {@link NameTokensResponseErrorIndexingStatusUnsupported}
|
|
1907
|
+
*/
|
|
1908
|
+
declare const makeNameTokensResponseErrorNameIndexingStatusUnsupported: (_valueLabel?: string) => z.ZodObject<{
|
|
1909
|
+
responseCode: z.ZodLiteral<"error">;
|
|
1910
|
+
errorCode: z.ZodLiteral<"unsupported-indexing-status">;
|
|
1911
|
+
error: z.ZodObject<{
|
|
1912
|
+
message: z.ZodString;
|
|
1913
|
+
details: z.ZodOptional<z.ZodUnknown>;
|
|
1914
|
+
}, z.core.$strip>;
|
|
1915
|
+
}, z.core.$strict>;
|
|
1916
|
+
/**
|
|
1917
|
+
* Schema for {@link NameTokensResponseError}
|
|
1918
|
+
*/
|
|
1919
|
+
declare const makeNameTokensResponseErrorSchema: (valueLabel?: string) => z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1920
|
+
responseCode: z.ZodLiteral<"error">;
|
|
1921
|
+
errorCode: z.ZodLiteral<"name-tokens-not-indexed">;
|
|
1922
|
+
error: z.ZodObject<{
|
|
1923
|
+
message: z.ZodString;
|
|
1924
|
+
details: z.ZodOptional<z.ZodUnknown>;
|
|
1925
|
+
}, z.core.$strip>;
|
|
1926
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1927
|
+
responseCode: z.ZodLiteral<"error">;
|
|
1928
|
+
errorCode: z.ZodLiteral<"unsupported-ensindexer-config">;
|
|
1929
|
+
error: z.ZodObject<{
|
|
1930
|
+
message: z.ZodString;
|
|
1931
|
+
details: z.ZodOptional<z.ZodUnknown>;
|
|
1932
|
+
}, z.core.$strip>;
|
|
1933
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1934
|
+
responseCode: z.ZodLiteral<"error">;
|
|
1935
|
+
errorCode: z.ZodLiteral<"unsupported-indexing-status">;
|
|
1936
|
+
error: z.ZodObject<{
|
|
1937
|
+
message: z.ZodString;
|
|
1938
|
+
details: z.ZodOptional<z.ZodUnknown>;
|
|
1939
|
+
}, z.core.$strip>;
|
|
1940
|
+
}, z.core.$strict>], "errorCode">;
|
|
1941
|
+
/**
|
|
1942
|
+
* Schema for {@link NameTokensResponse}
|
|
1943
|
+
*/
|
|
1944
|
+
declare const makeNameTokensResponseSchema: <const SerializableType extends boolean = false>(valueLabel?: string, serializable?: SerializableType) => z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1945
|
+
responseCode: z.ZodLiteral<"ok">;
|
|
1946
|
+
registeredNameTokens: z.ZodObject<{
|
|
1947
|
+
domainId: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1948
|
+
name: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<enssdk.InterpretedName, string>>, z.ZodTransform<enssdk.InterpretedName, enssdk.InterpretedName>>;
|
|
1949
|
+
tokens: z.ZodArray<z.ZodObject<{
|
|
1950
|
+
token: z.ZodObject<{
|
|
1951
|
+
assetNamespace: z.ZodEnum<{
|
|
1952
|
+
readonly ERC721: "erc721";
|
|
1953
|
+
readonly ERC1155: "erc1155";
|
|
1954
|
+
}>;
|
|
1955
|
+
contract: z.ZodObject<{
|
|
1956
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1957
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1958
|
+
}, z.core.$strict>;
|
|
1959
|
+
tokenId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBigInt> | (SerializableType extends true ? z.ZodString : z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBigInt>);
|
|
1960
|
+
}, z.core.$strip>;
|
|
1961
|
+
ownership: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1962
|
+
ownershipType: z.ZodLiteral<"namewrapper">;
|
|
1963
|
+
owner: z.ZodObject<{
|
|
1964
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1965
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1966
|
+
}, z.core.$strict>;
|
|
1967
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1968
|
+
ownershipType: z.ZodLiteral<"fully-onchain">;
|
|
1969
|
+
owner: z.ZodObject<{
|
|
1970
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1971
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1972
|
+
}, z.core.$strict>;
|
|
1973
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1974
|
+
ownershipType: z.ZodLiteral<"burned">;
|
|
1975
|
+
owner: z.ZodObject<{
|
|
1976
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1977
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1978
|
+
}, z.core.$strict>;
|
|
1979
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1980
|
+
ownershipType: z.ZodLiteral<"unknown">;
|
|
1981
|
+
owner: z.ZodObject<{
|
|
1982
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
1983
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
1984
|
+
}, z.core.$strict>;
|
|
1985
|
+
}, z.core.$strip>], "ownershipType">;
|
|
1986
|
+
mintStatus: z.ZodEnum<{
|
|
1987
|
+
readonly Minted: "minted";
|
|
1988
|
+
readonly Burned: "burned";
|
|
1989
|
+
}>;
|
|
1990
|
+
}, z.core.$strip>>;
|
|
1991
|
+
expiresAt: z.ZodInt;
|
|
1992
|
+
accurateAsOf: z.ZodInt;
|
|
1993
|
+
}, z.core.$strip>;
|
|
1994
|
+
}, z.core.$strict>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1995
|
+
responseCode: z.ZodLiteral<"error">;
|
|
1996
|
+
errorCode: z.ZodLiteral<"name-tokens-not-indexed">;
|
|
1997
|
+
error: z.ZodObject<{
|
|
1998
|
+
message: z.ZodString;
|
|
1999
|
+
details: z.ZodOptional<z.ZodUnknown>;
|
|
2000
|
+
}, z.core.$strip>;
|
|
2001
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
2002
|
+
responseCode: z.ZodLiteral<"error">;
|
|
2003
|
+
errorCode: z.ZodLiteral<"unsupported-ensindexer-config">;
|
|
2004
|
+
error: z.ZodObject<{
|
|
2005
|
+
message: z.ZodString;
|
|
2006
|
+
details: z.ZodOptional<z.ZodUnknown>;
|
|
2007
|
+
}, z.core.$strip>;
|
|
2008
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
2009
|
+
responseCode: z.ZodLiteral<"error">;
|
|
2010
|
+
errorCode: z.ZodLiteral<"unsupported-indexing-status">;
|
|
2011
|
+
error: z.ZodObject<{
|
|
2012
|
+
message: z.ZodString;
|
|
2013
|
+
details: z.ZodOptional<z.ZodUnknown>;
|
|
2014
|
+
}, z.core.$strip>;
|
|
2015
|
+
}, z.core.$strict>], "errorCode">], "responseCode">;
|
|
2016
|
+
|
|
2017
|
+
declare const realtimeResponseSchemaOk: z.ZodObject<{
|
|
2018
|
+
maxWorstCaseDistance: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
2019
|
+
slowestChainIndexingCursor: z.ZodInt;
|
|
2020
|
+
worstCaseDistance: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
2021
|
+
}, z.core.$strip>;
|
|
2022
|
+
declare const realtimeResponseSchemaError: z.ZodObject<{
|
|
2023
|
+
message: z.ZodString;
|
|
2024
|
+
details: z.ZodOptional<z.ZodUnknown>;
|
|
2025
|
+
}, z.core.$strip>;
|
|
2026
|
+
|
|
2027
|
+
/**
|
|
2028
|
+
* Example value for {@link SerializedRegistrarActionsResponseOk}, for use in OpenAPI documentation.
|
|
2029
|
+
*
|
|
2030
|
+
* - registrationLifecycle.node is namehash("vitalik.eth")
|
|
2031
|
+
* - subregistry.node is namehash("eth")
|
|
2032
|
+
* - subregistry.subregistryId is the ETH Registrar Controller on Ethereum mainnet
|
|
2033
|
+
*/
|
|
2034
|
+
declare const registrarActionsResponseOkExample: {
|
|
2035
|
+
responseCode: "ok";
|
|
2036
|
+
registrarActions: {
|
|
2037
|
+
action: {
|
|
2038
|
+
type: "registration";
|
|
2039
|
+
id: string;
|
|
2040
|
+
incrementalDuration: number;
|
|
2041
|
+
registrant: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045";
|
|
2042
|
+
registrationLifecycle: {
|
|
2043
|
+
subregistry: {
|
|
2044
|
+
subregistryId: {
|
|
2045
|
+
chainId: number;
|
|
2046
|
+
address: "0x253553366da8546fc250f225fe3d25d0c782303b";
|
|
2047
|
+
};
|
|
2048
|
+
node: "0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae";
|
|
2049
|
+
};
|
|
2050
|
+
node: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835";
|
|
2051
|
+
expiresAt: number;
|
|
2052
|
+
};
|
|
2053
|
+
pricing: {
|
|
2054
|
+
baseCost: {
|
|
2055
|
+
amount: string;
|
|
2056
|
+
currency: "ETH";
|
|
2057
|
+
};
|
|
2058
|
+
premium: {
|
|
2059
|
+
amount: string;
|
|
2060
|
+
currency: "ETH";
|
|
2061
|
+
};
|
|
2062
|
+
total: {
|
|
2063
|
+
amount: string;
|
|
2064
|
+
currency: "ETH";
|
|
2065
|
+
};
|
|
2066
|
+
};
|
|
2067
|
+
referral: {
|
|
2068
|
+
encodedReferrer: null;
|
|
2069
|
+
decodedReferrer: null;
|
|
2070
|
+
};
|
|
2071
|
+
block: {
|
|
2072
|
+
timestamp: number;
|
|
2073
|
+
number: number;
|
|
2074
|
+
};
|
|
2075
|
+
transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000001";
|
|
2076
|
+
eventIds: [string];
|
|
2077
|
+
};
|
|
2078
|
+
name: InterpretedName;
|
|
2079
|
+
}[];
|
|
2080
|
+
pageContext: {
|
|
2081
|
+
page: number;
|
|
2082
|
+
recordsPerPage: number;
|
|
2083
|
+
totalRecords: number;
|
|
2084
|
+
totalPages: number;
|
|
2085
|
+
hasNext: false;
|
|
2086
|
+
hasPrev: false;
|
|
2087
|
+
startIndex: number;
|
|
2088
|
+
endIndex: number;
|
|
2089
|
+
};
|
|
2090
|
+
accurateAsOf: number;
|
|
2091
|
+
};
|
|
2092
|
+
|
|
2093
|
+
/**
|
|
2094
|
+
* Schema for {@link NamedRegistrarAction}.
|
|
2095
|
+
*/
|
|
2096
|
+
declare const makeNamedRegistrarActionSchema: (valueLabel?: string) => z.ZodObject<{
|
|
2097
|
+
action: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2098
|
+
id: z.ZodString;
|
|
2099
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
2100
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2101
|
+
registrationLifecycle: z.ZodObject<{
|
|
2102
|
+
subregistry: z.ZodObject<{
|
|
2103
|
+
subregistryId: z.ZodObject<{
|
|
2104
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
2105
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2106
|
+
}, z.core.$strict>;
|
|
2107
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2108
|
+
}, z.core.$strip>;
|
|
2109
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2110
|
+
expiresAt: z.ZodInt;
|
|
2111
|
+
}, z.core.$strip>;
|
|
2112
|
+
pricing: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
|
|
2113
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
2114
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2115
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2116
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2117
|
+
amount: bigint;
|
|
2118
|
+
currency: CurrencyId;
|
|
2119
|
+
}>>;
|
|
2120
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
2121
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2122
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2123
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2124
|
+
amount: bigint;
|
|
2125
|
+
currency: CurrencyId;
|
|
2126
|
+
}>>;
|
|
2127
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
2128
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2129
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2130
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2131
|
+
amount: bigint;
|
|
2132
|
+
currency: CurrencyId;
|
|
2133
|
+
}>>;
|
|
2134
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingAvailable, {
|
|
2135
|
+
baseCost: PriceEth;
|
|
2136
|
+
premium: PriceEth;
|
|
2137
|
+
total: PriceEth;
|
|
2138
|
+
}>>, z.ZodPipe<z.ZodObject<{
|
|
2139
|
+
baseCost: z.ZodNull;
|
|
2140
|
+
premium: z.ZodNull;
|
|
2141
|
+
total: z.ZodNull;
|
|
2142
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingUnknown, {
|
|
2143
|
+
baseCost: null;
|
|
2144
|
+
premium: null;
|
|
2145
|
+
total: null;
|
|
2146
|
+
}>>]>;
|
|
2147
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
2148
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2149
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2150
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2151
|
+
encodedReferrer: z.ZodNull;
|
|
2152
|
+
decodedReferrer: z.ZodNull;
|
|
2153
|
+
}, z.core.$strip>]>;
|
|
2154
|
+
block: z.ZodObject<{
|
|
2155
|
+
timestamp: z.ZodInt;
|
|
2156
|
+
number: z.ZodInt;
|
|
2157
|
+
}, z.core.$strict>;
|
|
2158
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2159
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
2160
|
+
type: z.ZodLiteral<"registration">;
|
|
2161
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2162
|
+
id: z.ZodString;
|
|
2163
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
2164
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2165
|
+
registrationLifecycle: z.ZodObject<{
|
|
2166
|
+
subregistry: z.ZodObject<{
|
|
2167
|
+
subregistryId: z.ZodObject<{
|
|
2168
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
2169
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2170
|
+
}, z.core.$strict>;
|
|
2171
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2172
|
+
}, z.core.$strip>;
|
|
2173
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2174
|
+
expiresAt: z.ZodInt;
|
|
2175
|
+
}, z.core.$strip>;
|
|
2176
|
+
pricing: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
|
|
2177
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
2178
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2179
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2180
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2181
|
+
amount: bigint;
|
|
2182
|
+
currency: CurrencyId;
|
|
2183
|
+
}>>;
|
|
2184
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
2185
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2186
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2187
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2188
|
+
amount: bigint;
|
|
2189
|
+
currency: CurrencyId;
|
|
2190
|
+
}>>;
|
|
2191
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
2192
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2193
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2194
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2195
|
+
amount: bigint;
|
|
2196
|
+
currency: CurrencyId;
|
|
2197
|
+
}>>;
|
|
2198
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingAvailable, {
|
|
2199
|
+
baseCost: PriceEth;
|
|
2200
|
+
premium: PriceEth;
|
|
2201
|
+
total: PriceEth;
|
|
2202
|
+
}>>, z.ZodPipe<z.ZodObject<{
|
|
2203
|
+
baseCost: z.ZodNull;
|
|
2204
|
+
premium: z.ZodNull;
|
|
2205
|
+
total: z.ZodNull;
|
|
2206
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingUnknown, {
|
|
2207
|
+
baseCost: null;
|
|
2208
|
+
premium: null;
|
|
2209
|
+
total: null;
|
|
2210
|
+
}>>]>;
|
|
2211
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
2212
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2213
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2214
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2215
|
+
encodedReferrer: z.ZodNull;
|
|
2216
|
+
decodedReferrer: z.ZodNull;
|
|
2217
|
+
}, z.core.$strip>]>;
|
|
2218
|
+
block: z.ZodObject<{
|
|
2219
|
+
timestamp: z.ZodInt;
|
|
2220
|
+
number: z.ZodInt;
|
|
2221
|
+
}, z.core.$strict>;
|
|
2222
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2223
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
2224
|
+
type: z.ZodLiteral<"renewal">;
|
|
2225
|
+
}, z.core.$strip>], "type">;
|
|
2226
|
+
name: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<enssdk.InterpretedName, string>>, z.ZodTransform<enssdk.InterpretedName, enssdk.InterpretedName>>;
|
|
2227
|
+
}, z.core.$strip>;
|
|
2228
|
+
/**
|
|
2229
|
+
* Schema for {@link RegistrarActionsResponseOk}
|
|
2230
|
+
*/
|
|
2231
|
+
declare const makeRegistrarActionsResponseOkSchema: (valueLabel?: string) => z.ZodObject<{
|
|
2232
|
+
responseCode: z.ZodLiteral<"ok">;
|
|
2233
|
+
registrarActions: z.ZodArray<z.ZodObject<{
|
|
2234
|
+
action: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2235
|
+
id: z.ZodString;
|
|
2236
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
2237
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2238
|
+
registrationLifecycle: z.ZodObject<{
|
|
2239
|
+
subregistry: z.ZodObject<{
|
|
2240
|
+
subregistryId: z.ZodObject<{
|
|
2241
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
2242
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2243
|
+
}, z.core.$strict>;
|
|
2244
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2245
|
+
}, z.core.$strip>;
|
|
2246
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2247
|
+
expiresAt: z.ZodInt;
|
|
2248
|
+
}, z.core.$strip>;
|
|
2249
|
+
pricing: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
|
|
2250
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
2251
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2252
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2253
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2254
|
+
amount: bigint;
|
|
2255
|
+
currency: CurrencyId;
|
|
2256
|
+
}>>;
|
|
2257
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
2258
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2259
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2260
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2261
|
+
amount: bigint;
|
|
2262
|
+
currency: CurrencyId;
|
|
2263
|
+
}>>;
|
|
2264
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
2265
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2266
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2267
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2268
|
+
amount: bigint;
|
|
2269
|
+
currency: CurrencyId;
|
|
2270
|
+
}>>;
|
|
2271
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingAvailable, {
|
|
2272
|
+
baseCost: PriceEth;
|
|
2273
|
+
premium: PriceEth;
|
|
2274
|
+
total: PriceEth;
|
|
2275
|
+
}>>, z.ZodPipe<z.ZodObject<{
|
|
2276
|
+
baseCost: z.ZodNull;
|
|
2277
|
+
premium: z.ZodNull;
|
|
2278
|
+
total: z.ZodNull;
|
|
2279
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingUnknown, {
|
|
2280
|
+
baseCost: null;
|
|
2281
|
+
premium: null;
|
|
2282
|
+
total: null;
|
|
2283
|
+
}>>]>;
|
|
2284
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
2285
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2286
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2287
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2288
|
+
encodedReferrer: z.ZodNull;
|
|
2289
|
+
decodedReferrer: z.ZodNull;
|
|
2290
|
+
}, z.core.$strip>]>;
|
|
2291
|
+
block: z.ZodObject<{
|
|
2292
|
+
timestamp: z.ZodInt;
|
|
2293
|
+
number: z.ZodInt;
|
|
2294
|
+
}, z.core.$strict>;
|
|
2295
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2296
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
2297
|
+
type: z.ZodLiteral<"registration">;
|
|
2298
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2299
|
+
id: z.ZodString;
|
|
2300
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
2301
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2302
|
+
registrationLifecycle: z.ZodObject<{
|
|
2303
|
+
subregistry: z.ZodObject<{
|
|
2304
|
+
subregistryId: z.ZodObject<{
|
|
2305
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
2306
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2307
|
+
}, z.core.$strict>;
|
|
2308
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2309
|
+
}, z.core.$strip>;
|
|
2310
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2311
|
+
expiresAt: z.ZodInt;
|
|
2312
|
+
}, z.core.$strip>;
|
|
2313
|
+
pricing: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
|
|
2314
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
2315
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2316
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2317
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2318
|
+
amount: bigint;
|
|
2319
|
+
currency: CurrencyId;
|
|
2320
|
+
}>>;
|
|
2321
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
2322
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2323
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2324
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2325
|
+
amount: bigint;
|
|
2326
|
+
currency: CurrencyId;
|
|
2327
|
+
}>>;
|
|
2328
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
2329
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2330
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2331
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2332
|
+
amount: bigint;
|
|
2333
|
+
currency: CurrencyId;
|
|
2334
|
+
}>>;
|
|
2335
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingAvailable, {
|
|
2336
|
+
baseCost: PriceEth;
|
|
2337
|
+
premium: PriceEth;
|
|
2338
|
+
total: PriceEth;
|
|
2339
|
+
}>>, z.ZodPipe<z.ZodObject<{
|
|
2340
|
+
baseCost: z.ZodNull;
|
|
2341
|
+
premium: z.ZodNull;
|
|
2342
|
+
total: z.ZodNull;
|
|
2343
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingUnknown, {
|
|
2344
|
+
baseCost: null;
|
|
2345
|
+
premium: null;
|
|
2346
|
+
total: null;
|
|
2347
|
+
}>>]>;
|
|
2348
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
2349
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2350
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2351
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2352
|
+
encodedReferrer: z.ZodNull;
|
|
2353
|
+
decodedReferrer: z.ZodNull;
|
|
2354
|
+
}, z.core.$strip>]>;
|
|
2355
|
+
block: z.ZodObject<{
|
|
2356
|
+
timestamp: z.ZodInt;
|
|
2357
|
+
number: z.ZodInt;
|
|
2358
|
+
}, z.core.$strict>;
|
|
2359
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2360
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
2361
|
+
type: z.ZodLiteral<"renewal">;
|
|
2362
|
+
}, z.core.$strip>], "type">;
|
|
2363
|
+
name: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<enssdk.InterpretedName, string>>, z.ZodTransform<enssdk.InterpretedName, enssdk.InterpretedName>>;
|
|
2364
|
+
}, z.core.$strip>>;
|
|
2365
|
+
pageContext: z.ZodUnion<readonly [z.ZodObject<{
|
|
2366
|
+
totalRecords: z.ZodLiteral<0>;
|
|
2367
|
+
totalPages: z.ZodLiteral<1>;
|
|
2368
|
+
hasNext: z.ZodLiteral<false>;
|
|
2369
|
+
hasPrev: z.ZodLiteral<false>;
|
|
2370
|
+
page: z.ZodInt;
|
|
2371
|
+
recordsPerPage: z.ZodInt;
|
|
2372
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2373
|
+
totalRecords: z.ZodInt;
|
|
2374
|
+
totalPages: z.ZodInt;
|
|
2375
|
+
hasNext: z.ZodBoolean;
|
|
2376
|
+
hasPrev: z.ZodBoolean;
|
|
2377
|
+
startIndex: z.ZodInt;
|
|
2378
|
+
endIndex: z.ZodInt;
|
|
2379
|
+
page: z.ZodInt;
|
|
2380
|
+
recordsPerPage: z.ZodInt;
|
|
2381
|
+
}, z.core.$strip>]>;
|
|
2382
|
+
accurateAsOf: z.ZodInt;
|
|
2383
|
+
}, z.core.$strip>;
|
|
2384
|
+
/**
|
|
2385
|
+
* Schema for {@link RegistrarActionsResponseError}
|
|
2386
|
+
*/
|
|
2387
|
+
declare const makeRegistrarActionsResponseErrorSchema: (_valueLabel?: string) => z.ZodObject<{
|
|
2388
|
+
responseCode: z.ZodLiteral<"error">;
|
|
2389
|
+
error: z.ZodObject<{
|
|
2390
|
+
message: z.ZodString;
|
|
2391
|
+
details: z.ZodOptional<z.ZodUnknown>;
|
|
2392
|
+
}, z.core.$strip>;
|
|
2393
|
+
}, z.core.$strict>;
|
|
2394
|
+
/**
|
|
2395
|
+
* Schema for {@link RegistrarActionsResponse}
|
|
2396
|
+
*/
|
|
2397
|
+
declare const makeRegistrarActionsResponseSchema: (valueLabel?: string) => z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2398
|
+
responseCode: z.ZodLiteral<"ok">;
|
|
2399
|
+
registrarActions: z.ZodArray<z.ZodObject<{
|
|
2400
|
+
action: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2401
|
+
id: z.ZodString;
|
|
2402
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
2403
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2404
|
+
registrationLifecycle: z.ZodObject<{
|
|
2405
|
+
subregistry: z.ZodObject<{
|
|
2406
|
+
subregistryId: z.ZodObject<{
|
|
2407
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
2408
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2409
|
+
}, z.core.$strict>;
|
|
2410
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2411
|
+
}, z.core.$strip>;
|
|
2412
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2413
|
+
expiresAt: z.ZodInt;
|
|
2414
|
+
}, z.core.$strip>;
|
|
2415
|
+
pricing: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
|
|
2416
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
2417
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2418
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2419
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2420
|
+
amount: bigint;
|
|
2421
|
+
currency: CurrencyId;
|
|
2422
|
+
}>>;
|
|
2423
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
2424
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2425
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2426
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2427
|
+
amount: bigint;
|
|
2428
|
+
currency: CurrencyId;
|
|
2429
|
+
}>>;
|
|
2430
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
2431
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2432
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2433
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2434
|
+
amount: bigint;
|
|
2435
|
+
currency: CurrencyId;
|
|
2436
|
+
}>>;
|
|
2437
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingAvailable, {
|
|
2438
|
+
baseCost: PriceEth;
|
|
2439
|
+
premium: PriceEth;
|
|
2440
|
+
total: PriceEth;
|
|
2441
|
+
}>>, z.ZodPipe<z.ZodObject<{
|
|
2442
|
+
baseCost: z.ZodNull;
|
|
2443
|
+
premium: z.ZodNull;
|
|
2444
|
+
total: z.ZodNull;
|
|
2445
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingUnknown, {
|
|
2446
|
+
baseCost: null;
|
|
2447
|
+
premium: null;
|
|
2448
|
+
total: null;
|
|
2449
|
+
}>>]>;
|
|
2450
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
2451
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2452
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2453
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2454
|
+
encodedReferrer: z.ZodNull;
|
|
2455
|
+
decodedReferrer: z.ZodNull;
|
|
2456
|
+
}, z.core.$strip>]>;
|
|
2457
|
+
block: z.ZodObject<{
|
|
2458
|
+
timestamp: z.ZodInt;
|
|
2459
|
+
number: z.ZodInt;
|
|
2460
|
+
}, z.core.$strict>;
|
|
2461
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2462
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
2463
|
+
type: z.ZodLiteral<"registration">;
|
|
2464
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2465
|
+
id: z.ZodString;
|
|
2466
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
2467
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2468
|
+
registrationLifecycle: z.ZodObject<{
|
|
2469
|
+
subregistry: z.ZodObject<{
|
|
2470
|
+
subregistryId: z.ZodObject<{
|
|
2471
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
2472
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2473
|
+
}, z.core.$strict>;
|
|
2474
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2475
|
+
}, z.core.$strip>;
|
|
2476
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2477
|
+
expiresAt: z.ZodInt;
|
|
2478
|
+
}, z.core.$strip>;
|
|
2479
|
+
pricing: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
|
|
2480
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
2481
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2482
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2483
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2484
|
+
amount: bigint;
|
|
2485
|
+
currency: CurrencyId;
|
|
2486
|
+
}>>;
|
|
2487
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
2488
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2489
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2490
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2491
|
+
amount: bigint;
|
|
2492
|
+
currency: CurrencyId;
|
|
2493
|
+
}>>;
|
|
2494
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
2495
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2496
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2497
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2498
|
+
amount: bigint;
|
|
2499
|
+
currency: CurrencyId;
|
|
2500
|
+
}>>;
|
|
2501
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingAvailable, {
|
|
2502
|
+
baseCost: PriceEth;
|
|
2503
|
+
premium: PriceEth;
|
|
2504
|
+
total: PriceEth;
|
|
2505
|
+
}>>, z.ZodPipe<z.ZodObject<{
|
|
2506
|
+
baseCost: z.ZodNull;
|
|
2507
|
+
premium: z.ZodNull;
|
|
2508
|
+
total: z.ZodNull;
|
|
2509
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingUnknown, {
|
|
2510
|
+
baseCost: null;
|
|
2511
|
+
premium: null;
|
|
2512
|
+
total: null;
|
|
2513
|
+
}>>]>;
|
|
2514
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
2515
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2516
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2517
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2518
|
+
encodedReferrer: z.ZodNull;
|
|
2519
|
+
decodedReferrer: z.ZodNull;
|
|
2520
|
+
}, z.core.$strip>]>;
|
|
2521
|
+
block: z.ZodObject<{
|
|
2522
|
+
timestamp: z.ZodInt;
|
|
2523
|
+
number: z.ZodInt;
|
|
2524
|
+
}, z.core.$strict>;
|
|
2525
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2526
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
2527
|
+
type: z.ZodLiteral<"renewal">;
|
|
2528
|
+
}, z.core.$strip>], "type">;
|
|
2529
|
+
name: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<enssdk.InterpretedName, string>>, z.ZodTransform<enssdk.InterpretedName, enssdk.InterpretedName>>;
|
|
2530
|
+
}, z.core.$strip>>;
|
|
2531
|
+
pageContext: z.ZodUnion<readonly [z.ZodObject<{
|
|
2532
|
+
totalRecords: z.ZodLiteral<0>;
|
|
2533
|
+
totalPages: z.ZodLiteral<1>;
|
|
2534
|
+
hasNext: z.ZodLiteral<false>;
|
|
2535
|
+
hasPrev: z.ZodLiteral<false>;
|
|
2536
|
+
page: z.ZodInt;
|
|
2537
|
+
recordsPerPage: z.ZodInt;
|
|
2538
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2539
|
+
totalRecords: z.ZodInt;
|
|
2540
|
+
totalPages: z.ZodInt;
|
|
2541
|
+
hasNext: z.ZodBoolean;
|
|
2542
|
+
hasPrev: z.ZodBoolean;
|
|
2543
|
+
startIndex: z.ZodInt;
|
|
2544
|
+
endIndex: z.ZodInt;
|
|
2545
|
+
page: z.ZodInt;
|
|
2546
|
+
recordsPerPage: z.ZodInt;
|
|
2547
|
+
}, z.core.$strip>]>;
|
|
2548
|
+
accurateAsOf: z.ZodInt;
|
|
2549
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2550
|
+
responseCode: z.ZodLiteral<"error">;
|
|
2551
|
+
error: z.ZodObject<{
|
|
2552
|
+
message: z.ZodString;
|
|
2553
|
+
details: z.ZodOptional<z.ZodUnknown>;
|
|
2554
|
+
}, z.core.$strip>;
|
|
2555
|
+
}, z.core.$strict>], "responseCode">;
|
|
2556
|
+
/**
|
|
2557
|
+
* Schema for {@link SerializedRegistrarActionsResponseOk}
|
|
2558
|
+
*/
|
|
2559
|
+
declare const makeSerializedRegistrarActionsResponseOkSchema: (valueLabel?: string) => z.ZodObject<{
|
|
2560
|
+
responseCode: z.ZodLiteral<"ok">;
|
|
2561
|
+
registrarActions: z.ZodArray<z.ZodObject<{
|
|
2562
|
+
action: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2563
|
+
id: z.ZodString;
|
|
2564
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
2565
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2566
|
+
registrationLifecycle: z.ZodObject<{
|
|
2567
|
+
subregistry: z.ZodObject<{
|
|
2568
|
+
subregistryId: z.ZodObject<{
|
|
2569
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
2570
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2571
|
+
}, z.core.$strict>;
|
|
2572
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2573
|
+
}, z.core.$strip>;
|
|
2574
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2575
|
+
expiresAt: z.ZodInt;
|
|
2576
|
+
}, z.core.$strip>;
|
|
2577
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
2578
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2579
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2580
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2581
|
+
encodedReferrer: z.ZodNull;
|
|
2582
|
+
decodedReferrer: z.ZodNull;
|
|
2583
|
+
}, z.core.$strip>]>;
|
|
2584
|
+
block: z.ZodObject<{
|
|
2585
|
+
timestamp: z.ZodInt;
|
|
2586
|
+
number: z.ZodInt;
|
|
2587
|
+
}, z.core.$strict>;
|
|
2588
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2589
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
2590
|
+
pricing: z.ZodUnion<readonly [z.ZodObject<{
|
|
2591
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
2592
|
+
amount: z.ZodString;
|
|
2593
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2594
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
2595
|
+
amount: string;
|
|
2596
|
+
currency: CurrencyId;
|
|
2597
|
+
}>>;
|
|
2598
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
2599
|
+
amount: z.ZodString;
|
|
2600
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2601
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
2602
|
+
amount: string;
|
|
2603
|
+
currency: CurrencyId;
|
|
2604
|
+
}>>;
|
|
2605
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
2606
|
+
amount: z.ZodString;
|
|
2607
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2608
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
2609
|
+
amount: string;
|
|
2610
|
+
currency: CurrencyId;
|
|
2611
|
+
}>>;
|
|
2612
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2613
|
+
baseCost: z.ZodNull;
|
|
2614
|
+
premium: z.ZodNull;
|
|
2615
|
+
total: z.ZodNull;
|
|
2616
|
+
}, z.core.$strip>]>;
|
|
2617
|
+
type: z.ZodLiteral<"registration">;
|
|
2618
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2619
|
+
id: z.ZodString;
|
|
2620
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
2621
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2622
|
+
registrationLifecycle: z.ZodObject<{
|
|
2623
|
+
subregistry: z.ZodObject<{
|
|
2624
|
+
subregistryId: z.ZodObject<{
|
|
2625
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
2626
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2627
|
+
}, z.core.$strict>;
|
|
2628
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2629
|
+
}, z.core.$strip>;
|
|
2630
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2631
|
+
expiresAt: z.ZodInt;
|
|
2632
|
+
}, z.core.$strip>;
|
|
2633
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
2634
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2635
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2636
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2637
|
+
encodedReferrer: z.ZodNull;
|
|
2638
|
+
decodedReferrer: z.ZodNull;
|
|
2639
|
+
}, z.core.$strip>]>;
|
|
2640
|
+
block: z.ZodObject<{
|
|
2641
|
+
timestamp: z.ZodInt;
|
|
2642
|
+
number: z.ZodInt;
|
|
2643
|
+
}, z.core.$strict>;
|
|
2644
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2645
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
2646
|
+
pricing: z.ZodUnion<readonly [z.ZodObject<{
|
|
2647
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
2648
|
+
amount: z.ZodString;
|
|
2649
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2650
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
2651
|
+
amount: string;
|
|
2652
|
+
currency: CurrencyId;
|
|
2653
|
+
}>>;
|
|
2654
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
2655
|
+
amount: z.ZodString;
|
|
2656
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2657
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
2658
|
+
amount: string;
|
|
2659
|
+
currency: CurrencyId;
|
|
2660
|
+
}>>;
|
|
2661
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
2662
|
+
amount: z.ZodString;
|
|
2663
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2664
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
2665
|
+
amount: string;
|
|
2666
|
+
currency: CurrencyId;
|
|
2667
|
+
}>>;
|
|
2668
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2669
|
+
baseCost: z.ZodNull;
|
|
2670
|
+
premium: z.ZodNull;
|
|
2671
|
+
total: z.ZodNull;
|
|
2672
|
+
}, z.core.$strip>]>;
|
|
2673
|
+
type: z.ZodLiteral<"renewal">;
|
|
2674
|
+
}, z.core.$strip>], "type">;
|
|
2675
|
+
name: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<enssdk.InterpretedName, string>>, z.ZodTransform<enssdk.InterpretedName, enssdk.InterpretedName>>;
|
|
2676
|
+
}, z.core.$strip>>;
|
|
2677
|
+
pageContext: z.ZodUnion<readonly [z.ZodObject<{
|
|
2678
|
+
totalRecords: z.ZodLiteral<0>;
|
|
2679
|
+
totalPages: z.ZodLiteral<1>;
|
|
2680
|
+
hasNext: z.ZodLiteral<false>;
|
|
2681
|
+
hasPrev: z.ZodLiteral<false>;
|
|
2682
|
+
page: z.ZodInt;
|
|
2683
|
+
recordsPerPage: z.ZodInt;
|
|
2684
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2685
|
+
totalRecords: z.ZodInt;
|
|
2686
|
+
totalPages: z.ZodInt;
|
|
2687
|
+
hasNext: z.ZodBoolean;
|
|
2688
|
+
hasPrev: z.ZodBoolean;
|
|
2689
|
+
startIndex: z.ZodInt;
|
|
2690
|
+
endIndex: z.ZodInt;
|
|
2691
|
+
page: z.ZodInt;
|
|
2692
|
+
recordsPerPage: z.ZodInt;
|
|
2693
|
+
}, z.core.$strip>]>;
|
|
2694
|
+
accurateAsOf: z.ZodInt;
|
|
2695
|
+
}, z.core.$strip>;
|
|
2696
|
+
|
|
2697
|
+
/**
|
|
2698
|
+
* Example values for {@link ResolveRecordsResponse}, for use in OpenAPI documentation.
|
|
2699
|
+
*/
|
|
2700
|
+
declare const resolveRecordsResponseExample: {
|
|
2701
|
+
records: {
|
|
2702
|
+
addresses: {
|
|
2703
|
+
"60": string;
|
|
2704
|
+
};
|
|
2705
|
+
texts: {
|
|
2706
|
+
description: string;
|
|
2707
|
+
};
|
|
2708
|
+
};
|
|
2709
|
+
accelerationRequested: false;
|
|
2710
|
+
accelerationAttempted: false;
|
|
2711
|
+
};
|
|
2712
|
+
/**
|
|
2713
|
+
* Example values for {@link ResolvePrimaryNameResponse}, for use in OpenAPI documentation.
|
|
2714
|
+
*/
|
|
2715
|
+
declare const resolvePrimaryNameResponseExample: {
|
|
2716
|
+
name: string;
|
|
2717
|
+
accelerationRequested: false;
|
|
2718
|
+
accelerationAttempted: false;
|
|
2719
|
+
};
|
|
2720
|
+
/**
|
|
2721
|
+
* Example values for {@link ResolvePrimaryNamesResponse}, for use in OpenAPI documentation.
|
|
2722
|
+
*/
|
|
2723
|
+
declare const resolvePrimaryNamesResponseExample: {
|
|
2724
|
+
names: {
|
|
2725
|
+
"1": string;
|
|
2726
|
+
"10": null;
|
|
2727
|
+
"8453": string;
|
|
2728
|
+
"42161": null;
|
|
2729
|
+
"59144": null;
|
|
2730
|
+
"534352": null;
|
|
2731
|
+
};
|
|
2732
|
+
accelerationRequested: false;
|
|
2733
|
+
accelerationAttempted: false;
|
|
2734
|
+
};
|
|
2735
|
+
|
|
2736
|
+
/**
|
|
2737
|
+
* Schema for {@link ResolveRecordsResponse}
|
|
2738
|
+
*/
|
|
2739
|
+
declare const makeResolveRecordsResponseSchema: () => z.ZodObject<{
|
|
2740
|
+
records: z.ZodObject<{
|
|
2741
|
+
name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
2742
|
+
addresses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
|
|
2743
|
+
texts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
|
|
2744
|
+
contenthash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
2745
|
+
pubkey: z.ZodOptional<z.ZodNullable<z.ZodObject<{
|
|
2746
|
+
x: z.ZodString;
|
|
2747
|
+
y: z.ZodString;
|
|
2748
|
+
}, z.core.$strip>>>;
|
|
2749
|
+
dnszonehash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
2750
|
+
version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
|
|
2751
|
+
abi: z.ZodOptional<z.ZodNullable<z.ZodObject<{
|
|
2752
|
+
contentType: z.ZodString;
|
|
2753
|
+
data: z.ZodString;
|
|
2754
|
+
}, z.core.$strip>>>;
|
|
2755
|
+
interfaces: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
|
|
2756
|
+
}, z.core.$strip>;
|
|
2757
|
+
accelerationRequested: z.ZodBoolean;
|
|
2758
|
+
accelerationAttempted: z.ZodBoolean;
|
|
2759
|
+
trace: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
|
|
2760
|
+
}, z.core.$strip>;
|
|
2761
|
+
/**
|
|
2762
|
+
* Schema for {@link ResolvePrimaryNameResponse}
|
|
2763
|
+
*/
|
|
2764
|
+
declare const makeResolvePrimaryNameResponseSchema: () => z.ZodObject<{
|
|
2765
|
+
name: z.ZodNullable<z.ZodString>;
|
|
2766
|
+
accelerationRequested: z.ZodBoolean;
|
|
2767
|
+
accelerationAttempted: z.ZodBoolean;
|
|
2768
|
+
trace: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
|
|
2769
|
+
}, z.core.$strip>;
|
|
2770
|
+
/**
|
|
2771
|
+
* Schema for {@link ResolvePrimaryNamesResponse}
|
|
2772
|
+
*/
|
|
2773
|
+
declare const makeResolvePrimaryNamesResponseSchema: () => z.ZodObject<{
|
|
2774
|
+
names: z.ZodRecord<z.ZodNumber, z.ZodNullable<z.ZodString>>;
|
|
2775
|
+
accelerationRequested: z.ZodBoolean;
|
|
2776
|
+
accelerationAttempted: z.ZodBoolean;
|
|
2777
|
+
trace: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
|
|
2778
|
+
}, z.core.$strip>;
|
|
2779
|
+
|
|
2780
|
+
/**
|
|
2781
|
+
* Example value for {@link ErrorResponse} representing a 400 Bad Request, for use in OpenAPI documentation.
|
|
2782
|
+
*/
|
|
2783
|
+
declare const errorResponseBadRequestExample: {
|
|
2784
|
+
message: string;
|
|
2785
|
+
};
|
|
2786
|
+
/**
|
|
2787
|
+
* Example value for {@link ErrorResponse} representing a 400 Bad Request for an invalid ENS name,
|
|
2788
|
+
* for use in OpenAPI documentation.
|
|
2789
|
+
*/
|
|
2790
|
+
declare const errorResponseInvalidNameExample: {
|
|
2791
|
+
message: string;
|
|
2792
|
+
details: {
|
|
2793
|
+
errors: never[];
|
|
2794
|
+
properties: {
|
|
2795
|
+
name: {
|
|
2796
|
+
errors: string[];
|
|
2797
|
+
};
|
|
2798
|
+
};
|
|
2799
|
+
};
|
|
2800
|
+
};
|
|
2801
|
+
/**
|
|
2802
|
+
* Example value for {@link ErrorResponse} representing a 400 Bad Request for an invalid address,
|
|
2803
|
+
* for use in OpenAPI documentation.
|
|
2804
|
+
*/
|
|
2805
|
+
declare const errorResponseInvalidAddressExample: {
|
|
2806
|
+
message: string;
|
|
2807
|
+
details: {
|
|
2808
|
+
errors: never[];
|
|
2809
|
+
properties: {
|
|
2810
|
+
address: {
|
|
2811
|
+
errors: string[];
|
|
2812
|
+
};
|
|
2813
|
+
};
|
|
2814
|
+
};
|
|
2815
|
+
};
|
|
2816
|
+
/**
|
|
2817
|
+
* Example value for {@link ErrorResponse} representing a 500 Internal Server Error, for use in OpenAPI documentation.
|
|
2818
|
+
*/
|
|
2819
|
+
declare const errorResponseInternalServerErrorExample: {
|
|
2820
|
+
message: string;
|
|
2821
|
+
};
|
|
2822
|
+
|
|
2823
|
+
/**
|
|
2824
|
+
* Schema for {@link RequestPageParams}
|
|
2825
|
+
*/
|
|
2826
|
+
declare const makeRequestPageParamsSchema: (valueLabel?: string) => z.ZodObject<{
|
|
2827
|
+
page: z.ZodInt;
|
|
2828
|
+
recordsPerPage: z.ZodInt;
|
|
2829
|
+
}, z.core.$strip>;
|
|
2830
|
+
/**
|
|
2831
|
+
* Schema for {@link ResponsePageContextWithNoRecords}
|
|
2832
|
+
*/
|
|
2833
|
+
declare const makeResponsePageContextSchemaWithNoRecords: (valueLabel?: string) => z.ZodObject<{
|
|
2834
|
+
totalRecords: z.ZodLiteral<0>;
|
|
2835
|
+
totalPages: z.ZodLiteral<1>;
|
|
2836
|
+
hasNext: z.ZodLiteral<false>;
|
|
2837
|
+
hasPrev: z.ZodLiteral<false>;
|
|
2838
|
+
page: z.ZodInt;
|
|
2839
|
+
recordsPerPage: z.ZodInt;
|
|
2840
|
+
}, z.core.$strip>;
|
|
2841
|
+
/**
|
|
2842
|
+
* Schema for {@link ResponsePageContextWithRecords}
|
|
2843
|
+
*/
|
|
2844
|
+
declare const makeResponsePageContextSchemaWithRecords: (valueLabel?: string) => z.ZodObject<{
|
|
2845
|
+
totalRecords: z.ZodInt;
|
|
2846
|
+
totalPages: z.ZodInt;
|
|
2847
|
+
hasNext: z.ZodBoolean;
|
|
2848
|
+
hasPrev: z.ZodBoolean;
|
|
2849
|
+
startIndex: z.ZodInt;
|
|
2850
|
+
endIndex: z.ZodInt;
|
|
2851
|
+
page: z.ZodInt;
|
|
2852
|
+
recordsPerPage: z.ZodInt;
|
|
2853
|
+
}, z.core.$strip>;
|
|
2854
|
+
/**
|
|
2855
|
+
* Schema for {@link ResponsePageContext}
|
|
2856
|
+
*/
|
|
2857
|
+
declare const makeResponsePageContextSchema: (valueLabel?: string) => z.ZodUnion<readonly [z.ZodObject<{
|
|
2858
|
+
totalRecords: z.ZodLiteral<0>;
|
|
2859
|
+
totalPages: z.ZodLiteral<1>;
|
|
2860
|
+
hasNext: z.ZodLiteral<false>;
|
|
2861
|
+
hasPrev: z.ZodLiteral<false>;
|
|
2862
|
+
page: z.ZodInt;
|
|
2863
|
+
recordsPerPage: z.ZodInt;
|
|
2864
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2865
|
+
totalRecords: z.ZodInt;
|
|
2866
|
+
totalPages: z.ZodInt;
|
|
2867
|
+
hasNext: z.ZodBoolean;
|
|
2868
|
+
hasPrev: z.ZodBoolean;
|
|
2869
|
+
startIndex: z.ZodInt;
|
|
2870
|
+
endIndex: z.ZodInt;
|
|
2871
|
+
page: z.ZodInt;
|
|
2872
|
+
recordsPerPage: z.ZodInt;
|
|
2873
|
+
}, z.core.$strip>]>;
|
|
2874
|
+
|
|
2875
|
+
type GraphqlApiExampleQuery = {
|
|
2876
|
+
id: string;
|
|
2877
|
+
query: string;
|
|
2878
|
+
variables: NamespaceSpecificValue<Record<string, unknown>>;
|
|
2879
|
+
};
|
|
2880
|
+
declare function getGraphqlApiExampleQueryById(id: string): GraphqlApiExampleQuery;
|
|
2881
|
+
declare const GRAPHQL_API_EXAMPLE_QUERIES: GraphqlApiExampleQuery[];
|
|
2882
|
+
|
|
2883
|
+
/**
|
|
2884
|
+
* Schema for parsing objects into {@link RegistrationLifecycle}.
|
|
2885
|
+
*/
|
|
2886
|
+
declare const makeRegistrationLifecycleSchema: (valueLabel?: string) => z.ZodObject<{
|
|
2887
|
+
subregistry: z.ZodObject<{
|
|
2888
|
+
subregistryId: z.ZodObject<{
|
|
2889
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
2890
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2891
|
+
}, z.core.$strict>;
|
|
2892
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2893
|
+
}, z.core.$strip>;
|
|
2894
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2895
|
+
expiresAt: z.ZodInt;
|
|
2896
|
+
}, z.core.$strip>;
|
|
2897
|
+
/**
|
|
2898
|
+
* Schema for parsing objects into {@link SerializedRegistrarActionPricing}.
|
|
2899
|
+
*/
|
|
2900
|
+
declare const makeSerializedRegistrarActionPricingSchema: (valueLabel?: string) => z.ZodUnion<readonly [z.ZodObject<{
|
|
2901
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
2902
|
+
amount: z.ZodString;
|
|
2903
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2904
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
2905
|
+
amount: string;
|
|
2906
|
+
currency: CurrencyId;
|
|
2907
|
+
}>>;
|
|
2908
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
2909
|
+
amount: z.ZodString;
|
|
2910
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2911
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
2912
|
+
amount: string;
|
|
2913
|
+
currency: CurrencyId;
|
|
2914
|
+
}>>;
|
|
2915
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
2916
|
+
amount: z.ZodString;
|
|
2917
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2918
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
2919
|
+
amount: string;
|
|
2920
|
+
currency: CurrencyId;
|
|
2921
|
+
}>>;
|
|
2922
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2923
|
+
baseCost: z.ZodNull;
|
|
2924
|
+
premium: z.ZodNull;
|
|
2925
|
+
total: z.ZodNull;
|
|
2926
|
+
}, z.core.$strip>]>;
|
|
2927
|
+
declare const makeBaseRegistrarActionSchema: (valueLabel?: string) => z.ZodObject<{
|
|
2928
|
+
id: z.ZodString;
|
|
2929
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
2930
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2931
|
+
registrationLifecycle: z.ZodObject<{
|
|
2932
|
+
subregistry: z.ZodObject<{
|
|
2933
|
+
subregistryId: z.ZodObject<{
|
|
2934
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
2935
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2936
|
+
}, z.core.$strict>;
|
|
2937
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2938
|
+
}, z.core.$strip>;
|
|
2939
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2940
|
+
expiresAt: z.ZodInt;
|
|
2941
|
+
}, z.core.$strip>;
|
|
2942
|
+
pricing: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
|
|
2943
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
2944
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2945
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2946
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2947
|
+
amount: bigint;
|
|
2948
|
+
currency: CurrencyId;
|
|
2949
|
+
}>>;
|
|
2950
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
2951
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2952
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2953
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2954
|
+
amount: bigint;
|
|
2955
|
+
currency: CurrencyId;
|
|
2956
|
+
}>>;
|
|
2957
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
2958
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
2959
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
2960
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
2961
|
+
amount: bigint;
|
|
2962
|
+
currency: CurrencyId;
|
|
2963
|
+
}>>;
|
|
2964
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingAvailable, {
|
|
2965
|
+
baseCost: PriceEth;
|
|
2966
|
+
premium: PriceEth;
|
|
2967
|
+
total: PriceEth;
|
|
2968
|
+
}>>, z.ZodPipe<z.ZodObject<{
|
|
2969
|
+
baseCost: z.ZodNull;
|
|
2970
|
+
premium: z.ZodNull;
|
|
2971
|
+
total: z.ZodNull;
|
|
2972
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingUnknown, {
|
|
2973
|
+
baseCost: null;
|
|
2974
|
+
premium: null;
|
|
2975
|
+
total: null;
|
|
2976
|
+
}>>]>;
|
|
2977
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
2978
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2979
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2980
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
2981
|
+
encodedReferrer: z.ZodNull;
|
|
2982
|
+
decodedReferrer: z.ZodNull;
|
|
2983
|
+
}, z.core.$strip>]>;
|
|
2984
|
+
block: z.ZodObject<{
|
|
2985
|
+
timestamp: z.ZodInt;
|
|
2986
|
+
number: z.ZodInt;
|
|
2987
|
+
}, z.core.$strict>;
|
|
2988
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2989
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
2990
|
+
}, z.core.$strip>;
|
|
2991
|
+
declare const makeRegistrarActionRegistrationSchema: (valueLabel?: string) => z.ZodObject<{
|
|
2992
|
+
id: z.ZodString;
|
|
2993
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
2994
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
2995
|
+
registrationLifecycle: z.ZodObject<{
|
|
2996
|
+
subregistry: z.ZodObject<{
|
|
2997
|
+
subregistryId: z.ZodObject<{
|
|
2998
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
2999
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3000
|
+
}, z.core.$strict>;
|
|
3001
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3002
|
+
}, z.core.$strip>;
|
|
3003
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3004
|
+
expiresAt: z.ZodInt;
|
|
3005
|
+
}, z.core.$strip>;
|
|
3006
|
+
pricing: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
|
|
3007
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
3008
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3009
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3010
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
3011
|
+
amount: bigint;
|
|
3012
|
+
currency: CurrencyId;
|
|
3013
|
+
}>>;
|
|
3014
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
3015
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3016
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3017
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
3018
|
+
amount: bigint;
|
|
3019
|
+
currency: CurrencyId;
|
|
3020
|
+
}>>;
|
|
3021
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
3022
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3023
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3024
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
3025
|
+
amount: bigint;
|
|
3026
|
+
currency: CurrencyId;
|
|
3027
|
+
}>>;
|
|
3028
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingAvailable, {
|
|
3029
|
+
baseCost: PriceEth;
|
|
3030
|
+
premium: PriceEth;
|
|
3031
|
+
total: PriceEth;
|
|
3032
|
+
}>>, z.ZodPipe<z.ZodObject<{
|
|
3033
|
+
baseCost: z.ZodNull;
|
|
3034
|
+
premium: z.ZodNull;
|
|
3035
|
+
total: z.ZodNull;
|
|
3036
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingUnknown, {
|
|
3037
|
+
baseCost: null;
|
|
3038
|
+
premium: null;
|
|
3039
|
+
total: null;
|
|
3040
|
+
}>>]>;
|
|
3041
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
3042
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3043
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3044
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
3045
|
+
encodedReferrer: z.ZodNull;
|
|
3046
|
+
decodedReferrer: z.ZodNull;
|
|
3047
|
+
}, z.core.$strip>]>;
|
|
3048
|
+
block: z.ZodObject<{
|
|
3049
|
+
timestamp: z.ZodInt;
|
|
3050
|
+
number: z.ZodInt;
|
|
3051
|
+
}, z.core.$strict>;
|
|
3052
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3053
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
3054
|
+
type: z.ZodLiteral<"registration">;
|
|
3055
|
+
}, z.core.$strip>;
|
|
3056
|
+
declare const makeRegistrarActionRenewalSchema: (valueLabel?: string) => z.ZodObject<{
|
|
3057
|
+
id: z.ZodString;
|
|
3058
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
3059
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3060
|
+
registrationLifecycle: z.ZodObject<{
|
|
3061
|
+
subregistry: z.ZodObject<{
|
|
3062
|
+
subregistryId: z.ZodObject<{
|
|
3063
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
3064
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3065
|
+
}, z.core.$strict>;
|
|
3066
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3067
|
+
}, z.core.$strip>;
|
|
3068
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3069
|
+
expiresAt: z.ZodInt;
|
|
3070
|
+
}, z.core.$strip>;
|
|
3071
|
+
pricing: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
|
|
3072
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
3073
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3074
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3075
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
3076
|
+
amount: bigint;
|
|
3077
|
+
currency: CurrencyId;
|
|
3078
|
+
}>>;
|
|
3079
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
3080
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3081
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3082
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
3083
|
+
amount: bigint;
|
|
3084
|
+
currency: CurrencyId;
|
|
3085
|
+
}>>;
|
|
3086
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
3087
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3088
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3089
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
3090
|
+
amount: bigint;
|
|
3091
|
+
currency: CurrencyId;
|
|
3092
|
+
}>>;
|
|
3093
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingAvailable, {
|
|
3094
|
+
baseCost: PriceEth;
|
|
3095
|
+
premium: PriceEth;
|
|
3096
|
+
total: PriceEth;
|
|
3097
|
+
}>>, z.ZodPipe<z.ZodObject<{
|
|
3098
|
+
baseCost: z.ZodNull;
|
|
3099
|
+
premium: z.ZodNull;
|
|
3100
|
+
total: z.ZodNull;
|
|
3101
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingUnknown, {
|
|
3102
|
+
baseCost: null;
|
|
3103
|
+
premium: null;
|
|
3104
|
+
total: null;
|
|
3105
|
+
}>>]>;
|
|
3106
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
3107
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3108
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3109
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
3110
|
+
encodedReferrer: z.ZodNull;
|
|
3111
|
+
decodedReferrer: z.ZodNull;
|
|
3112
|
+
}, z.core.$strip>]>;
|
|
3113
|
+
block: z.ZodObject<{
|
|
3114
|
+
timestamp: z.ZodInt;
|
|
3115
|
+
number: z.ZodInt;
|
|
3116
|
+
}, z.core.$strict>;
|
|
3117
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3118
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
3119
|
+
type: z.ZodLiteral<"renewal">;
|
|
3120
|
+
}, z.core.$strip>;
|
|
3121
|
+
/**
|
|
3122
|
+
* Schema for {@link RegistrarAction}.
|
|
3123
|
+
*/
|
|
3124
|
+
declare const makeRegistrarActionSchema: (valueLabel?: string) => z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
3125
|
+
id: z.ZodString;
|
|
3126
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
3127
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3128
|
+
registrationLifecycle: z.ZodObject<{
|
|
3129
|
+
subregistry: z.ZodObject<{
|
|
3130
|
+
subregistryId: z.ZodObject<{
|
|
3131
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
3132
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3133
|
+
}, z.core.$strict>;
|
|
3134
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3135
|
+
}, z.core.$strip>;
|
|
3136
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3137
|
+
expiresAt: z.ZodInt;
|
|
3138
|
+
}, z.core.$strip>;
|
|
3139
|
+
pricing: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
|
|
3140
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
3141
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3142
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3143
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
3144
|
+
amount: bigint;
|
|
3145
|
+
currency: CurrencyId;
|
|
3146
|
+
}>>;
|
|
3147
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
3148
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3149
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3150
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
3151
|
+
amount: bigint;
|
|
3152
|
+
currency: CurrencyId;
|
|
3153
|
+
}>>;
|
|
3154
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
3155
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3156
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3157
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
3158
|
+
amount: bigint;
|
|
3159
|
+
currency: CurrencyId;
|
|
3160
|
+
}>>;
|
|
3161
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingAvailable, {
|
|
3162
|
+
baseCost: PriceEth;
|
|
3163
|
+
premium: PriceEth;
|
|
3164
|
+
total: PriceEth;
|
|
3165
|
+
}>>, z.ZodPipe<z.ZodObject<{
|
|
3166
|
+
baseCost: z.ZodNull;
|
|
3167
|
+
premium: z.ZodNull;
|
|
3168
|
+
total: z.ZodNull;
|
|
3169
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingUnknown, {
|
|
3170
|
+
baseCost: null;
|
|
3171
|
+
premium: null;
|
|
3172
|
+
total: null;
|
|
3173
|
+
}>>]>;
|
|
3174
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
3175
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3176
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3177
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
3178
|
+
encodedReferrer: z.ZodNull;
|
|
3179
|
+
decodedReferrer: z.ZodNull;
|
|
3180
|
+
}, z.core.$strip>]>;
|
|
3181
|
+
block: z.ZodObject<{
|
|
3182
|
+
timestamp: z.ZodInt;
|
|
3183
|
+
number: z.ZodInt;
|
|
3184
|
+
}, z.core.$strict>;
|
|
3185
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3186
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
3187
|
+
type: z.ZodLiteral<"registration">;
|
|
3188
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
3189
|
+
id: z.ZodString;
|
|
3190
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
3191
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3192
|
+
registrationLifecycle: z.ZodObject<{
|
|
3193
|
+
subregistry: z.ZodObject<{
|
|
3194
|
+
subregistryId: z.ZodObject<{
|
|
3195
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
3196
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3197
|
+
}, z.core.$strict>;
|
|
3198
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3199
|
+
}, z.core.$strip>;
|
|
3200
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3201
|
+
expiresAt: z.ZodInt;
|
|
3202
|
+
}, z.core.$strip>;
|
|
3203
|
+
pricing: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
|
|
3204
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
3205
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3206
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3207
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
3208
|
+
amount: bigint;
|
|
3209
|
+
currency: CurrencyId;
|
|
3210
|
+
}>>;
|
|
3211
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
3212
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3213
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3214
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
3215
|
+
amount: bigint;
|
|
3216
|
+
currency: CurrencyId;
|
|
3217
|
+
}>>;
|
|
3218
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
3219
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3220
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3221
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
3222
|
+
amount: bigint;
|
|
3223
|
+
currency: CurrencyId;
|
|
3224
|
+
}>>;
|
|
3225
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingAvailable, {
|
|
3226
|
+
baseCost: PriceEth;
|
|
3227
|
+
premium: PriceEth;
|
|
3228
|
+
total: PriceEth;
|
|
3229
|
+
}>>, z.ZodPipe<z.ZodObject<{
|
|
3230
|
+
baseCost: z.ZodNull;
|
|
3231
|
+
premium: z.ZodNull;
|
|
3232
|
+
total: z.ZodNull;
|
|
3233
|
+
}, z.core.$strip>, z.ZodTransform<RegistrarActionPricingUnknown, {
|
|
3234
|
+
baseCost: null;
|
|
3235
|
+
premium: null;
|
|
3236
|
+
total: null;
|
|
3237
|
+
}>>]>;
|
|
3238
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
3239
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3240
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3241
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
3242
|
+
encodedReferrer: z.ZodNull;
|
|
3243
|
+
decodedReferrer: z.ZodNull;
|
|
3244
|
+
}, z.core.$strip>]>;
|
|
3245
|
+
block: z.ZodObject<{
|
|
3246
|
+
timestamp: z.ZodInt;
|
|
3247
|
+
number: z.ZodInt;
|
|
3248
|
+
}, z.core.$strict>;
|
|
3249
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3250
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
3251
|
+
type: z.ZodLiteral<"renewal">;
|
|
3252
|
+
}, z.core.$strip>], "type">;
|
|
3253
|
+
/**
|
|
3254
|
+
* Schema for {@link SerializedRegistrarAction}
|
|
3255
|
+
*/
|
|
3256
|
+
declare const makeSerializedRegistrarActionSchema: (valueLabel?: string) => z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
3257
|
+
id: z.ZodString;
|
|
3258
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
3259
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3260
|
+
registrationLifecycle: z.ZodObject<{
|
|
3261
|
+
subregistry: z.ZodObject<{
|
|
3262
|
+
subregistryId: z.ZodObject<{
|
|
3263
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
3264
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3265
|
+
}, z.core.$strict>;
|
|
3266
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3267
|
+
}, z.core.$strip>;
|
|
3268
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3269
|
+
expiresAt: z.ZodInt;
|
|
3270
|
+
}, z.core.$strip>;
|
|
3271
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
3272
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3273
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3274
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
3275
|
+
encodedReferrer: z.ZodNull;
|
|
3276
|
+
decodedReferrer: z.ZodNull;
|
|
3277
|
+
}, z.core.$strip>]>;
|
|
3278
|
+
block: z.ZodObject<{
|
|
3279
|
+
timestamp: z.ZodInt;
|
|
3280
|
+
number: z.ZodInt;
|
|
3281
|
+
}, z.core.$strict>;
|
|
3282
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3283
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
3284
|
+
pricing: z.ZodUnion<readonly [z.ZodObject<{
|
|
3285
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
3286
|
+
amount: z.ZodString;
|
|
3287
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3288
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
3289
|
+
amount: string;
|
|
3290
|
+
currency: CurrencyId;
|
|
3291
|
+
}>>;
|
|
3292
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
3293
|
+
amount: z.ZodString;
|
|
3294
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3295
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
3296
|
+
amount: string;
|
|
3297
|
+
currency: CurrencyId;
|
|
3298
|
+
}>>;
|
|
3299
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
3300
|
+
amount: z.ZodString;
|
|
3301
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3302
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
3303
|
+
amount: string;
|
|
3304
|
+
currency: CurrencyId;
|
|
3305
|
+
}>>;
|
|
3306
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
3307
|
+
baseCost: z.ZodNull;
|
|
3308
|
+
premium: z.ZodNull;
|
|
3309
|
+
total: z.ZodNull;
|
|
3310
|
+
}, z.core.$strip>]>;
|
|
3311
|
+
type: z.ZodLiteral<"registration">;
|
|
3312
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
3313
|
+
id: z.ZodString;
|
|
3314
|
+
incrementalDuration: z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
3315
|
+
registrant: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3316
|
+
registrationLifecycle: z.ZodObject<{
|
|
3317
|
+
subregistry: z.ZodObject<{
|
|
3318
|
+
subregistryId: z.ZodObject<{
|
|
3319
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
3320
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3321
|
+
}, z.core.$strict>;
|
|
3322
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3323
|
+
}, z.core.$strip>;
|
|
3324
|
+
node: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3325
|
+
expiresAt: z.ZodInt;
|
|
3326
|
+
}, z.core.$strip>;
|
|
3327
|
+
referral: z.ZodUnion<readonly [z.ZodObject<{
|
|
3328
|
+
encodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3329
|
+
decodedReferrer: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3330
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
3331
|
+
encodedReferrer: z.ZodNull;
|
|
3332
|
+
decodedReferrer: z.ZodNull;
|
|
3333
|
+
}, z.core.$strip>]>;
|
|
3334
|
+
block: z.ZodObject<{
|
|
3335
|
+
timestamp: z.ZodInt;
|
|
3336
|
+
number: z.ZodInt;
|
|
3337
|
+
}, z.core.$strict>;
|
|
3338
|
+
transactionHash: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3339
|
+
eventIds: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<[string, ...string[]], string[]>>;
|
|
3340
|
+
pricing: z.ZodUnion<readonly [z.ZodObject<{
|
|
3341
|
+
baseCost: z.ZodPipe<z.ZodObject<{
|
|
3342
|
+
amount: z.ZodString;
|
|
3343
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3344
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
3345
|
+
amount: string;
|
|
3346
|
+
currency: CurrencyId;
|
|
3347
|
+
}>>;
|
|
3348
|
+
premium: z.ZodPipe<z.ZodObject<{
|
|
3349
|
+
amount: z.ZodString;
|
|
3350
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3351
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
3352
|
+
amount: string;
|
|
3353
|
+
currency: CurrencyId;
|
|
3354
|
+
}>>;
|
|
3355
|
+
total: z.ZodPipe<z.ZodObject<{
|
|
3356
|
+
amount: z.ZodString;
|
|
3357
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3358
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
3359
|
+
amount: string;
|
|
3360
|
+
currency: CurrencyId;
|
|
3361
|
+
}>>;
|
|
3362
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
3363
|
+
baseCost: z.ZodNull;
|
|
3364
|
+
premium: z.ZodNull;
|
|
3365
|
+
total: z.ZodNull;
|
|
3366
|
+
}, z.core.$strip>]>;
|
|
3367
|
+
type: z.ZodLiteral<"renewal">;
|
|
3368
|
+
}, z.core.$strip>], "type">;
|
|
3369
|
+
|
|
3370
|
+
/**
|
|
3371
|
+
* EIP-165 ABI
|
|
3372
|
+
* @see https://eips.ethereum.org/EIPS/eip-165
|
|
3373
|
+
*/
|
|
3374
|
+
declare const EIP_165_ABI: readonly [{
|
|
3375
|
+
readonly inputs: readonly [{
|
|
3376
|
+
readonly internalType: "bytes4";
|
|
3377
|
+
readonly name: "interfaceID";
|
|
3378
|
+
readonly type: "bytes4";
|
|
3379
|
+
}];
|
|
3380
|
+
readonly name: "supportsInterface";
|
|
3381
|
+
readonly outputs: readonly [{
|
|
3382
|
+
readonly internalType: "bool";
|
|
3383
|
+
readonly name: "";
|
|
3384
|
+
readonly type: "bool";
|
|
3385
|
+
}];
|
|
3386
|
+
readonly stateMutability: "view";
|
|
3387
|
+
readonly type: "function";
|
|
3388
|
+
}];
|
|
3389
|
+
/**
|
|
3390
|
+
* Determines whether a Contract at `address` supports a specific EIP-165 `interfaceId`.
|
|
3391
|
+
*
|
|
3392
|
+
* Accepts both viem PublicClient and Ponder Context client types.
|
|
3393
|
+
*/
|
|
3394
|
+
declare function supportsInterface<TClient extends {
|
|
3395
|
+
readContract: (params: {
|
|
3396
|
+
abi: typeof EIP_165_ABI;
|
|
3397
|
+
functionName: "supportsInterface";
|
|
3398
|
+
address: Address;
|
|
3399
|
+
args: readonly [InterfaceId];
|
|
3400
|
+
}) => Promise<boolean>;
|
|
3401
|
+
}>({ publicClient, interfaceId: selector, address, }: {
|
|
3402
|
+
address: Address;
|
|
3403
|
+
interfaceId: InterfaceId;
|
|
3404
|
+
publicClient: TClient;
|
|
3405
|
+
}): Promise<boolean>;
|
|
3406
|
+
declare const makeSupportsInterfaceReader: (interfaceId: InterfaceId) => (args: Omit<Parameters<typeof supportsInterface>[0], "interfaceId">) => Promise<boolean>;
|
|
3407
|
+
|
|
3408
|
+
/**
|
|
3409
|
+
* Determines whether a Resolver contract supports ENSIP-10.
|
|
3410
|
+
*/
|
|
3411
|
+
declare const isExtendedResolver: (args: Omit<Parameters<(<TClient extends {
|
|
3412
|
+
readContract: (params: {
|
|
3413
|
+
abi: readonly [{
|
|
3414
|
+
readonly inputs: readonly [{
|
|
3415
|
+
readonly internalType: "bytes4";
|
|
3416
|
+
readonly name: "interfaceID";
|
|
3417
|
+
readonly type: "bytes4";
|
|
3418
|
+
}];
|
|
3419
|
+
readonly name: "supportsInterface";
|
|
3420
|
+
readonly outputs: readonly [{
|
|
3421
|
+
readonly internalType: "bool";
|
|
3422
|
+
readonly name: "";
|
|
3423
|
+
readonly type: "bool";
|
|
3424
|
+
}];
|
|
3425
|
+
readonly stateMutability: "view";
|
|
3426
|
+
readonly type: "function";
|
|
3427
|
+
}];
|
|
3428
|
+
functionName: "supportsInterface";
|
|
3429
|
+
address: enssdk.Address;
|
|
3430
|
+
args: readonly [enssdk.InterfaceId];
|
|
3431
|
+
}) => Promise<boolean>;
|
|
3432
|
+
}>({ publicClient, interfaceId: selector, address, }: {
|
|
3433
|
+
address: enssdk.Address;
|
|
3434
|
+
interfaceId: enssdk.InterfaceId;
|
|
3435
|
+
publicClient: TClient;
|
|
3436
|
+
}) => Promise<boolean>)>[0], "interfaceId">) => Promise<boolean>;
|
|
3437
|
+
|
|
3438
|
+
/**
|
|
3439
|
+
* Builds a Alchemy RPC base URL for the specified chain ID.
|
|
3440
|
+
*
|
|
3441
|
+
* @param chainId - The chain ID to build the RPC base URL for
|
|
3442
|
+
* @param key - The Alchemy API key
|
|
3443
|
+
* @returns The Alchemy RPC base URL, or undefined if the chain is not supported
|
|
3444
|
+
*
|
|
3445
|
+
* @example
|
|
3446
|
+
* ```typescript
|
|
3447
|
+
* const url = buildAlchemyUrl(1, "your-api-key");
|
|
3448
|
+
* // Returns: "eth-mainnet.g.alchemy.com/v2/your-api-key"
|
|
3449
|
+
* ```
|
|
3450
|
+
*/
|
|
3451
|
+
declare function buildAlchemyBaseUrl(chainId: ChainId, key: string): string | undefined;
|
|
3452
|
+
/**
|
|
3453
|
+
* Builds a dRPC RPC URL for the specified chain ID.
|
|
3454
|
+
*
|
|
3455
|
+
* @param chainId - The chain ID to build the RPC URL for
|
|
3456
|
+
* @param key - The dRPC API key
|
|
3457
|
+
* @returns The complete dRPC RPC URL, or undefined if the chain is not supported
|
|
3458
|
+
*
|
|
3459
|
+
* @example
|
|
3460
|
+
* ```typescript
|
|
3461
|
+
* const url = buildDRPCUrl(1, "your-api-key");
|
|
3462
|
+
* // Returns: "https://lb.drpc.live/ethereum/your-api-key"
|
|
3463
|
+
* ```
|
|
3464
|
+
*/
|
|
3465
|
+
declare function buildDRPCUrl(chainId: ChainId, key: string): string | undefined;
|
|
3466
|
+
/**
|
|
3467
|
+
* Builds a QuickNode RPC base URL for the specified chain ID.
|
|
3468
|
+
*
|
|
3469
|
+
* @param chainId - The chain ID to build the RPC base URL for
|
|
3470
|
+
* @param apiKey - The QuickNode API key
|
|
3471
|
+
* @param endpointName - The QuickNode Endpoint name
|
|
3472
|
+
* @returns The QuickNode RPC base URL, or undefined if the chain is not supported
|
|
3473
|
+
*
|
|
3474
|
+
* NOTE:
|
|
3475
|
+
* - Only multi-chain QuickNode endpoints are supported.
|
|
3476
|
+
* https://www.quicknode.com/guides/quicknode-products/how-to-use-multichain-endpoint
|
|
3477
|
+
* - QuickNode platform does not support Linea Sepolia RPC (as of 2025-12-03).
|
|
3478
|
+
* https://www.quicknode.com/docs/linea
|
|
3479
|
+
*
|
|
3480
|
+
* @example
|
|
3481
|
+
* ```typescript
|
|
3482
|
+
* const url = buildQuickNodeURL(1, "your-api-key", "your-endpoint-name");
|
|
3483
|
+
* // Returns: "your-endpoint-name.quiknode.pro/your-api-key"
|
|
3484
|
+
* ```
|
|
3485
|
+
*/
|
|
3486
|
+
declare function buildQuickNodeURL(chainId: ChainId, apiKey: string, endpointName: string): string | undefined;
|
|
3487
|
+
declare function alchemySupportsChain(chainId: ChainId): boolean;
|
|
3488
|
+
declare function dRPCSupportsChain(chainId: ChainId): boolean;
|
|
3489
|
+
declare function quickNodeSupportsChain(chainId: ChainId): boolean;
|
|
3490
|
+
|
|
3491
|
+
/**
|
|
3492
|
+
* Environment variables for ENSDb configuration.
|
|
3493
|
+
*/
|
|
3494
|
+
interface EnsDbEnvironment {
|
|
3495
|
+
ENSDB_URL?: string;
|
|
3496
|
+
ENSINDEXER_SCHEMA_NAME?: string;
|
|
3497
|
+
}
|
|
3498
|
+
/**
|
|
3499
|
+
* Environment variables for RPC configuration.
|
|
3500
|
+
*/
|
|
3501
|
+
interface RpcEnvironment {
|
|
3502
|
+
[x: `RPC_URL_${number}`]: ChainIdSpecificRpcEnvironmentVariable | undefined;
|
|
3503
|
+
ALCHEMY_API_KEY?: string;
|
|
3504
|
+
QUICKNODE_API_KEY?: string;
|
|
3505
|
+
QUICKNODE_ENDPOINT_NAME?: string;
|
|
3506
|
+
DRPC_API_KEY?: string;
|
|
3507
|
+
RPC_AUTO_GEN_MODE?: string;
|
|
3508
|
+
}
|
|
3509
|
+
/**
|
|
3510
|
+
* Environment variables for port configuration.
|
|
3511
|
+
*/
|
|
3512
|
+
interface PortEnvironment {
|
|
3513
|
+
PORT?: string;
|
|
3514
|
+
}
|
|
3515
|
+
/**
|
|
3516
|
+
* Represents the raw unvalidated environment variable for the RPCs associated with a chain.
|
|
3517
|
+
*
|
|
3518
|
+
* May contain a comma separated list of one or more URLs.
|
|
3519
|
+
*/
|
|
3520
|
+
type ChainIdSpecificRpcEnvironmentVariable = string;
|
|
3521
|
+
/**
|
|
3522
|
+
* Environment variables for log level configuration.
|
|
3523
|
+
*/
|
|
3524
|
+
type LogLevelEnvironment = {
|
|
3525
|
+
LOG_LEVEL?: string;
|
|
3526
|
+
};
|
|
3527
|
+
/**
|
|
3528
|
+
* Environment variables for communicating with The Graph.
|
|
3529
|
+
*/
|
|
3530
|
+
type TheGraphEnvironment = {
|
|
3531
|
+
THEGRAPH_API_KEY?: string;
|
|
3532
|
+
};
|
|
3533
|
+
/**
|
|
3534
|
+
* Environment variables for referral program editions configuration.
|
|
3535
|
+
*
|
|
3536
|
+
* If REFERRAL_PROGRAM_EDITIONS is set, it should be a URL that returns
|
|
3537
|
+
* the JSON for a valid serialized referral program editions definition.
|
|
3538
|
+
*/
|
|
3539
|
+
interface ReferralProgramEditionsEnvironment {
|
|
3540
|
+
/**
|
|
3541
|
+
* Optional URL that returns the JSON for a valid serialized referral program editions definition.
|
|
3542
|
+
* If not set, ENSApi treats the referral program as having zero configured editions and
|
|
3543
|
+
* performs no referral-related work against ENSDb.
|
|
3544
|
+
*/
|
|
3545
|
+
REFERRAL_PROGRAM_EDITIONS?: string;
|
|
3546
|
+
}
|
|
3547
|
+
|
|
3548
|
+
/**
|
|
3549
|
+
* Stringify a config object.
|
|
3550
|
+
*
|
|
3551
|
+
* @param json The config object to print
|
|
3552
|
+
* @param options.pretty Whether to pretty print the JSON output. Defaults to false (minified).
|
|
3553
|
+
* @returns The JSON string representation of the config object
|
|
3554
|
+
*/
|
|
3555
|
+
declare const stringifyConfig: (json: any, options?: {
|
|
3556
|
+
pretty: boolean;
|
|
3557
|
+
}) => string;
|
|
3558
|
+
|
|
3559
|
+
declare const RpcConfigsSchema: z.ZodPipe<z.ZodRecord<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodCoercedNumber<string>>, z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>, z.ZodArray<z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>>>>, z.ZodTransform<Map<number, RpcConfig>, Record<number, URL[]>>>;
|
|
3560
|
+
declare const ENSNamespaceSchema: z.ZodEnum<{
|
|
3561
|
+
readonly Mainnet: "mainnet";
|
|
3562
|
+
readonly Sepolia: "sepolia";
|
|
3563
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
3564
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
3565
|
+
}>;
|
|
3566
|
+
declare const PortNumberSchema: z.ZodCoercedNumber<unknown>;
|
|
3567
|
+
declare const OptionalPortNumberSchema: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
|
|
3568
|
+
declare const TheGraphApiKeySchema: z.ZodOptional<z.ZodString>;
|
|
3569
|
+
|
|
3570
|
+
/**
|
|
3571
|
+
* RPC configuration for a single chain.
|
|
3572
|
+
*
|
|
3573
|
+
* Ponder automatically manages the use of RPC endpoints for each indexed chain.
|
|
3574
|
+
*
|
|
3575
|
+
* @see https://ponder.sh/docs/config/chains#rpc-endpoints
|
|
3576
|
+
* @see https://ponder.sh/docs/config/chains#websocket
|
|
3577
|
+
*/
|
|
3578
|
+
interface RpcConfig {
|
|
3579
|
+
/**
|
|
3580
|
+
* The HTTP protocol URLs for RPCs to the chain (ex: "https://eth-mainnet.g.alchemy.com/v2/...").
|
|
3581
|
+
* For proper indexing behavior, each RPC must support high request rate limits (ex: 500+ requests a second).
|
|
3582
|
+
*
|
|
3583
|
+
* The order of RPC URLs matters. The first HTTP/HTTPS RPC for a given chain
|
|
3584
|
+
* will be the RPC that is used for Resolution API request processing.
|
|
3585
|
+
*
|
|
3586
|
+
* Invariants:
|
|
3587
|
+
* - Includes one or more URLs.
|
|
3588
|
+
* - Each URL in the array is guaranteed to be distinct.
|
|
3589
|
+
* - The protocol of each URL is guaranteed to be "http" or "https".
|
|
3590
|
+
*/
|
|
3591
|
+
httpRPCs: [URL, ...URL[]];
|
|
3592
|
+
/**
|
|
3593
|
+
* The websocket RPC for the chain.
|
|
3594
|
+
*
|
|
3595
|
+
* If defined, it is used to accelerate discovery of new "realtime" blocks.
|
|
3596
|
+
*
|
|
3597
|
+
* Invariants:
|
|
3598
|
+
* - If defined, the protocol of the URL is guaranteed to be "ws" or "wss".
|
|
3599
|
+
*/
|
|
3600
|
+
websocketRPC?: URL;
|
|
3601
|
+
}
|
|
3602
|
+
type RpcConfigs = Map<ChainId, RpcConfig>;
|
|
3603
|
+
type TheGraphApiKey = z.infer<typeof TheGraphApiKeySchema>;
|
|
3604
|
+
type PortNumber = z.infer<typeof PortNumberSchema>;
|
|
3605
|
+
|
|
3606
|
+
/**
|
|
3607
|
+
* Generic utilities for redacting sensitive information from configuration objects.
|
|
3608
|
+
*/
|
|
3609
|
+
|
|
3610
|
+
/**
|
|
3611
|
+
* Generic function to redact URL objects by replacing the path with a redacted placeholder.
|
|
3612
|
+
*/
|
|
3613
|
+
declare function redactUrl(url: URL): URL;
|
|
3614
|
+
/**
|
|
3615
|
+
* Generic function to redact strings by replacing them with a redacted placeholder.
|
|
3616
|
+
*/
|
|
3617
|
+
declare function redactString(_: string): string;
|
|
3618
|
+
/**
|
|
3619
|
+
* Redact RPC configs by replacing URLs with redacted values.
|
|
3620
|
+
*/
|
|
3621
|
+
declare function redactRpcConfigs(rpcConfigs: RpcConfigs): RpcConfigs;
|
|
3622
|
+
|
|
3623
|
+
/**
|
|
3624
|
+
* Mode for auto-generating RPCs across indexed chains.
|
|
3625
|
+
*/
|
|
3626
|
+
declare const RpcAutoGenModes: {
|
|
3627
|
+
/**
|
|
3628
|
+
* Auto-generates only HTTP RPCs for supported chains.
|
|
3629
|
+
*/
|
|
3630
|
+
readonly HttpOnly: "http-only";
|
|
3631
|
+
/**
|
|
3632
|
+
* Auto-generates both HTTP and WebSocket RPCs for supported chains.
|
|
3633
|
+
*/
|
|
3634
|
+
readonly HttpAndWs: "http-and-ws";
|
|
3635
|
+
};
|
|
3636
|
+
/**
|
|
3637
|
+
* The derived string union of possible {@link RpcAutoGenModes}.
|
|
3638
|
+
*/
|
|
3639
|
+
type RpcAutoGenMode = (typeof RpcAutoGenModes)[keyof typeof RpcAutoGenModes];
|
|
3640
|
+
/**
|
|
3641
|
+
* Build the RPCs auto-generation mode based on environment variables, with validation.
|
|
3642
|
+
*
|
|
3643
|
+
* Note: if env.RPC_AUTO_GEN_MODE is not set,
|
|
3644
|
+
* {@link DEFAULT_RPC_AUTO_GEN_MODE} will be used as the default.
|
|
3645
|
+
*
|
|
3646
|
+
* @param env The RPC environment variables to determine the auto-generation mode.
|
|
3647
|
+
* @returns The RPCs auto-generation mode to use for building RPC configurations.
|
|
3648
|
+
* @throws Error if the provided RPC_AUTO_GEN_MODE env var is invalid.
|
|
3649
|
+
*/
|
|
3650
|
+
declare function buildRpcAutoGenMode(env: RpcEnvironment): RpcAutoGenMode;
|
|
3651
|
+
/**
|
|
3652
|
+
* Constructs dynamic chain configuration from environment variables, scoped to chain IDs that appear
|
|
3653
|
+
* in the specified `namespace`.
|
|
3654
|
+
*
|
|
3655
|
+
* This function auto-generates RPCs, depending on
|
|
3656
|
+
* the configured {@link RpcAutoGenMode}, in the following order:
|
|
3657
|
+
* 1. RPC_URL_*, if available in the env
|
|
3658
|
+
* 2. Alchemy, if ALCHEMY_API_KEY is available in the env
|
|
3659
|
+
* 3. QuickNode, if both, QUICKNODE_API_KEY and QUICKNODE_ENDPOINT_NAME are specified,
|
|
3660
|
+
* a QuickNode RPC URL will be provided for each of the chains it supports.
|
|
3661
|
+
* 4. DRPC, if DRPC_API_KEY is available in the env
|
|
3662
|
+
*
|
|
3663
|
+
* It also provides a single Alchemy wss:// url if ALCHEMY_API_KEY is available in the env.
|
|
3664
|
+
*
|
|
3665
|
+
* NOTE: This function returns raw RpcConfigEnvironment values which are not yet parsed or validated.
|
|
3666
|
+
*
|
|
3667
|
+
* @throws when only one but not both of the following environment variables are defined:
|
|
3668
|
+
* {@link RpcEnvironment.QUICKNODE_API_KEY} or
|
|
3669
|
+
* {@link RpcEnvironment.QUICKNODE_ENDPOINT_NAME}.
|
|
3670
|
+
*/
|
|
3671
|
+
declare function buildRpcConfigsFromEnv(env: RpcEnvironment, namespace: ENSNamespaceId): Record<ChainIdString, ChainIdSpecificRpcEnvironmentVariable>;
|
|
3672
|
+
|
|
3673
|
+
/**
|
|
3674
|
+
* Invariant: RPC endpoint configuration for a chain must include at least one http/https protocol URL.
|
|
3675
|
+
*/
|
|
3676
|
+
declare function invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL(ctx: ZodCheckFnInput<URL[]>): void;
|
|
3677
|
+
/**
|
|
3678
|
+
* Invariant: RPC configuration for a chain must include at most one WS/WSS protocol URL.
|
|
3679
|
+
*/
|
|
3680
|
+
declare function invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL(ctx: ZodCheckFnInput<URL[]>): void;
|
|
3681
|
+
declare function invariant_rpcConfigsSpecifiedForRootChain(ctx: ZodCheckFnInput<{
|
|
3682
|
+
namespace: z.infer<typeof ENSNamespaceSchema>;
|
|
3683
|
+
rpcConfigs: z.infer<typeof RpcConfigsSchema>;
|
|
3684
|
+
}>): void;
|
|
3685
|
+
|
|
3686
|
+
/**
|
|
3687
|
+
* Represents the well-known ENSNode configuration templates deployed to the cloud. The value of each
|
|
3688
|
+
* key matches the domain segment that identifies this configuration template.
|
|
3689
|
+
*
|
|
3690
|
+
* @see https://ensnode.io/docs/usage/hosted-ensnode-instances
|
|
3691
|
+
*/
|
|
3692
|
+
declare const ConfigTemplateIds: {
|
|
3693
|
+
Mainnet: string;
|
|
3694
|
+
Sepolia: string;
|
|
3695
|
+
Alpha: string;
|
|
3696
|
+
AlphaSepolia: string;
|
|
3697
|
+
};
|
|
3698
|
+
type ConfigTemplateId = (typeof ConfigTemplateIds)[keyof typeof ConfigTemplateIds];
|
|
3699
|
+
/**
|
|
3700
|
+
* Determines whether the provided `configTemplateId` is Subgraph Compatible.
|
|
3701
|
+
*
|
|
3702
|
+
* See packages/ensnode-sdk/src/ensindexer/config/is-subgraph-compatible.ts for additional info.
|
|
3703
|
+
*
|
|
3704
|
+
* @see https://ensnode.io/docs/concepts/what-is-the-ens-subgraph
|
|
3705
|
+
*/
|
|
3706
|
+
declare function isConfigTemplateSubgraphCompatible(configTemplateId: ConfigTemplateId): boolean;
|
|
3707
|
+
/**
|
|
3708
|
+
* Determines the ENSNamespaceId for the provided `configTemplateId`.
|
|
3709
|
+
*
|
|
3710
|
+
* @see https://ensnode.io/docs/usage/hosted-ensnode-instances
|
|
3711
|
+
*/
|
|
3712
|
+
declare function namespaceForConfigTemplateId(configTemplateId: ConfigTemplateId): "mainnet" | "sepolia";
|
|
3713
|
+
|
|
3714
|
+
declare const DATASOURCE_NAMES_WITH_ENSv2_CONTRACTS: ["ENSv2Root"];
|
|
3715
|
+
type DatasourceWithENSv2Contracts = Datasource & {
|
|
3716
|
+
contracts: {
|
|
3717
|
+
Registry: ContractConfig;
|
|
3718
|
+
EnhancedAccessControl: ContractConfig;
|
|
3719
|
+
};
|
|
3720
|
+
};
|
|
3721
|
+
/**
|
|
3722
|
+
* The set of DatasourceNames that describe ENSv2 contracts that are indexed by the
|
|
3723
|
+
* Protocol Acceleration plugin.
|
|
3724
|
+
*/
|
|
3725
|
+
declare const getDatasourcesWithENSv2Contracts: (namespace: ENSNamespaceId) => DatasourceWithENSv2Contracts[];
|
|
3726
|
+
|
|
3727
|
+
type DatasourceWithResolverContract = Datasource & {
|
|
3728
|
+
contracts: {
|
|
3729
|
+
Resolver: ContractConfig;
|
|
3730
|
+
};
|
|
3731
|
+
};
|
|
3732
|
+
declare const DATASOURCE_NAMES_WITH_RESOLVERS: ["ensroot", "basenames", "lineanames", "threednsOptimism", "threednsBase", "ENSv2Root"];
|
|
3733
|
+
/**
|
|
3734
|
+
* The set of DatasourceNames that describe Resolver contracts that are indexed by the
|
|
3735
|
+
* Protocol Acceleration plugin.
|
|
3736
|
+
*/
|
|
3737
|
+
declare const getDatasourcesWithResolvers: (namespace: ENSNamespaceId) => DatasourceWithResolverContract[];
|
|
3738
|
+
|
|
3739
|
+
/**
|
|
3740
|
+
* Set of valid log levels, mirroring pino#LogLevelWithSilent.
|
|
3741
|
+
*/
|
|
3742
|
+
declare const LogLevelSchema: z.ZodEnum<{
|
|
3743
|
+
error: "error";
|
|
3744
|
+
info: "info";
|
|
3745
|
+
trace: "trace";
|
|
3746
|
+
fatal: "fatal";
|
|
3747
|
+
warn: "warn";
|
|
3748
|
+
debug: "debug";
|
|
3749
|
+
silent: "silent";
|
|
3750
|
+
}>;
|
|
3751
|
+
type LogLevel = z.infer<typeof LogLevelSchema>;
|
|
3752
|
+
declare function getLogLevelFromEnv(env: LogLevelEnvironment, defaultLogLevel: LogLevel): LogLevel;
|
|
3753
|
+
|
|
3754
|
+
/**
|
|
3755
|
+
* Describes a Bridged Resolver's origin Domain and target Registry.
|
|
3756
|
+
*/
|
|
3757
|
+
interface BridgedResolverConfig {
|
|
3758
|
+
/**
|
|
3759
|
+
* The Bridged Resolver connecting the origin Domain to the target Registry.
|
|
3760
|
+
*/
|
|
3761
|
+
resolver: AccountId;
|
|
3762
|
+
/**
|
|
3763
|
+
* The DomainId of the _legitimate_ originating Domain on the ENS Root chain whose
|
|
3764
|
+
* Bridged Resolver attachment canonicalizes the bridged target Registry. Anyone can set a
|
|
3765
|
+
* known Bridged Resolver (e.g. `BasenamesL1Resolver`) as their resolver, but only the
|
|
3766
|
+
* originating Domain (e.g. mainnet `base.eth`) is the canonical parent of the bridged
|
|
3767
|
+
* target Registry.
|
|
3768
|
+
*/
|
|
3769
|
+
originDomainId: DomainId;
|
|
3770
|
+
/**
|
|
3771
|
+
* The RegistryId of the _specific_ (Concrete or Virtual) Registry to which the Bridged Resolver defers.
|
|
3772
|
+
*/
|
|
3773
|
+
targetRegistryId: RegistryId;
|
|
3774
|
+
/**
|
|
3775
|
+
* The AccountId of the Concrete Registry to which the Bridged Resolver defers, necessary for
|
|
3776
|
+
* current ENSv1 Protocol Acceleration implementation.
|
|
3777
|
+
* TODO: refactor Protocol Acceleration to operate over RegistryId instead of AccountId.
|
|
3778
|
+
*/
|
|
3779
|
+
targetRegistry: AccountId;
|
|
3780
|
+
}
|
|
3781
|
+
/**
|
|
3782
|
+
* For a given `resolver`, if it is a known Bridged Resolver, return its Bridged Resolver Config.
|
|
3783
|
+
*/
|
|
3784
|
+
declare function isBridgedResolver(namespace: ENSNamespaceId, resolver: AccountId): BridgedResolverConfig | null;
|
|
3785
|
+
/**
|
|
3786
|
+
* Returns the `BridgedResolverConfig` for `domainId` if it is the origin Domain of a known
|
|
3787
|
+
* Bridged Resolver, or `null` otherwise.
|
|
3788
|
+
*
|
|
3789
|
+
* `Domain.subregistryId` on a bridge origin (e.g. mainnet `base.eth`, `linea.eth`) is owned by
|
|
3790
|
+
* `handleBridgedResolverChange` — it must point at the bridged target Registry on the L2 chain
|
|
3791
|
+
* so the canonical edge to that target Registry can agree. Chain-local subname events on the
|
|
3792
|
+
* origin Domain must not overwrite that pointer.
|
|
3793
|
+
*/
|
|
3794
|
+
declare function isBridgedOriginDomain(namespace: ENSNamespaceId, domainId: DomainId): BridgedResolverConfig | null;
|
|
3795
|
+
/**
|
|
3796
|
+
* Returns the `BridgedResolverConfig` for `registryId` if it is the target Registry of a known
|
|
3797
|
+
* Bridged Resolver, or `null` otherwise.
|
|
3798
|
+
*
|
|
3799
|
+
* `Registry.canonicalDomainId` on a bridged target (e.g. the Basenames/Lineanames L2 Registries)
|
|
3800
|
+
* is owned by the registry-creation path in `ENSv1Registry.ts` — it must point at the mainnet
|
|
3801
|
+
* origin Domain so the canonical edge can agree. Chain-local subname events on the target Registry
|
|
3802
|
+
* must not overwrite that pointer with the L2-side Domain ID.
|
|
3803
|
+
*/
|
|
3804
|
+
declare function isBridgedTargetRegistry(namespace: ENSNamespaceId, registryId: RegistryId): BridgedResolverConfig | null;
|
|
3805
|
+
|
|
3806
|
+
/**
|
|
3807
|
+
* ENSIP-19 Reverse Resolvers (i.e. DefaultReverseResolver or ChainReverseResolver) simply:
|
|
3808
|
+
* a. read the Name for their specific coinType from their connected StandaloneReverseRegistry, or
|
|
3809
|
+
* b. return the default coinType's Name.
|
|
3810
|
+
*
|
|
3811
|
+
* We encode this behavior here, for the purposes of Protocol Acceleration.
|
|
3812
|
+
*/
|
|
3813
|
+
declare function isKnownENSIP19ReverseResolver(namespace: ENSNamespaceId, resolver: AccountId): boolean;
|
|
3814
|
+
|
|
3815
|
+
/**
|
|
3816
|
+
* Returns whether `resolver` is an Static Resolver.
|
|
3817
|
+
*
|
|
3818
|
+
* Static Resolvers must abide the following pattern:
|
|
3819
|
+
* 1. All information necessary for resolution is stored on-chain, and
|
|
3820
|
+
* 2. All resolve() calls resolve to the exact value previously emitted by the Resolver in
|
|
3821
|
+
* its events (i.e. no post-processing or other logic, a simple return of the on-chain data).
|
|
3822
|
+
* 2.a the Resolver MAY implement address record defaulting and still be considered Static (see below).
|
|
3823
|
+
* 3. Its behavior is unlikely to change (i.e. the contract is not upgradable or is unlikely to be
|
|
3824
|
+
* upgraded in a way that violates principles 1. or 2.).
|
|
3825
|
+
*
|
|
3826
|
+
* TODO: these relationships could be encoded in an ENSIP
|
|
3827
|
+
*/
|
|
3828
|
+
declare function isStaticResolver(namespace: ENSNamespaceId, resolver: AccountId): boolean;
|
|
3829
|
+
/**
|
|
3830
|
+
* Returns whether `resolver` implements address record defaulting.
|
|
3831
|
+
*
|
|
3832
|
+
* @see https://docs.ens.domains/ensip/19/#default-address
|
|
3833
|
+
*/
|
|
3834
|
+
declare function staticResolverImplementsAddressRecordDefaulting(namespace: ENSNamespaceId, resolver: AccountId): boolean;
|
|
3835
|
+
|
|
3836
|
+
/**
|
|
3837
|
+
* Determines whether, given the provided context, a Subgraph GraphQL API request can be handled by
|
|
3838
|
+
* a TheGraph-hosted Subgraph.
|
|
3839
|
+
*
|
|
3840
|
+
* @see https://ensnode.io/docs/concepts/what-is-the-ens-subgraph
|
|
3841
|
+
*/
|
|
3842
|
+
declare const canFallbackToTheGraph: ({ namespace, theGraphApiKey, isSubgraphCompatible, }: {
|
|
3843
|
+
namespace: ENSNamespaceId;
|
|
3844
|
+
theGraphApiKey: string | undefined;
|
|
3845
|
+
isSubgraphCompatible: boolean;
|
|
3846
|
+
}) => TheGraphFallback;
|
|
3847
|
+
|
|
3848
|
+
/**
|
|
3849
|
+
* Parses a string value as a boolean.
|
|
3850
|
+
*/
|
|
3851
|
+
declare const makeBooleanStringSchema: (valueLabel?: string) => z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodEnum<{
|
|
3852
|
+
true: "true";
|
|
3853
|
+
false: "false";
|
|
3854
|
+
}>>, z.ZodTransform<boolean, "true" | "false">>;
|
|
3855
|
+
/**
|
|
3856
|
+
* Parses a numeric value as a finite non-negative number.
|
|
3857
|
+
*/
|
|
3858
|
+
declare const makeFiniteNonNegativeNumberSchema: (valueLabel?: string) => z.ZodNumber;
|
|
3859
|
+
/**
|
|
3860
|
+
* Parses a numeric value as an integer.
|
|
3861
|
+
*/
|
|
3862
|
+
declare const makeIntegerSchema: (valueLabel?: string) => z.ZodInt;
|
|
3863
|
+
/**
|
|
3864
|
+
* Parses a numeric value as a positive integer.
|
|
3865
|
+
*/
|
|
3866
|
+
declare const makePositiveIntegerSchema: (valueLabel?: string) => z.ZodInt;
|
|
3867
|
+
/**
|
|
3868
|
+
* Parses a numeric value as a non-negative integer.
|
|
3869
|
+
*/
|
|
3870
|
+
declare const makeNonNegativeIntegerSchema: (valueLabel?: string) => z.ZodInt;
|
|
3871
|
+
/**
|
|
3872
|
+
* Parses a numeric value as {@link Duration}
|
|
3873
|
+
*/
|
|
3874
|
+
declare const makeDurationSchema: (valueLabel?: string) => z.ZodPipe<z.ZodNumber, z.ZodInt>;
|
|
3875
|
+
/**
|
|
3876
|
+
* Parses Chain ID
|
|
3877
|
+
*
|
|
3878
|
+
* {@link ChainId}
|
|
3879
|
+
*/
|
|
3880
|
+
declare const makeChainIdSchema: (valueLabel?: string) => z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
3881
|
+
/**
|
|
3882
|
+
* Parses a serialized representation of {@link ChainId}.
|
|
3883
|
+
*/
|
|
3884
|
+
declare const makeChainIdStringSchema: (valueLabel?: string) => z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodCoercedNumber<string>>, z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
3885
|
+
/**
|
|
3886
|
+
* Parses Defaultable Chain ID
|
|
3887
|
+
*
|
|
3888
|
+
* {@link DefaultableChainId}
|
|
3889
|
+
*/
|
|
3890
|
+
declare const makeDefaultableChainIdSchema: (valueLabel?: string) => z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
3891
|
+
/**
|
|
3892
|
+
* Parses a serialized representation of {@link DefaultableChainId}.
|
|
3893
|
+
*/
|
|
3894
|
+
declare const makeDefaultableChainIdStringSchema: (valueLabel?: string) => z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodCoercedNumber<string>>, z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
|
|
3895
|
+
/**
|
|
3896
|
+
* Parses {@link CoinType}.
|
|
3897
|
+
*/
|
|
3898
|
+
declare const makeCoinTypeSchema: (valueLabel?: string) => z.ZodPipe<z.ZodNumber, z.ZodTransform<0 | 2 | 3 | 4 | 22 | 7 | 5 | 6 | 20 | 14 | 42 | 43 | 61 | 60 | 57 | 55 | 74 | 77 | 105 | 111 | 118 | 121 | 128 | 133 | 134 | 135 | 136 | 137 | 141 | 144 | 145 | 148 | 153 | 156 | 165 | 192 | 2147492101 | 2147483648 | 175 | 178 | 194 | 195 | 204 | 235 | 236 | 242 | 246 | 283 | 291 | 301 | 304 | 308 | 309 | 313 | 326 | 330 | 354 | 360 | 367 | 397 | 415 | 425 | 434 | 457 | 459 | 461 | 472 | 489 | 500 | 501 | 508 | 535 | 539 | 566 | 568 | 569 | 570 | 571 | 573 | 574 | 576 | 589 | 592 | 700 | 714 | 784 | 818 | 820 | 825 | 888 | 889 | 904 | 931 | 999 | 1001 | 1007 | 1023 | 1024 | 1237 | 1729 | 1815 | 1991 | 2301 | 2303 | 2305 | 2718 | 3030 | 4218 | 5353 | 5757 | 6060 | 8444 | 8964 | 9000 | 9004 | 9797 | 16754 | 19167 | 52752 | 99999 | 5655640 | 5718350 | 5741564 | 2147483658 | 2147483673 | 2147483704 | 2147483708 | 2147483709 | 2147483736 | 2147483747 | 2147483748 | 2147483756 | 2147483785 | 2147483817 | 2147483894 | 2147483898 | 2147483936 | 2147483972 | 2147484009 | 2147484468 | 2147484736 | 2147488648 | 2147523445 | 2147525809 | 2147525868 | 2147526762 | 2147542792 | 2148018000 | 2155261425, number>>;
|
|
3899
|
+
/**
|
|
3900
|
+
* Parses a serialized representation of {@link CoinType}.
|
|
3901
|
+
*/
|
|
3902
|
+
declare const makeCoinTypeStringSchema: (valueLabel?: string) => z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodCoercedNumber<string>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<0 | 2 | 3 | 4 | 22 | 7 | 5 | 6 | 20 | 14 | 42 | 43 | 61 | 60 | 57 | 55 | 74 | 77 | 105 | 111 | 118 | 121 | 128 | 133 | 134 | 135 | 136 | 137 | 141 | 144 | 145 | 148 | 153 | 156 | 165 | 192 | 2147492101 | 2147483648 | 175 | 178 | 194 | 195 | 204 | 235 | 236 | 242 | 246 | 283 | 291 | 301 | 304 | 308 | 309 | 313 | 326 | 330 | 354 | 360 | 367 | 397 | 415 | 425 | 434 | 457 | 459 | 461 | 472 | 489 | 500 | 501 | 508 | 535 | 539 | 566 | 568 | 569 | 570 | 571 | 573 | 574 | 576 | 589 | 592 | 700 | 714 | 784 | 818 | 820 | 825 | 888 | 889 | 904 | 931 | 999 | 1001 | 1007 | 1023 | 1024 | 1237 | 1729 | 1815 | 1991 | 2301 | 2303 | 2305 | 2718 | 3030 | 4218 | 5353 | 5757 | 6060 | 8444 | 8964 | 9000 | 9004 | 9797 | 16754 | 19167 | 52752 | 99999 | 5655640 | 5718350 | 5741564 | 2147483658 | 2147483673 | 2147483704 | 2147483708 | 2147483709 | 2147483736 | 2147483747 | 2147483748 | 2147483756 | 2147483785 | 2147483817 | 2147483894 | 2147483898 | 2147483936 | 2147483972 | 2147484009 | 2147484468 | 2147484736 | 2147488648 | 2147523445 | 2147525809 | 2147525868 | 2147526762 | 2147542792 | 2148018000 | 2155261425, number>>>;
|
|
3903
|
+
/**
|
|
3904
|
+
* Parses a serialized representation of an EVM address into a {@link NormalizedAddress}.
|
|
3905
|
+
*/
|
|
3906
|
+
declare const makeNormalizedAddressSchema: (valueLabel?: string) => z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
3907
|
+
/**
|
|
3908
|
+
* Parses an ISO 8601 string representations of {@link Datetime}
|
|
3909
|
+
*/
|
|
3910
|
+
declare const makeDatetimeSchema: (valueLabel?: string) => z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>;
|
|
3911
|
+
/**
|
|
3912
|
+
* Parses value as {@link UnixTimestamp}.
|
|
3913
|
+
*/
|
|
3914
|
+
declare const makeUnixTimestampSchema: (valueLabel?: string) => z.ZodInt;
|
|
3915
|
+
/**
|
|
3916
|
+
* Parses a string representations of {@link URL}
|
|
3917
|
+
*/
|
|
3918
|
+
declare const makeUrlSchema: (valueLabel?: string) => z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>;
|
|
3919
|
+
/**
|
|
3920
|
+
* Parses a serialized representation of a comma separated list.
|
|
3921
|
+
*/
|
|
3922
|
+
declare const makeCommaSeparatedList: (valueLabel?: string) => z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>;
|
|
3923
|
+
/**
|
|
3924
|
+
* Parses a numeric value as a block number.
|
|
3925
|
+
*/
|
|
3926
|
+
declare const makeBlockNumberSchema: (valueLabel?: string) => z.ZodInt;
|
|
3927
|
+
/**
|
|
3928
|
+
* Parses an object value as the {@link BlockRef} object.
|
|
3929
|
+
*/
|
|
3930
|
+
declare const makeBlockRefSchema: (valueLabel?: string) => z.ZodObject<{
|
|
3931
|
+
timestamp: z.ZodInt;
|
|
3932
|
+
number: z.ZodInt;
|
|
3933
|
+
}, z.core.$strict>;
|
|
3934
|
+
/**
|
|
3935
|
+
* Parses a string value as ENSNamespaceId.
|
|
3936
|
+
*/
|
|
3937
|
+
declare const makeENSNamespaceIdSchema: (valueLabel?: string) => z.ZodEnum<{
|
|
3938
|
+
readonly Mainnet: "mainnet";
|
|
3939
|
+
readonly Sepolia: "sepolia";
|
|
3940
|
+
readonly SepoliaV2: "sepolia-v2";
|
|
3941
|
+
readonly EnsTestEnv: "ens-test-env";
|
|
3942
|
+
}>;
|
|
3943
|
+
declare const makePriceCurrencySchema: (currency: CurrencyId, valueLabel?: string) => z.ZodObject<{
|
|
3944
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3945
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3946
|
+
}, z.core.$strict>;
|
|
3947
|
+
declare const makeSerializedPriceCurrencySchema: (currency: CurrencyId, valueLabel?: string) => z.ZodObject<{
|
|
3948
|
+
amount: z.ZodString;
|
|
3949
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3950
|
+
}, z.core.$strict>;
|
|
3951
|
+
/**
|
|
3952
|
+
* Schema for {@link Price} type.
|
|
3953
|
+
*/
|
|
3954
|
+
declare const makePriceSchema: (valueLabel?: string) => z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
3955
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3956
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3957
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
3958
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3959
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3960
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
3961
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3962
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3963
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
3964
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3965
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3966
|
+
}, z.core.$strict>], "currency">;
|
|
3967
|
+
/**
|
|
3968
|
+
* Schema for {@link PriceEth} type.
|
|
3969
|
+
*/
|
|
3970
|
+
declare const makePriceEthSchema: (valueLabel?: string) => z.ZodPipe<z.ZodObject<{
|
|
3971
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3972
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3973
|
+
}, z.core.$strict>, z.ZodTransform<PriceEth, {
|
|
3974
|
+
amount: bigint;
|
|
3975
|
+
currency: CurrencyId;
|
|
3976
|
+
}>>;
|
|
3977
|
+
declare const makeSerializedPriceEthSchema: (valueLabel?: string) => z.ZodPipe<z.ZodObject<{
|
|
3978
|
+
amount: z.ZodString;
|
|
3979
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3980
|
+
}, z.core.$strict>, z.ZodTransform<SerializedPriceEth, {
|
|
3981
|
+
amount: string;
|
|
3982
|
+
currency: CurrencyId;
|
|
3983
|
+
}>>;
|
|
3984
|
+
/**
|
|
3985
|
+
* Schema for {@link PriceUsdc} type.
|
|
3986
|
+
*/
|
|
3987
|
+
declare const makePriceUsdcSchema: (valueLabel?: string) => z.ZodPipe<z.ZodObject<{
|
|
3988
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3989
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
3990
|
+
}, z.core.$strict>, z.ZodTransform<PriceUsdc, {
|
|
3991
|
+
amount: bigint;
|
|
3992
|
+
currency: CurrencyId;
|
|
3993
|
+
}>>;
|
|
3994
|
+
/**
|
|
3995
|
+
* Schema for {@link PriceDai} type.
|
|
3996
|
+
*/
|
|
3997
|
+
declare const makePriceDaiSchema: (valueLabel?: string) => z.ZodPipe<z.ZodObject<{
|
|
3998
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
3999
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
4000
|
+
}, z.core.$strict>, z.ZodTransform<PriceDai, {
|
|
4001
|
+
amount: bigint;
|
|
4002
|
+
currency: CurrencyId;
|
|
4003
|
+
}>>;
|
|
4004
|
+
/**
|
|
4005
|
+
* Schema for {@link PriceEnsTokens} type.
|
|
4006
|
+
*/
|
|
4007
|
+
declare const makePriceEnsTokensSchema: (valueLabel?: string) => z.ZodPipe<z.ZodObject<{
|
|
4008
|
+
amount: z.ZodCoercedBigInt<unknown>;
|
|
4009
|
+
currency: z.ZodLiteral<CurrencyId>;
|
|
4010
|
+
}, z.core.$strict>, z.ZodTransform<PriceEnsTokens, {
|
|
4011
|
+
amount: bigint;
|
|
4012
|
+
currency: CurrencyId;
|
|
4013
|
+
}>>;
|
|
4014
|
+
/**
|
|
4015
|
+
* Schema for {@link AccountId} type.
|
|
4016
|
+
*/
|
|
4017
|
+
declare const makeAccountIdSchema: (valueLabel?: string) => z.ZodObject<{
|
|
4018
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4019
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4020
|
+
}, z.core.$strict>;
|
|
4021
|
+
/**
|
|
4022
|
+
* Schema for {@link AccountIdString} type.
|
|
4023
|
+
*/
|
|
4024
|
+
declare const makeAccountIdStringSchema: (valueLabel?: string) => z.ZodPipe<z.ZodPipe<z.ZodCoercedString<unknown>, z.ZodTransform<{
|
|
4025
|
+
chainId: number;
|
|
4026
|
+
address: string;
|
|
4027
|
+
}, string>>, z.ZodObject<{
|
|
4028
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4029
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4030
|
+
}, z.core.$strict>>;
|
|
4031
|
+
/**
|
|
4032
|
+
* Make a schema for {@link Hex} representation of bytes array.
|
|
4033
|
+
*
|
|
4034
|
+
* @param {number} options.bytesCount expected count of bytes to be hex-encoded
|
|
4035
|
+
*/
|
|
4036
|
+
declare const makeHexStringSchema: (options: {
|
|
4037
|
+
bytesCount: number;
|
|
4038
|
+
}, valueLabel?: string) => z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4039
|
+
/**
|
|
4040
|
+
* Make schema for {@link Node}.
|
|
4041
|
+
*/
|
|
4042
|
+
declare const makeNodeSchema: (valueLabel?: string) => z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4043
|
+
/**
|
|
4044
|
+
* Make schema for Transaction Hash
|
|
4045
|
+
*/
|
|
4046
|
+
declare const makeTransactionHashSchema: (valueLabel?: string) => z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4047
|
+
/**
|
|
4048
|
+
* Make schema for {@link ReinterpretedName}.
|
|
4049
|
+
*/
|
|
4050
|
+
declare const makeReinterpretedNameSchema: (valueLabel?: string) => z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<InterpretedName, string>>, z.ZodTransform<InterpretedName, InterpretedName>>;
|
|
4051
|
+
|
|
4052
|
+
declare const tokenIdSchemaSerializable: z.ZodString;
|
|
4053
|
+
declare const tokenIdSchemaNative: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBigInt>;
|
|
4054
|
+
declare function makeTokenIdSchema<const SerializableType extends boolean>(_valueLabel: string, serializable: SerializableType): SerializableType extends true ? typeof tokenIdSchemaSerializable : typeof tokenIdSchemaNative;
|
|
4055
|
+
/**
|
|
4056
|
+
* Make schema for {@link AssetId}.
|
|
4057
|
+
*
|
|
4058
|
+
*/
|
|
4059
|
+
declare const makeAssetIdSchema: <const SerializableType extends boolean = false>(valueLabel?: string, serializable?: SerializableType) => z.ZodObject<{
|
|
4060
|
+
assetNamespace: z.ZodEnum<{
|
|
4061
|
+
readonly ERC721: "erc721";
|
|
4062
|
+
readonly ERC1155: "erc1155";
|
|
4063
|
+
}>;
|
|
4064
|
+
contract: z.ZodObject<{
|
|
4065
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4066
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4067
|
+
}, z.core.$strict>;
|
|
4068
|
+
tokenId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBigInt> | (SerializableType extends true ? z.ZodString : z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBigInt>);
|
|
4069
|
+
}, z.core.$strip>;
|
|
4070
|
+
/**
|
|
4071
|
+
* Make schema for {@link AssetIdString}.
|
|
4072
|
+
*/
|
|
4073
|
+
declare const makeAssetIdStringSchema: (valueLabel?: string) => z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
|
|
4074
|
+
assetNamespace: z.ZodEnum<{
|
|
4075
|
+
readonly ERC721: "erc721";
|
|
4076
|
+
readonly ERC1155: "erc1155";
|
|
4077
|
+
}>;
|
|
4078
|
+
contract: z.ZodObject<{
|
|
4079
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4080
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4081
|
+
}, z.core.$strict>;
|
|
4082
|
+
tokenId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBigInt>;
|
|
4083
|
+
}, z.core.$strip>>;
|
|
4084
|
+
/**
|
|
4085
|
+
* Make schema for {@link DomainAssetId}.
|
|
4086
|
+
*/
|
|
4087
|
+
declare const makeDomainAssetSchema: (valueLabel?: string) => z.ZodObject<{
|
|
4088
|
+
assetNamespace: z.ZodEnum<{
|
|
4089
|
+
readonly ERC721: "erc721";
|
|
4090
|
+
readonly ERC1155: "erc1155";
|
|
4091
|
+
}>;
|
|
4092
|
+
contract: z.ZodObject<{
|
|
4093
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4094
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4095
|
+
}, z.core.$strict>;
|
|
4096
|
+
tokenId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBigInt>;
|
|
4097
|
+
domainId: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4098
|
+
}, z.core.$strip>;
|
|
4099
|
+
declare const makeNameTokenOwnershipNameWrapperSchema: (valueLabel?: string) => z.ZodObject<{
|
|
4100
|
+
ownershipType: z.ZodLiteral<"namewrapper">;
|
|
4101
|
+
owner: z.ZodObject<{
|
|
4102
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4103
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4104
|
+
}, z.core.$strict>;
|
|
4105
|
+
}, z.core.$strip>;
|
|
4106
|
+
declare const makeNameTokenOwnershipFullyOnchainSchema: (valueLabel?: string) => z.ZodObject<{
|
|
4107
|
+
ownershipType: z.ZodLiteral<"fully-onchain">;
|
|
4108
|
+
owner: z.ZodObject<{
|
|
4109
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4110
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4111
|
+
}, z.core.$strict>;
|
|
4112
|
+
}, z.core.$strip>;
|
|
4113
|
+
declare const makeNameTokenOwnershipBurnedSchema: (valueLabel?: string) => z.ZodObject<{
|
|
4114
|
+
ownershipType: z.ZodLiteral<"burned">;
|
|
4115
|
+
owner: z.ZodObject<{
|
|
4116
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4117
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4118
|
+
}, z.core.$strict>;
|
|
4119
|
+
}, z.core.$strip>;
|
|
4120
|
+
declare const makeNameTokenOwnershipUnknownSchema: (valueLabel?: string) => z.ZodObject<{
|
|
4121
|
+
ownershipType: z.ZodLiteral<"unknown">;
|
|
4122
|
+
owner: z.ZodObject<{
|
|
4123
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4124
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4125
|
+
}, z.core.$strict>;
|
|
4126
|
+
}, z.core.$strip>;
|
|
4127
|
+
declare const makeNameTokenOwnershipSchema: (valueLabel?: string) => z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
4128
|
+
ownershipType: z.ZodLiteral<"namewrapper">;
|
|
4129
|
+
owner: z.ZodObject<{
|
|
4130
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4131
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4132
|
+
}, z.core.$strict>;
|
|
4133
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
4134
|
+
ownershipType: z.ZodLiteral<"fully-onchain">;
|
|
4135
|
+
owner: z.ZodObject<{
|
|
4136
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4137
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4138
|
+
}, z.core.$strict>;
|
|
4139
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
4140
|
+
ownershipType: z.ZodLiteral<"burned">;
|
|
4141
|
+
owner: z.ZodObject<{
|
|
4142
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4143
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4144
|
+
}, z.core.$strict>;
|
|
4145
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
4146
|
+
ownershipType: z.ZodLiteral<"unknown">;
|
|
4147
|
+
owner: z.ZodObject<{
|
|
4148
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4149
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4150
|
+
}, z.core.$strict>;
|
|
4151
|
+
}, z.core.$strip>], "ownershipType">;
|
|
4152
|
+
/**
|
|
4153
|
+
* Make schema for {@link NameToken}.
|
|
4154
|
+
*/
|
|
4155
|
+
declare const makeNameTokenSchema: <const SerializableType extends boolean>(valueLabel?: string, serializable?: SerializableType) => z.ZodObject<{
|
|
4156
|
+
token: z.ZodObject<{
|
|
4157
|
+
assetNamespace: z.ZodEnum<{
|
|
4158
|
+
readonly ERC721: "erc721";
|
|
4159
|
+
readonly ERC1155: "erc1155";
|
|
4160
|
+
}>;
|
|
4161
|
+
contract: z.ZodObject<{
|
|
4162
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4163
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4164
|
+
}, z.core.$strict>;
|
|
4165
|
+
tokenId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBigInt> | (SerializableType extends true ? z.ZodString : z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBigInt>);
|
|
4166
|
+
}, z.core.$strip>;
|
|
4167
|
+
ownership: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
4168
|
+
ownershipType: z.ZodLiteral<"namewrapper">;
|
|
4169
|
+
owner: z.ZodObject<{
|
|
4170
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4171
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4172
|
+
}, z.core.$strict>;
|
|
4173
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
4174
|
+
ownershipType: z.ZodLiteral<"fully-onchain">;
|
|
4175
|
+
owner: z.ZodObject<{
|
|
4176
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4177
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4178
|
+
}, z.core.$strict>;
|
|
4179
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
4180
|
+
ownershipType: z.ZodLiteral<"burned">;
|
|
4181
|
+
owner: z.ZodObject<{
|
|
4182
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4183
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4184
|
+
}, z.core.$strict>;
|
|
4185
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
4186
|
+
ownershipType: z.ZodLiteral<"unknown">;
|
|
4187
|
+
owner: z.ZodObject<{
|
|
4188
|
+
chainId: z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>;
|
|
4189
|
+
address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
|
|
4190
|
+
}, z.core.$strict>;
|
|
4191
|
+
}, z.core.$strip>], "ownershipType">;
|
|
4192
|
+
mintStatus: z.ZodEnum<{
|
|
4193
|
+
readonly Minted: "minted";
|
|
4194
|
+
readonly Burned: "burned";
|
|
4195
|
+
}>;
|
|
4196
|
+
}, z.core.$strip>;
|
|
4197
|
+
|
|
4198
|
+
export { type BridgedResolverConfig, type ChainIdSpecificRpcEnvironmentVariable, type ConfigTemplateId, ConfigTemplateIds, DATASOURCE_NAMES_WITH_ENSv2_CONTRACTS, DATASOURCE_NAMES_WITH_RESOLVERS, ENSNamespaceSchema, type EnsDbEnvironment, GRAPHQL_API_EXAMPLE_QUERIES, type GraphqlApiExampleQuery, type LogLevel, type LogLevelEnvironment, OptionalPortNumberSchema, type PortEnvironment, type PortNumber, PortNumberSchema, type ReferralProgramEditionsEnvironment, type RpcConfig, type RpcConfigs, RpcConfigsSchema, type RpcEnvironment, type TheGraphApiKey, TheGraphApiKeySchema, type TheGraphEnvironment, TheGraphFallback, type ZodCheckFnInput, alchemySupportsChain, buildAlchemyBaseUrl, buildDRPCUrl, buildQuickNodeURL, buildRpcAutoGenMode, buildRpcConfigsFromEnv, canFallbackToTheGraph, dRPCSupportsChain, errorResponseBadRequestExample, errorResponseInternalServerErrorExample, errorResponseInvalidAddressExample, errorResponseInvalidNameExample, getDatasourcesWithENSv2Contracts, getDatasourcesWithResolvers, getGraphqlApiExampleQueryById, getLogLevelFromEnv, invariant_ensRainbowSupportedLabelSetAndVersion, invariant_isSubgraphCompatibleRequirements, invariant_rpcConfigsSpecifiedForRootChain, invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL, invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL, isBridgedOriginDomain, isBridgedResolver, isBridgedTargetRegistry, isConfigTemplateSubgraphCompatible, isExtendedResolver, isKnownENSIP19ReverseResolver, isStaticResolver, makeAccountIdSchema, makeAccountIdStringSchema, makeAssetIdSchema, makeAssetIdStringSchema, makeBaseRegistrarActionSchema, makeBlockNumberSchema, makeBlockRefSchema, makeBooleanStringSchema, makeChainIdSchema, makeChainIdStringSchema, makeCoinTypeSchema, makeCoinTypeStringSchema, makeCommaSeparatedList, makeDatetimeSchema, makeDefaultableChainIdSchema, makeDefaultableChainIdStringSchema, makeDomainAssetSchema, makeDurationSchema, makeENSIndexerPublicConfigSchema, makeENSIndexerVersionInfoSchema, makeENSNamespaceIdSchema, makeEnsApiIndexingStatusResponseErrorSchema, makeEnsApiIndexingStatusResponseOkSchema, makeEnsApiIndexingStatusResponseSchema, makeEnsIndexerPublicConfigSchema, makeEnsIndexerSchemaNameSchema, makeEnsIndexerVersionInfoSchema, makeFiniteNonNegativeNumberSchema, makeFullyPinnedLabelSetSchema, makeHexStringSchema, makeIndexedChainIdsSchema, makeIndexingStatusResponseSchema, makeIntegerSchema, makeNameTokenOwnershipBurnedSchema, makeNameTokenOwnershipFullyOnchainSchema, makeNameTokenOwnershipNameWrapperSchema, makeNameTokenOwnershipSchema, makeNameTokenOwnershipUnknownSchema, makeNameTokenSchema, makeNameTokensResponseErrorEnsIndexerConfigUnsupported, makeNameTokensResponseErrorNameIndexingStatusUnsupported, makeNameTokensResponseErrorNameTokensNotIndexedSchema, makeNameTokensResponseErrorSchema, makeNameTokensResponseOkSchema, makeNameTokensResponseSchema, makeNamedRegistrarActionSchema, makeNodeSchema, makeNonNegativeIntegerSchema, makeNormalizedAddressSchema, makePluginsListSchema, makePositiveIntegerSchema, makePriceCurrencySchema, makePriceDaiSchema, makePriceEnsTokensSchema, makePriceEthSchema, makePriceSchema, makePriceUsdcSchema, makeRegisteredNameTokenSchema, makeRegistrarActionRegistrationSchema, makeRegistrarActionRenewalSchema, makeRegistrarActionSchema, makeRegistrarActionsResponseErrorSchema, makeRegistrarActionsResponseOkSchema, makeRegistrarActionsResponseSchema, makeRegistrationLifecycleSchema, makeReinterpretedNameSchema, makeRequestPageParamsSchema, makeResolvePrimaryNameResponseSchema, makeResolvePrimaryNamesResponseSchema, makeResolveRecordsResponseSchema, makeResponsePageContextSchema, makeResponsePageContextSchemaWithNoRecords, makeResponsePageContextSchemaWithRecords, makeSerializedEnsApiIndexingStatusResponseOkSchema, makeSerializedEnsApiIndexingStatusResponseSchema, makeSerializedEnsIndexerPublicConfigSchema, makeSerializedIndexedChainIdsSchema, makeSerializedPriceCurrencySchema, makeSerializedPriceEthSchema, makeSerializedRegistrarActionPricingSchema, makeSerializedRegistrarActionSchema, makeSerializedRegistrarActionsResponseOkSchema, makeSupportsInterfaceReader, makeTokenIdSchema, makeTransactionHashSchema, makeUnixTimestampSchema, makeUrlSchema, nameTokensNotIndexedExample, nameTokensResponseOkExample, nameTokensServiceUnavailableExample, namespaceForConfigTemplateId, quickNodeSupportsChain, realtimeResponseSchemaError, realtimeResponseSchemaOk, redactRpcConfigs, redactString, redactUrl, registrarActionsResponseOkExample, resolvePrimaryNameResponseExample, resolvePrimaryNamesResponseExample, resolveRecordsResponseExample, staticResolverImplementsAddressRecordDefaulting, stringifyConfig };
|