@avalabs/glacier-sdk 3.1.0-canary.639f9ba.0 → 3.1.0-canary.7a21d42.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.d.ts CHANGED
@@ -54,592 +54,502 @@ declare abstract class BaseHttpRequest {
54
54
  abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
55
55
  }
56
56
 
57
- declare class DefaultService {
58
- readonly httpRequest: BaseHttpRequest;
59
- constructor(httpRequest: BaseHttpRequest);
57
+ type LogsFormatMetadata = {
60
58
  /**
61
- * @returns any
62
- * @throws ApiError
59
+ * The IP address of the client that made the request.
63
60
  */
64
- mediaControllerUploadImage(): CancelablePromise<any>;
65
- }
61
+ ipAddress: string;
62
+ /**
63
+ * The host for the request made by the client.
64
+ */
65
+ host: string;
66
+ /**
67
+ * The user agent of the client that made the request.
68
+ */
69
+ userAgent: string;
70
+ };
66
71
 
67
72
  /**
68
- * ISO 4217 currency code.
73
+ * The type of request made by the client.
69
74
  */
70
- declare enum CurrencyCode {
71
- USD = "usd",
72
- EUR = "eur",
73
- AUD = "aud",
74
- CAD = "cad",
75
- CHF = "chf",
76
- CLP = "clp",
77
- CNY = "cny",
78
- CZK = "czk",
79
- DKK = "dkk",
80
- GBP = "gbp",
81
- HKD = "hkd",
82
- HUF = "huf",
83
- JPY = "jpy",
84
- NZD = "nzd"
75
+ declare enum RequestType {
76
+ DATA = "data",
77
+ RPC = "rpc"
85
78
  }
86
79
 
87
- type Money = {
88
- currencyCode: CurrencyCode;
80
+ type LogsFormat = {
89
81
  /**
90
- * Monetary value in base 10 decimals.
82
+ * The organization id of the request.
91
83
  */
92
- value: number;
93
- };
94
-
95
- type NativeTokenBalance = {
84
+ orgId: string;
96
85
  /**
97
- * The contract name.
86
+ * The unique log id of the request.
98
87
  */
99
- name: string;
88
+ logId: string;
100
89
  /**
101
- * The contract symbol.
90
+ * The timestamp of the request.
102
91
  */
103
- symbol: string;
92
+ eventTimestamp: number;
104
93
  /**
105
- * The number of decimals the token uses. For example `6`, means to divide the token amount by `1000000` to get its user representation.
94
+ * The apiKey used to make the request.
106
95
  */
107
- decimals: number;
96
+ apiKeyId: string;
108
97
  /**
109
- * The logo uri for the address.
98
+ * The alias of the apiKey used to make the request.
110
99
  */
111
- logoUri?: string;
100
+ apiKeyAlias: string;
112
101
  /**
113
- * The evm chain id.
102
+ * The region of the host for the request made by the client.
114
103
  */
115
- chainId: string;
104
+ hostRegion: string;
105
+ requestType: RequestType;
116
106
  /**
117
- * The token price, if available.
107
+ * The path of the request made by the client.
118
108
  */
119
- price?: Money;
109
+ requestPath: string;
120
110
  /**
121
- * The address balance for the token, in units specified by the `decimals` value for the contract.
111
+ * The number of API credits consumed by the request.
122
112
  */
123
- balance: string;
113
+ apiCreditsConsumed: number;
124
114
  /**
125
- * The monetary value of the balance, if a price is available for the token.
115
+ * The duration of the request in milliseconds.
126
116
  */
127
- balanceValue?: Money;
128
- };
129
-
130
- type GetNativeBalanceResponse = {
117
+ requestDurationMsecs: number;
131
118
  /**
132
- * The native token balance for the address.
119
+ * The response code of the request.
133
120
  */
134
- nativeTokenBalance: NativeTokenBalance;
135
- };
136
-
137
- /**
138
- * The metadata indexing status of the nft.
139
- */
140
- declare enum NftTokenMetadataStatus {
141
- UNKNOWN = "UNKNOWN",
142
- MISSING_TOKEN = "MISSING_TOKEN",
143
- INVALID_TOKEN_URI = "INVALID_TOKEN_URI",
144
- INVALID_TOKEN_URI_SCHEME = "INVALID_TOKEN_URI_SCHEME",
145
- UNREACHABLE_TOKEN_URI = "UNREACHABLE_TOKEN_URI",
146
- THROTTLED_TOKEN_URI = "THROTTLED_TOKEN_URI",
147
- METADATA_CONTENT_TOO_LARGE = "METADATA_CONTENT_TOO_LARGE",
148
- INVALID_METADATA = "INVALID_METADATA",
149
- INVALID_METADATA_JSON = "INVALID_METADATA_JSON",
150
- INDEXED = "INDEXED",
151
- UNINDEXED = "UNINDEXED"
152
- }
153
-
154
- type Erc1155TokenMetadata = {
155
- indexStatus: NftTokenMetadataStatus;
156
- metadataLastUpdatedTimestamp?: number;
157
- name?: string;
158
- symbol?: string;
159
- imageUri?: string;
160
- description?: string;
161
- animationUri?: string;
162
- externalUrl?: string;
163
- background?: string;
164
- decimals?: number;
165
- properties?: string;
166
- };
167
-
168
- type Erc1155TokenBalance = {
121
+ responseCode: number;
169
122
  /**
170
- * A wallet or contract address in mixed-case checksum encoding.
123
+ * The chain id of the request.
171
124
  */
172
- address: string;
173
- ercType: Erc1155TokenBalance.ercType;
174
- tokenId: string;
175
- tokenUri: string;
176
- metadata: Erc1155TokenMetadata;
125
+ chainId?: string;
177
126
  /**
178
- * The evm chain id.
127
+ * The rpc method of the request.
179
128
  */
180
- chainId: string;
129
+ rpcMethod?: string;
181
130
  /**
182
- * The address balance for the token, in units specified by the `decimals` value for the contract.
131
+ * The metadata of the request.
183
132
  */
184
- balance: string;
185
- };
186
- declare namespace Erc1155TokenBalance {
187
- enum ercType {
188
- ERC_1155 = "ERC-1155"
189
- }
190
- }
191
-
192
- type Erc721TokenMetadata = {
193
- indexStatus: NftTokenMetadataStatus;
194
- metadataLastUpdatedTimestamp?: number;
195
- name?: string;
196
- symbol?: string;
197
- imageUri?: string;
198
- description?: string;
199
- animationUri?: string;
200
- externalUrl?: string;
201
- background?: string;
202
- attributes?: string;
133
+ metadata: LogsFormatMetadata;
203
134
  };
204
135
 
205
- type Erc721TokenBalance = {
206
- /**
207
- * A wallet or contract address in mixed-case checksum encoding.
208
- */
209
- address: string;
210
- /**
211
- * The contract name.
212
- */
213
- name: string;
136
+ type LogsResponseDTO = {
214
137
  /**
215
- * The contract symbol.
138
+ * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
216
139
  */
217
- symbol: string;
218
- ercType: Erc721TokenBalance.ercType;
219
- tokenId: string;
220
- tokenUri: string;
221
- metadata: Erc721TokenMetadata;
140
+ nextPageToken?: string;
222
141
  /**
223
- * A wallet or contract address in mixed-case checksum encoding.
142
+ * The organization id of the request.
224
143
  */
225
- ownerAddress?: string;
144
+ orgId: string;
226
145
  /**
227
- * The evm chain id.
146
+ * An array of logs representing the requests made by clients.
228
147
  */
229
- chainId: string;
148
+ logs: Array<LogsFormat>;
230
149
  };
231
- declare namespace Erc721TokenBalance {
232
- enum ercType {
233
- ERC_721 = "ERC-721"
234
- }
150
+
151
+ declare enum TimeIntervalGranularityExtended {
152
+ MINUTE = "minute",
153
+ HOURLY = "hourly",
154
+ DAILY = "daily",
155
+ WEEKLY = "weekly",
156
+ MONTHLY = "monthly"
235
157
  }
236
158
 
237
- type ListCollectibleBalancesResponse = {
238
- /**
239
- * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
240
- */
241
- nextPageToken?: string;
242
- /**
243
- * The list of ERC-721 and ERC-1155 token balances for the address.
244
- */
245
- collectibleBalances: Array<(Erc721TokenBalance | Erc1155TokenBalance)>;
246
- };
159
+ declare enum UsageMetricsGroupByEnum {
160
+ REQUEST_PATH = "requestPath",
161
+ RESPONSE_CODE = "responseCode",
162
+ CHAIN_ID = "chainId",
163
+ API_KEY_ID = "apiKeyId",
164
+ REQUEST_TYPE = "requestType"
165
+ }
247
166
 
248
- type ListErc1155BalancesResponse = {
167
+ type UsageMetricsValueDTO = {
249
168
  /**
250
- * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
169
+ * Column name used for data aggregation
251
170
  */
252
- nextPageToken?: string;
171
+ groupedBy: UsageMetricsValueDTO.groupedBy;
253
172
  /**
254
- * The list of ERC-1155 token balances for the address.
173
+ * The value of the column used for data aggregation
255
174
  */
256
- erc1155TokenBalances: Array<Erc1155TokenBalance>;
257
- };
258
-
259
- type Erc20TokenBalance = {
175
+ groupValue?: (string | number);
260
176
  /**
261
- * A wallet or contract address in mixed-case checksum encoding.
177
+ * The total number of requests
262
178
  */
263
- address: string;
179
+ totalRequests: number;
264
180
  /**
265
- * The contract name.
181
+ * The number of requests per second
266
182
  */
267
- name: string;
183
+ requestsPerSecond: number;
268
184
  /**
269
- * The contract symbol.
185
+ * The success rate percentage
270
186
  */
271
- symbol: string;
187
+ successRatePercent: number;
272
188
  /**
273
- * The number of decimals the token uses. For example `6`, means to divide the token amount by `1000000` to get its user representation.
189
+ * The median response time in milliseconds
274
190
  */
275
- decimals: number;
191
+ medianResponseTimeMsecs: number;
276
192
  /**
277
- * The logo uri for the address.
193
+ * The number of invalid requests
278
194
  */
279
- logoUri?: string;
280
- ercType: Erc20TokenBalance.ercType;
195
+ invalidRequests: number;
281
196
  /**
282
- * The token price, if available.
197
+ * The number of API credits used
283
198
  */
284
- price?: Money;
199
+ apiCreditsUsed: number;
285
200
  /**
286
- * The evm chain id.
201
+ * The number of API credits wasted on invalid requests
287
202
  */
288
- chainId: string;
203
+ apiCreditsWasted: number;
204
+ };
205
+ declare namespace UsageMetricsValueDTO {
289
206
  /**
290
- * The address balance for the token, in units specified by the `decimals` value for the contract.
291
- */
292
- balance: string;
293
- /**
294
- * The monetary value of the balance, if a price is available for the token.
207
+ * Column name used for data aggregation
295
208
  */
296
- balanceValue?: Money;
297
- };
298
- declare namespace Erc20TokenBalance {
299
- enum ercType {
300
- ERC_20 = "ERC-20"
209
+ enum groupedBy {
210
+ REQUEST_PATH = "requestPath",
211
+ RESPONSE_CODE = "responseCode",
212
+ CHAIN_ID = "chainId",
213
+ API_KEY_ID = "apiKeyId",
214
+ REQUEST_TYPE = "requestType",
215
+ NONE = "None"
301
216
  }
302
217
  }
303
218
 
304
- type ListErc20BalancesResponse = {
219
+ type Metric = {
305
220
  /**
306
- * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
221
+ * The timestamp of the metrics value
307
222
  */
308
- nextPageToken?: string;
223
+ timestamp: number;
309
224
  /**
310
- * The list of ERC-20 token balances for the address.
225
+ * The metrics values for the timestamp
311
226
  */
312
- erc20TokenBalances: Array<Erc20TokenBalance>;
227
+ values: Array<UsageMetricsValueDTO>;
313
228
  };
314
229
 
315
- type ListErc721BalancesResponse = {
230
+ type UsageMetricsResponseDTO = {
316
231
  /**
317
- * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
232
+ * Duration in which the metrics value is aggregated
318
233
  */
319
- nextPageToken?: string;
234
+ aggregateDuration: string;
320
235
  /**
321
- * The list of ERC-721 token balances for the address.
236
+ * Org ID for which the metrics are aggregated
322
237
  */
323
- erc721TokenBalances: Array<Erc721TokenBalance>;
238
+ orgId: string;
239
+ /**
240
+ * Metrics values
241
+ */
242
+ metrics: Array<Metric>;
324
243
  };
325
244
 
326
- declare class EvmBalancesService {
245
+ declare class DataApiUsageMetricsService {
327
246
  readonly httpRequest: BaseHttpRequest;
328
247
  constructor(httpRequest: BaseHttpRequest);
329
248
  /**
330
- * Get native token balance
331
- * Gets native token balance of a wallet address.
332
- *
333
- * Balance at a given block can be retrieved with the `blockNumber` parameter.
334
- * @returns GetNativeBalanceResponse Successful response
249
+ * Get usage metrics for the Data API
250
+ * Gets metrics for Data API usage over a specified time interval aggregated at the specified time-duration granularity.
251
+ * @returns UsageMetricsResponseDTO Successful response
335
252
  * @throws ApiError
336
253
  */
337
- getNativeBalance({ chainId, address, blockNumber, currency, }: {
338
- /**
339
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
340
- */
341
- chainId: string;
342
- /**
343
- * A wallet address.
344
- */
345
- address: string;
254
+ getApiUsageMetrics({ orgId, startTimestamp, endTimestamp, timeInterval, groupBy, requestPath, requestType, responseCode, chainId, apiKeyId, }: {
346
255
  /**
347
- * The block number, if not defined the block number will be the latest block.
256
+ * Organization ID to fetch usage metrics for
348
257
  */
349
- blockNumber?: string;
258
+ orgId?: string;
350
259
  /**
351
- * The currency that return values should use. Defaults to USD.
260
+ * Query param for retrieving items after a specific timestamp.
352
261
  */
353
- currency?: CurrencyCode;
354
- }): CancelablePromise<GetNativeBalanceResponse>;
355
- /**
356
- * List ERC-20 balances
357
- * Lists ERC-20 token balances of a wallet address.
358
- *
359
- * Balance at a given block can be retrieved with the `blockNumber` parameter.
360
- *
361
- * Balance for specific contracts can be retrieved with the `contractAddresses` parameter.
362
- * @returns ListErc20BalancesResponse Successful response
363
- * @throws ApiError
364
- */
365
- listErc20Balances({ chainId, address, blockNumber, pageToken, pageSize, filterSpamTokens, contractAddresses, currency, }: {
262
+ startTimestamp?: number;
366
263
  /**
367
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
264
+ * Query param for retrieving items before a specific timestamp.
368
265
  */
369
- chainId: string;
266
+ endTimestamp?: number;
370
267
  /**
371
- * A wallet address.
268
+ * Time interval granularity for data aggregation
372
269
  */
373
- address: string;
270
+ timeInterval?: TimeIntervalGranularityExtended;
374
271
  /**
375
- * The block number, if not defined the block number will be the latest block.
272
+ * Query param for the criterion used for grouping metrics
376
273
  */
377
- blockNumber?: string;
274
+ groupBy?: UsageMetricsGroupByEnum;
378
275
  /**
379
- * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
276
+ * Filter data by request path.
380
277
  */
381
- pageToken?: string;
278
+ requestPath?: string;
382
279
  /**
383
- * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
280
+ * Filter data by request type.
384
281
  */
385
- pageSize?: number;
282
+ requestType?: 'data' | 'rpc';
386
283
  /**
387
- * whether to filter out spam tokens from the response. Default is true.
284
+ * Filter data by response status code.
388
285
  */
389
- filterSpamTokens?: boolean;
286
+ responseCode?: string;
390
287
  /**
391
- * A comma separated list of contract addresses to filter by.
288
+ * Filter data by chain ID.
392
289
  */
393
- contractAddresses?: string;
290
+ chainId?: string;
394
291
  /**
395
- * The currency that return values should use. Defaults to USD.
292
+ * Filter data by API key ID.
396
293
  */
397
- currency?: CurrencyCode;
398
- }): CancelablePromise<ListErc20BalancesResponse>;
294
+ apiKeyId?: string;
295
+ }): CancelablePromise<UsageMetricsResponseDTO>;
399
296
  /**
400
- * List ERC-721 balances
401
- * Lists ERC-721 token balances of a wallet address.
402
- *
403
- * Balance for a specific contract can be retrieved with the `contractAddress` parameter.
404
- * @returns ListErc721BalancesResponse Successful response
297
+ * Get logs for requests made by client
298
+ * Gets logs for requests made by client over a specified time interval for a specific organization.
299
+ * @returns LogsResponseDTO Successful response
405
300
  * @throws ApiError
406
301
  */
407
- listErc721Balances({ chainId, address, pageToken, pageSize, contractAddress, }: {
302
+ getApiLogs({ orgId, startTimestamp, endTimestamp, requestPath, requestType, responseCode, chainId, apiKeyId, pageToken, pageSize, }: {
408
303
  /**
409
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
304
+ * Organization ID to fetch usage metrics for
410
305
  */
411
- chainId: string;
306
+ orgId?: string;
412
307
  /**
413
- * A wallet address.
308
+ * Query param for retrieving items after a specific timestamp.
414
309
  */
415
- address: string;
310
+ startTimestamp?: number;
416
311
  /**
417
- * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
312
+ * Query param for retrieving items before a specific timestamp.
418
313
  */
419
- pageToken?: string;
314
+ endTimestamp?: number;
420
315
  /**
421
- * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
316
+ * Filter data by request path.
422
317
  */
423
- pageSize?: number;
318
+ requestPath?: string;
424
319
  /**
425
- * A contract addresses to filter by.
320
+ * Filter data by request type.
426
321
  */
427
- contractAddress?: string;
428
- }): CancelablePromise<ListErc721BalancesResponse>;
429
- /**
430
- * List ERC-1155 balances
431
- * Lists ERC-1155 token balances of a wallet address.
432
- *
433
- * Balance at a given block can be retrieved with the `blockNumber` parameter.
434
- *
435
- * Balance for a specific contract can be retrieved with the `contractAddress` parameter.
436
- * @returns ListErc1155BalancesResponse Successful response
437
- * @throws ApiError
438
- */
439
- listErc1155Balances({ chainId, address, blockNumber, pageToken, pageSize, contractAddress, }: {
322
+ requestType?: 'data' | 'rpc';
440
323
  /**
441
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
324
+ * Filter data by response status code.
442
325
  */
443
- chainId: string;
326
+ responseCode?: string;
444
327
  /**
445
- * A wallet address.
328
+ * Filter data by chain ID.
446
329
  */
447
- address: string;
330
+ chainId?: string;
448
331
  /**
449
- * The block number, if not defined the block number will be the latest block.
332
+ * Filter data by API key ID.
450
333
  */
451
- blockNumber?: string;
334
+ apiKeyId?: string;
452
335
  /**
453
336
  * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
454
337
  */
455
338
  pageToken?: string;
456
339
  /**
457
- * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
340
+ * The maximum number of items to return.
458
341
  */
459
342
  pageSize?: number;
460
- /**
461
- * A contract addresses to filter by.
462
- */
463
- contractAddress?: string;
464
- }): CancelablePromise<ListErc1155BalancesResponse>;
343
+ }): CancelablePromise<LogsResponseDTO>;
344
+ }
345
+
346
+ declare class DefaultService {
347
+ readonly httpRequest: BaseHttpRequest;
348
+ constructor(httpRequest: BaseHttpRequest);
465
349
  /**
466
- * List collectible (ERC-721/ERC-1155) balances
467
- * Lists ERC-721 and ERC-1155 token balances of a wallet address.
468
- *
469
- * Balance for a specific contract can be retrieved with the `contractAddress` parameter.
470
- * @returns ListCollectibleBalancesResponse Successful response
350
+ * @returns any
471
351
  * @throws ApiError
472
352
  */
473
- listCollectibleBalances({ chainId, address, pageToken, pageSize, contractAddress, }: {
474
- /**
475
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
476
- */
477
- chainId: string;
478
- /**
479
- * A wallet address.
480
- */
481
- address: string;
482
- /**
483
- * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
484
- */
485
- pageToken?: string;
486
- /**
487
- * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
488
- */
489
- pageSize?: number;
490
- /**
491
- * A contract addresses to filter by.
492
- */
493
- contractAddress?: string;
494
- }): CancelablePromise<ListCollectibleBalancesResponse>;
353
+ mediaControllerUploadImage(): CancelablePromise<any>;
495
354
  }
496
355
 
497
- type GetEvmBlockResponse = {
356
+ /**
357
+ * ISO 4217 currency code.
358
+ */
359
+ declare enum CurrencyCode {
360
+ USD = "usd",
361
+ EUR = "eur",
362
+ AUD = "aud",
363
+ CAD = "cad",
364
+ CHF = "chf",
365
+ CLP = "clp",
366
+ CNY = "cny",
367
+ CZK = "czk",
368
+ DKK = "dkk",
369
+ GBP = "gbp",
370
+ HKD = "hkd",
371
+ HUF = "huf",
372
+ JPY = "jpy",
373
+ NZD = "nzd"
374
+ }
375
+
376
+ type Money = {
377
+ currencyCode: CurrencyCode;
498
378
  /**
499
- * The block number on the chain.
379
+ * Monetary value in base 10 decimals.
500
380
  */
501
- blockNumber: string;
381
+ value: number;
382
+ };
383
+
384
+ type NativeTokenBalance = {
502
385
  /**
503
- * The block finality timestamp.
386
+ * The contract name.
504
387
  */
505
- blockTimestamp: number;
388
+ name: string;
506
389
  /**
507
- * The block hash identifier.
390
+ * The contract symbol.
508
391
  */
509
- blockHash: string;
392
+ symbol: string;
510
393
  /**
511
- * The number of evm transactions in the block.
394
+ * The number of decimals the token uses. For example `6`, means to divide the token amount by `1000000` to get its user representation.
512
395
  */
513
- txCount: number;
396
+ decimals: number;
514
397
  /**
515
- * The base gas fee for a transaction to be included in the block.
398
+ * The logo uri for the address.
516
399
  */
517
- baseFee: string;
400
+ logoUri?: string;
518
401
  /**
519
- * The gas used for transactions in the block.
402
+ * The evm chain id.
520
403
  */
521
- gasUsed: string;
404
+ chainId: string;
522
405
  /**
523
- * The total gas limit set for transactions in the block.
406
+ * The token price, if available.
524
407
  */
525
- gasLimit: string;
526
- gasCost: string;
408
+ price?: Money;
527
409
  /**
528
- * The hash of the parent block.
410
+ * The address balance for the token, in units specified by the `decimals` value for the contract.
529
411
  */
530
- parentHash: string;
412
+ balance: string;
531
413
  /**
532
- * The amount of fees spent/burned for transactions in the block.
414
+ * The monetary value of the balance, if a price is available for the token.
533
415
  */
534
- feesSpent: string;
416
+ balanceValue?: Money;
417
+ };
418
+
419
+ type GetNativeBalanceResponse = {
535
420
  /**
536
- * The cumulative number of transactions for the chain including this block.
421
+ * The native token balance for the address.
537
422
  */
538
- cumulativeTransactions: string;
423
+ nativeTokenBalance: NativeTokenBalance;
539
424
  };
540
425
 
541
- type EvmBlock = {
426
+ /**
427
+ * The metadata indexing status of the nft.
428
+ */
429
+ declare enum NftTokenMetadataStatus {
430
+ UNKNOWN = "UNKNOWN",
431
+ MISSING_TOKEN = "MISSING_TOKEN",
432
+ INVALID_TOKEN_URI = "INVALID_TOKEN_URI",
433
+ INVALID_TOKEN_URI_SCHEME = "INVALID_TOKEN_URI_SCHEME",
434
+ UNREACHABLE_TOKEN_URI = "UNREACHABLE_TOKEN_URI",
435
+ THROTTLED_TOKEN_URI = "THROTTLED_TOKEN_URI",
436
+ METADATA_CONTENT_TOO_LARGE = "METADATA_CONTENT_TOO_LARGE",
437
+ INVALID_METADATA = "INVALID_METADATA",
438
+ INVALID_METADATA_JSON = "INVALID_METADATA_JSON",
439
+ INDEXED = "INDEXED",
440
+ UNINDEXED = "UNINDEXED"
441
+ }
442
+
443
+ type Erc1155TokenMetadata = {
444
+ indexStatus: NftTokenMetadataStatus;
445
+ metadataLastUpdatedTimestamp?: number;
446
+ name?: string;
447
+ symbol?: string;
448
+ imageUri?: string;
449
+ description?: string;
450
+ animationUri?: string;
451
+ externalUrl?: string;
452
+ background?: string;
453
+ decimals?: number;
454
+ properties?: string;
455
+ };
456
+
457
+ type Erc1155TokenBalance = {
542
458
  /**
543
- * The block number on the chain.
459
+ * A wallet or contract address in mixed-case checksum encoding.
544
460
  */
545
- blockNumber: string;
461
+ address: string;
462
+ ercType: Erc1155TokenBalance.ercType;
463
+ tokenId: string;
464
+ tokenUri: string;
465
+ metadata: Erc1155TokenMetadata;
546
466
  /**
547
- * The block finality timestamp.
467
+ * The evm chain id.
548
468
  */
549
- blockTimestamp: number;
469
+ chainId: string;
550
470
  /**
551
- * The block hash identifier.
471
+ * The address balance for the token, in units specified by the `decimals` value for the contract.
552
472
  */
553
- blockHash: string;
473
+ balance: string;
474
+ };
475
+ declare namespace Erc1155TokenBalance {
476
+ enum ercType {
477
+ ERC_1155 = "ERC-1155"
478
+ }
479
+ }
480
+
481
+ type Erc721TokenMetadata = {
482
+ indexStatus: NftTokenMetadataStatus;
483
+ metadataLastUpdatedTimestamp?: number;
484
+ name?: string;
485
+ symbol?: string;
486
+ imageUri?: string;
487
+ description?: string;
488
+ animationUri?: string;
489
+ externalUrl?: string;
490
+ background?: string;
491
+ attributes?: string;
492
+ };
493
+
494
+ type Erc721TokenBalance = {
554
495
  /**
555
- * The number of evm transactions in the block.
496
+ * A wallet or contract address in mixed-case checksum encoding.
556
497
  */
557
- txCount: number;
498
+ address: string;
558
499
  /**
559
- * The base gas fee for a transaction to be included in the block.
500
+ * The contract name.
560
501
  */
561
- baseFee: string;
502
+ name: string;
562
503
  /**
563
- * The gas used for transactions in the block.
504
+ * The contract symbol.
564
505
  */
565
- gasUsed: string;
506
+ symbol: string;
507
+ ercType: Erc721TokenBalance.ercType;
508
+ tokenId: string;
509
+ tokenUri: string;
510
+ metadata: Erc721TokenMetadata;
566
511
  /**
567
- * The total gas limit set for transactions in the block.
512
+ * A wallet or contract address in mixed-case checksum encoding.
568
513
  */
569
- gasLimit: string;
570
- gasCost: string;
514
+ ownerAddress?: string;
571
515
  /**
572
- * The hash of the parent block.
516
+ * The evm chain id.
573
517
  */
574
- parentHash: string;
518
+ chainId: string;
519
+ };
520
+ declare namespace Erc721TokenBalance {
521
+ enum ercType {
522
+ ERC_721 = "ERC-721"
523
+ }
524
+ }
525
+
526
+ type ListCollectibleBalancesResponse = {
575
527
  /**
576
- * The amount of fees spent/burned for transactions in the block.
528
+ * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
577
529
  */
578
- feesSpent: string;
530
+ nextPageToken?: string;
579
531
  /**
580
- * The cumulative number of transactions for the chain including this block.
532
+ * The list of ERC-721 and ERC-1155 token balances for the address.
581
533
  */
582
- cumulativeTransactions: string;
534
+ collectibleBalances: Array<(Erc721TokenBalance | Erc1155TokenBalance)>;
583
535
  };
584
536
 
585
- type ListEvmBlocksResponse = {
537
+ type ListErc1155BalancesResponse = {
586
538
  /**
587
539
  * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
588
540
  */
589
541
  nextPageToken?: string;
590
- blocks: Array<EvmBlock>;
591
- };
592
-
593
- declare class EvmBlocksService {
594
- readonly httpRequest: BaseHttpRequest;
595
- constructor(httpRequest: BaseHttpRequest);
596
542
  /**
597
- * List latest blocks
598
- * Lists the latest indexed blocks on the EVM-compatible chain sorted in descending order by block timestamp.
599
- * @returns ListEvmBlocksResponse Successful response
600
- * @throws ApiError
543
+ * The list of ERC-1155 token balances for the address.
601
544
  */
602
- getLatestBlocks({ chainId, pageToken, pageSize, }: {
603
- /**
604
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
605
- */
606
- chainId: string;
607
- /**
608
- * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
609
- */
610
- pageToken?: string;
611
- /**
612
- * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
613
- */
614
- pageSize?: number;
615
- }): CancelablePromise<ListEvmBlocksResponse>;
545
+ erc1155TokenBalances: Array<Erc1155TokenBalance>;
546
+ };
547
+
548
+ type Erc20TokenBalance = {
616
549
  /**
617
- * Get block
618
- * Gets the details of an individual block on the EVM-compatible chain.
619
- * @returns GetEvmBlockResponse Successful response
620
- * @throws ApiError
550
+ * A wallet or contract address in mixed-case checksum encoding.
621
551
  */
622
- getBlock({ chainId, blockId, }: {
623
- /**
624
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
625
- */
626
- chainId: string;
627
- /**
628
- * A block identifier which is either a block number or the block hash.
629
- */
630
- blockId: string;
631
- }): CancelablePromise<GetEvmBlockResponse>;
632
- }
633
-
634
- /**
635
- * Status of chain nodes. Chain nodes can become temporarily `UNAVAILABLE` for several reasons, such as validator stake falling below threshold. If chain nodes are `UNAVAILABLE`, requests that rely on data from the chain nodes may return 503 errors.
636
- */
637
- declare enum ChainStatus {
638
- OK = "OK",
639
- UNAVAILABLE = "UNAVAILABLE"
640
- }
641
-
642
- type NetworkToken = {
552
+ address: string;
643
553
  /**
644
554
  * The contract name.
645
555
  */
@@ -656,727 +566,842 @@ type NetworkToken = {
656
566
  * The logo uri for the address.
657
567
  */
658
568
  logoUri?: string;
659
- description?: string;
660
- };
661
-
662
- type UtilityAddresses = {
663
- multicall?: string;
569
+ ercType: Erc20TokenBalance.ercType;
570
+ /**
571
+ * The token price, if available.
572
+ */
573
+ price?: Money;
574
+ /**
575
+ * The evm chain id.
576
+ */
577
+ chainId: string;
578
+ /**
579
+ * The address balance for the token, in units specified by the `decimals` value for the contract.
580
+ */
581
+ balance: string;
582
+ /**
583
+ * The monetary value of the balance, if a price is available for the token.
584
+ */
585
+ balanceValue?: Money;
664
586
  };
665
-
666
- declare enum VmName {
667
- EVM = "EVM",
668
- BITCOIN = "BITCOIN",
669
- ETHEREUM = "ETHEREUM"
587
+ declare namespace Erc20TokenBalance {
588
+ enum ercType {
589
+ ERC_20 = "ERC-20"
590
+ }
670
591
  }
671
592
 
672
- type GetChainResponse = {
673
- chainId: string;
674
- status: ChainStatus;
675
- chainName: string;
676
- description: string;
677
- platformChainId?: string;
678
- subnetId?: string;
679
- vmId?: string;
680
- vmName: VmName;
681
- explorerUrl?: string;
682
- rpcUrl: string;
683
- wsUrl?: string;
684
- isTestnet: boolean;
685
- utilityAddresses?: UtilityAddresses;
686
- networkToken: NetworkToken;
687
- chainLogoUri?: string;
688
- private?: boolean;
689
- enabledFeatures?: Array<'nftIndexing' | 'webhooks'>;
593
+ type ListErc20BalancesResponse = {
594
+ /**
595
+ * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
596
+ */
597
+ nextPageToken?: string;
598
+ /**
599
+ * The list of ERC-20 token balances for the address.
600
+ */
601
+ erc20TokenBalances: Array<Erc20TokenBalance>;
690
602
  };
691
603
 
692
- declare enum GlacierApiFeature {
693
- NFT_INDEXING = "nftIndexing",
694
- WEBHOOKS = "webhooks"
695
- }
696
-
697
- type ChainInfo = {
698
- chainId: string;
699
- status: ChainStatus;
700
- chainName: string;
701
- description: string;
702
- platformChainId?: string;
703
- subnetId?: string;
704
- vmId?: string;
705
- vmName: VmName;
706
- explorerUrl?: string;
707
- rpcUrl: string;
708
- wsUrl?: string;
709
- isTestnet: boolean;
710
- utilityAddresses?: UtilityAddresses;
711
- networkToken: NetworkToken;
712
- chainLogoUri?: string;
713
- private?: boolean;
714
- enabledFeatures?: Array<'nftIndexing' | 'webhooks'>;
715
- };
716
-
717
- type ListChainsResponse = {
718
- chains: Array<ChainInfo>;
604
+ type ListErc721BalancesResponse = {
605
+ /**
606
+ * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
607
+ */
608
+ nextPageToken?: string;
609
+ /**
610
+ * The list of ERC-721 token balances for the address.
611
+ */
612
+ erc721TokenBalances: Array<Erc721TokenBalance>;
719
613
  };
720
614
 
721
- declare enum NetworkType {
722
- MAINNET = "mainnet",
723
- TESTNET = "testnet"
724
- }
725
-
726
- declare class EvmChainsService {
615
+ declare class EvmBalancesService {
727
616
  readonly httpRequest: BaseHttpRequest;
728
617
  constructor(httpRequest: BaseHttpRequest);
729
618
  /**
730
- * List chains
731
- * Lists the supported EVM-compatible chains. Filterable by network.
732
- * @returns ListChainsResponse Successful response
619
+ * Get native token balance
620
+ * Gets native token balance of a wallet address.
621
+ *
622
+ * Balance at a given block can be retrieved with the `blockNumber` parameter.
623
+ * @returns GetNativeBalanceResponse Successful response
733
624
  * @throws ApiError
734
625
  */
735
- supportedChains({ network, feature, }: {
626
+ getNativeBalance({ chainId, address, blockNumber, currency, }: {
736
627
  /**
737
- * mainnet or testnet.
628
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
738
629
  */
739
- network?: NetworkType;
630
+ chainId: string;
740
631
  /**
741
- * Filter by feature.
632
+ * A wallet address.
742
633
  */
743
- feature?: GlacierApiFeature;
744
- }): CancelablePromise<ListChainsResponse>;
634
+ address: string;
635
+ /**
636
+ * The block number, if not defined the block number will be the latest block.
637
+ */
638
+ blockNumber?: string;
639
+ /**
640
+ * The currency that return values should use. Defaults to USD.
641
+ */
642
+ currency?: CurrencyCode;
643
+ }): CancelablePromise<GetNativeBalanceResponse>;
745
644
  /**
746
- * Get chain information
747
- * Gets chain information for the EVM-compatible chain if supported by the api.
748
- * @returns GetChainResponse Successful response
645
+ * List ERC-20 balances
646
+ * Lists ERC-20 token balances of a wallet address.
647
+ *
648
+ * Balance at a given block can be retrieved with the `blockNumber` parameter.
649
+ *
650
+ * Balance for specific contracts can be retrieved with the `contractAddresses` parameter.
651
+ * @returns ListErc20BalancesResponse Successful response
749
652
  * @throws ApiError
750
653
  */
751
- getChainInfo({ chainId, }: {
654
+ listErc20Balances({ chainId, address, blockNumber, pageToken, pageSize, filterSpamTokens, contractAddresses, currency, }: {
752
655
  /**
753
656
  * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
754
657
  */
755
658
  chainId: string;
756
- }): CancelablePromise<GetChainResponse>;
757
- }
758
-
759
- type ImageAsset = {
760
- assetId?: string;
659
+ /**
660
+ * A wallet address.
661
+ */
662
+ address: string;
663
+ /**
664
+ * The block number, if not defined the block number will be the latest block.
665
+ */
666
+ blockNumber?: string;
667
+ /**
668
+ * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
669
+ */
670
+ pageToken?: string;
671
+ /**
672
+ * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
673
+ */
674
+ pageSize?: number;
675
+ /**
676
+ * whether to filter out spam tokens from the response. Default is true.
677
+ */
678
+ filterSpamTokens?: boolean;
679
+ /**
680
+ * A comma separated list of contract addresses to filter by.
681
+ */
682
+ contractAddresses?: string;
683
+ /**
684
+ * The currency that return values should use. Defaults to USD.
685
+ */
686
+ currency?: CurrencyCode;
687
+ }): CancelablePromise<ListErc20BalancesResponse>;
761
688
  /**
762
- * OUTPUT ONLY
689
+ * List ERC-721 balances
690
+ * Lists ERC-721 token balances of a wallet address.
691
+ *
692
+ * Balance for a specific contract can be retrieved with the `contractAddress` parameter.
693
+ * @returns ListErc721BalancesResponse Successful response
694
+ * @throws ApiError
763
695
  */
764
- imageUri?: string;
765
- };
766
-
767
- type PricingProviders = {
768
- coingeckoCoinId?: string;
769
- };
770
-
771
- declare enum ResourceLinkType {
772
- BLOG = "Blog",
773
- COIN_GECKO = "CoinGecko",
774
- COIN_MARKET_CAP = "CoinMarketCap",
775
- DISCORD = "Discord",
776
- DOCUMENTATION = "Documentation",
777
- FACEBOOK = "Facebook",
778
- GITHUB = "Github",
779
- INSTAGRAM = "Instagram",
780
- LINKED_IN = "LinkedIn",
781
- MEDIUM = "Medium",
782
- REDDIT = "Reddit",
783
- SUPPORT = "Support",
784
- TELEGRAM = "Telegram",
785
- TIK_TOK = "TikTok",
786
- TWITTER = "Twitter",
787
- WEBSITE = "Website",
788
- WHITEPAPER = "Whitepaper",
789
- YOUTUBE = "Youtube"
790
- }
791
-
792
- type ResourceLink = {
793
- type: ResourceLinkType;
794
- url: string;
795
- };
796
-
797
- type ContractSubmissionErc1155 = {
798
- description?: string;
799
- officialSite?: string;
800
- email?: string;
801
- logoAsset?: ImageAsset;
802
- bannerAsset?: ImageAsset;
803
- color?: string;
804
- resourceLinks?: Array<ResourceLink>;
805
- tags?: Array<string>;
696
+ listErc721Balances({ chainId, address, pageToken, pageSize, contractAddress, }: {
697
+ /**
698
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
699
+ */
700
+ chainId: string;
701
+ /**
702
+ * A wallet address.
703
+ */
704
+ address: string;
705
+ /**
706
+ * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
707
+ */
708
+ pageToken?: string;
709
+ /**
710
+ * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
711
+ */
712
+ pageSize?: number;
713
+ /**
714
+ * A contract addresses to filter by.
715
+ */
716
+ contractAddress?: string;
717
+ }): CancelablePromise<ListErc721BalancesResponse>;
806
718
  /**
807
- * The contract name.
719
+ * List ERC-1155 balances
720
+ * Lists ERC-1155 token balances of a wallet address.
721
+ *
722
+ * Balance at a given block can be retrieved with the `blockNumber` parameter.
723
+ *
724
+ * Balance for a specific contract can be retrieved with the `contractAddress` parameter.
725
+ * @returns ListErc1155BalancesResponse Successful response
726
+ * @throws ApiError
808
727
  */
809
- name: string;
810
- ercType: ContractSubmissionErc1155.ercType;
728
+ listErc1155Balances({ chainId, address, blockNumber, pageToken, pageSize, contractAddress, }: {
729
+ /**
730
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
731
+ */
732
+ chainId: string;
733
+ /**
734
+ * A wallet address.
735
+ */
736
+ address: string;
737
+ /**
738
+ * The block number, if not defined the block number will be the latest block.
739
+ */
740
+ blockNumber?: string;
741
+ /**
742
+ * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
743
+ */
744
+ pageToken?: string;
745
+ /**
746
+ * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
747
+ */
748
+ pageSize?: number;
749
+ /**
750
+ * A contract addresses to filter by.
751
+ */
752
+ contractAddress?: string;
753
+ }): CancelablePromise<ListErc1155BalancesResponse>;
811
754
  /**
812
- * The contract symbol.
755
+ * List collectible (ERC-721/ERC-1155) balances
756
+ * Lists ERC-721 and ERC-1155 token balances of a wallet address.
757
+ *
758
+ * Balance for a specific contract can be retrieved with the `contractAddress` parameter.
759
+ * @returns ListCollectibleBalancesResponse Successful response
760
+ * @throws ApiError
813
761
  */
814
- symbol: string;
815
- pricingProviders?: PricingProviders;
816
- };
817
- declare namespace ContractSubmissionErc1155 {
818
- enum ercType {
819
- ERC_1155 = "ERC-1155"
820
- }
762
+ listCollectibleBalances({ chainId, address, pageToken, pageSize, contractAddress, }: {
763
+ /**
764
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
765
+ */
766
+ chainId: string;
767
+ /**
768
+ * A wallet address.
769
+ */
770
+ address: string;
771
+ /**
772
+ * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
773
+ */
774
+ pageToken?: string;
775
+ /**
776
+ * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
777
+ */
778
+ pageSize?: number;
779
+ /**
780
+ * A contract addresses to filter by.
781
+ */
782
+ contractAddress?: string;
783
+ }): CancelablePromise<ListCollectibleBalancesResponse>;
821
784
  }
822
785
 
823
- type ContractSubmissionErc20 = {
824
- description?: string;
825
- officialSite?: string;
826
- email?: string;
827
- logoAsset?: ImageAsset;
828
- bannerAsset?: ImageAsset;
829
- color?: string;
830
- resourceLinks?: Array<ResourceLink>;
831
- tags?: Array<string>;
786
+ type GetEvmBlockResponse = {
832
787
  /**
833
- * The contract name.
788
+ * The block number on the chain.
834
789
  */
835
- name: string;
836
- ercType: ContractSubmissionErc20.ercType;
790
+ blockNumber: string;
837
791
  /**
838
- * The contract symbol.
792
+ * The block finality timestamp.
839
793
  */
840
- symbol: string;
841
- pricingProviders?: PricingProviders;
842
- };
843
- declare namespace ContractSubmissionErc20 {
844
- enum ercType {
845
- ERC_20 = "ERC-20"
846
- }
847
- }
848
-
849
- type ContractSubmissionErc721 = {
850
- description?: string;
851
- officialSite?: string;
852
- email?: string;
853
- logoAsset?: ImageAsset;
854
- bannerAsset?: ImageAsset;
855
- color?: string;
856
- resourceLinks?: Array<ResourceLink>;
857
- tags?: Array<string>;
794
+ blockTimestamp: number;
858
795
  /**
859
- * The contract name.
796
+ * The block hash identifier.
860
797
  */
861
- name: string;
862
- ercType: ContractSubmissionErc721.ercType;
798
+ blockHash: string;
863
799
  /**
864
- * The contract symbol.
800
+ * The number of evm transactions in the block.
865
801
  */
866
- symbol: string;
867
- };
868
- declare namespace ContractSubmissionErc721 {
869
- enum ercType {
870
- ERC_721 = "ERC-721"
871
- }
872
- }
873
-
874
- type ContractSubmissionUnknown = {
875
- description?: string;
876
- officialSite?: string;
877
- email?: string;
878
- logoAsset?: ImageAsset;
879
- bannerAsset?: ImageAsset;
880
- color?: string;
881
- resourceLinks?: Array<ResourceLink>;
882
- tags?: Array<string>;
802
+ txCount: number;
883
803
  /**
884
- * The contract name.
804
+ * The base gas fee for a transaction to be included in the block.
885
805
  */
886
- name: string;
887
- ercType: ContractSubmissionUnknown.ercType;
888
- };
889
- declare namespace ContractSubmissionUnknown {
890
- enum ercType {
891
- UNKNOWN = "UNKNOWN"
892
- }
893
- }
894
-
895
- type ContractSubmissionBody = {
896
- contract: (ContractSubmissionErc1155 | ContractSubmissionErc20 | ContractSubmissionErc721 | ContractSubmissionUnknown);
897
- };
898
-
899
- type ContractDeploymentDetails = {
900
- txHash: string;
806
+ baseFee: string;
901
807
  /**
902
- * The address that initiated the transaction which deployed this contract.
808
+ * The gas used for transactions in the block.
903
809
  */
904
- deployerAddress: string;
810
+ gasUsed: string;
905
811
  /**
906
- * The contract address which deployed this contract via smart contract. This field is only populated when the contract was deployed as part of smart contract execution.
812
+ * The total gas limit set for transactions in the block.
907
813
  */
908
- deployerContractAddress?: string;
909
- };
910
-
911
- type Erc1155Contract = {
814
+ gasLimit: string;
815
+ gasCost: string;
912
816
  /**
913
- * The contract name.
817
+ * The hash of the parent block.
914
818
  */
915
- name?: string;
916
- description?: string;
917
- officialSite?: string;
918
- email?: string;
919
- logoAsset?: ImageAsset;
920
- bannerAsset?: ImageAsset;
921
- color?: string;
922
- resourceLinks?: Array<ResourceLink>;
923
- tags?: Array<string>;
819
+ parentHash: string;
924
820
  /**
925
- * A wallet or contract address in mixed-case checksum encoding.
821
+ * The amount of fees spent/burned for transactions in the block.
926
822
  */
927
- address: string;
928
- deploymentDetails: ContractDeploymentDetails;
929
- ercType: Erc1155Contract.ercType;
823
+ feesSpent: string;
930
824
  /**
931
- * The contract symbol.
825
+ * The cumulative number of transactions for the chain including this block.
932
826
  */
933
- symbol?: string;
934
- pricingProviders?: PricingProviders;
827
+ cumulativeTransactions: string;
935
828
  };
936
- declare namespace Erc1155Contract {
937
- enum ercType {
938
- ERC_1155 = "ERC-1155"
939
- }
940
- }
941
829
 
942
- type Erc20Contract = {
830
+ type EvmBlock = {
943
831
  /**
944
- * The contract name.
832
+ * The block number on the chain.
945
833
  */
946
- name?: string;
947
- description?: string;
948
- officialSite?: string;
949
- email?: string;
950
- logoAsset?: ImageAsset;
951
- bannerAsset?: ImageAsset;
952
- color?: string;
953
- resourceLinks?: Array<ResourceLink>;
954
- tags?: Array<string>;
834
+ blockNumber: string;
955
835
  /**
956
- * A wallet or contract address in mixed-case checksum encoding.
836
+ * The block finality timestamp.
957
837
  */
958
- address: string;
959
- deploymentDetails: ContractDeploymentDetails;
960
- ercType: Erc20Contract.ercType;
838
+ blockTimestamp: number;
961
839
  /**
962
- * The contract symbol.
840
+ * The block hash identifier.
963
841
  */
964
- symbol?: string;
842
+ blockHash: string;
965
843
  /**
966
- * The number of decimals the token uses. For example `6`, means to divide the token amount by `1000000` to get its user representation.
844
+ * The number of evm transactions in the block.
967
845
  */
968
- decimals: number;
969
- pricingProviders?: PricingProviders;
970
- };
971
- declare namespace Erc20Contract {
972
- enum ercType {
973
- ERC_20 = "ERC-20"
974
- }
975
- }
976
-
977
- type Erc721Contract = {
846
+ txCount: number;
978
847
  /**
979
- * The contract name.
848
+ * The base gas fee for a transaction to be included in the block.
980
849
  */
981
- name?: string;
982
- description?: string;
983
- officialSite?: string;
984
- email?: string;
985
- logoAsset?: ImageAsset;
986
- bannerAsset?: ImageAsset;
987
- color?: string;
988
- resourceLinks?: Array<ResourceLink>;
989
- tags?: Array<string>;
850
+ baseFee: string;
990
851
  /**
991
- * A wallet or contract address in mixed-case checksum encoding.
852
+ * The gas used for transactions in the block.
992
853
  */
993
- address: string;
994
- deploymentDetails: ContractDeploymentDetails;
995
- ercType: Erc721Contract.ercType;
854
+ gasUsed: string;
996
855
  /**
997
- * The contract symbol.
856
+ * The total gas limit set for transactions in the block.
998
857
  */
999
- symbol?: string;
1000
- };
1001
- declare namespace Erc721Contract {
1002
- enum ercType {
1003
- ERC_721 = "ERC-721"
1004
- }
1005
- }
1006
-
1007
- type UnknownContract = {
858
+ gasLimit: string;
859
+ gasCost: string;
1008
860
  /**
1009
- * The contract name.
861
+ * The hash of the parent block.
1010
862
  */
1011
- name?: string;
1012
- description?: string;
1013
- officialSite?: string;
1014
- email?: string;
1015
- logoAsset?: ImageAsset;
1016
- bannerAsset?: ImageAsset;
1017
- color?: string;
1018
- resourceLinks?: Array<ResourceLink>;
1019
- tags?: Array<string>;
863
+ parentHash: string;
1020
864
  /**
1021
- * A wallet or contract address in mixed-case checksum encoding.
865
+ * The amount of fees spent/burned for transactions in the block.
1022
866
  */
1023
- address: string;
1024
- deploymentDetails: ContractDeploymentDetails;
1025
- ercType: UnknownContract.ercType;
867
+ feesSpent: string;
868
+ /**
869
+ * The cumulative number of transactions for the chain including this block.
870
+ */
871
+ cumulativeTransactions: string;
1026
872
  };
1027
- declare namespace UnknownContract {
1028
- enum ercType {
1029
- UNKNOWN = "UNKNOWN"
1030
- }
1031
- }
1032
873
 
1033
- type UpdateContractResponse = {
1034
- contract: (UnknownContract | Erc20Contract | Erc721Contract | Erc1155Contract);
874
+ type ListEvmBlocksResponse = {
875
+ /**
876
+ * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
877
+ */
878
+ nextPageToken?: string;
879
+ blocks: Array<EvmBlock>;
1035
880
  };
1036
881
 
1037
- declare class EvmContractsService {
882
+ declare class EvmBlocksService {
1038
883
  readonly httpRequest: BaseHttpRequest;
1039
884
  constructor(httpRequest: BaseHttpRequest);
1040
885
  /**
1041
- * Get contract metadata
1042
- * Gets metadata about the contract at the given address.
1043
- * @returns any Successful response
886
+ * List latest blocks
887
+ * Lists the latest indexed blocks on the EVM-compatible chain sorted in descending order by block timestamp.
888
+ * @returns ListEvmBlocksResponse Successful response
1044
889
  * @throws ApiError
1045
890
  */
1046
- getContractMetadata({ chainId, address, }: {
891
+ getLatestBlocks({ chainId, pageToken, pageSize, }: {
1047
892
  /**
1048
893
  * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1049
894
  */
1050
895
  chainId: string;
1051
896
  /**
1052
- * Contract address on the relevant chain.
897
+ * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
1053
898
  */
1054
- address: string;
1055
- }): CancelablePromise<(Erc721Contract | Erc1155Contract | Erc20Contract | UnknownContract)>;
899
+ pageToken?: string;
900
+ /**
901
+ * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
902
+ */
903
+ pageSize?: number;
904
+ }): CancelablePromise<ListEvmBlocksResponse>;
1056
905
  /**
1057
- * Update contract information
1058
- * Update contract information. Updates will be reviewed by the Ava Labs team before they are published.
1059
- * @returns UpdateContractResponse Successful response
906
+ * Get block
907
+ * Gets the details of an individual block on the EVM-compatible chain.
908
+ * @returns GetEvmBlockResponse Successful response
1060
909
  * @throws ApiError
1061
910
  */
1062
- updateContractInfo({ chainId, address, requestBody, }: {
911
+ getBlock({ chainId, blockId, }: {
1063
912
  /**
1064
913
  * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1065
914
  */
1066
915
  chainId: string;
1067
916
  /**
1068
- * Contract address on the relevant chain.
917
+ * A block identifier which is either a block number or the block hash.
1069
918
  */
1070
- address: string;
1071
- requestBody: ContractSubmissionBody;
1072
- }): CancelablePromise<UpdateContractResponse>;
919
+ blockId: string;
920
+ }): CancelablePromise<GetEvmBlockResponse>;
1073
921
  }
1074
922
 
1075
- type Erc1155Token = {
1076
- /**
1077
- * A wallet or contract address in mixed-case checksum encoding.
1078
- */
1079
- address: string;
1080
- ercType: Erc1155Token.ercType;
1081
- tokenId: string;
1082
- tokenUri: string;
1083
- metadata: Erc1155TokenMetadata;
1084
- };
1085
- declare namespace Erc1155Token {
1086
- enum ercType {
1087
- ERC_1155 = "ERC-1155"
1088
- }
923
+ declare enum ApiFeature {
924
+ NFT_INDEXING = "nftIndexing",
925
+ WEBHOOKS = "webhooks",
926
+ TELEPORTER = "teleporter"
1089
927
  }
1090
928
 
1091
- type RichAddress = {
929
+ /**
930
+ * Status of chain nodes. Chain nodes can become temporarily `UNAVAILABLE` for several reasons, such as validator stake falling below threshold. If chain nodes are `UNAVAILABLE`, requests that rely on data from the chain nodes may return 503 errors.
931
+ */
932
+ declare enum ChainStatus {
933
+ OK = "OK",
934
+ UNAVAILABLE = "UNAVAILABLE"
935
+ }
936
+
937
+ type NetworkToken = {
1092
938
  /**
1093
939
  * The contract name.
1094
940
  */
1095
- name?: string;
941
+ name: string;
1096
942
  /**
1097
943
  * The contract symbol.
1098
944
  */
1099
- symbol?: string;
945
+ symbol: string;
1100
946
  /**
1101
947
  * The number of decimals the token uses. For example `6`, means to divide the token amount by `1000000` to get its user representation.
1102
948
  */
1103
- decimals?: number;
949
+ decimals: number;
1104
950
  /**
1105
951
  * The logo uri for the address.
1106
952
  */
1107
953
  logoUri?: string;
1108
- /**
1109
- * A wallet or contract address in mixed-case checksum encoding.
1110
- */
1111
- address: string;
954
+ description?: string;
1112
955
  };
1113
956
 
1114
- type Erc1155TransferDetails = {
1115
- from: RichAddress;
1116
- to: RichAddress;
1117
- logIndex: number;
1118
- value: string;
1119
- erc1155Token: Erc1155Token;
957
+ type UtilityAddresses = {
958
+ multicall?: string;
1120
959
  };
1121
960
 
1122
- type Erc20Token = {
961
+ declare enum VmName {
962
+ EVM = "EVM",
963
+ BITCOIN = "BITCOIN",
964
+ ETHEREUM = "ETHEREUM"
965
+ }
966
+
967
+ type GetChainResponse = {
968
+ chainId: string;
969
+ status: ChainStatus;
970
+ chainName: string;
971
+ description: string;
972
+ platformChainId?: string;
973
+ subnetId?: string;
974
+ vmId?: string;
975
+ vmName: VmName;
976
+ explorerUrl?: string;
977
+ rpcUrl: string;
978
+ wsUrl?: string;
979
+ isTestnet: boolean;
980
+ utilityAddresses?: UtilityAddresses;
981
+ networkToken: NetworkToken;
982
+ chainLogoUri?: string;
983
+ private?: boolean;
984
+ enabledFeatures?: Array<'nftIndexing' | 'webhooks' | 'teleporter'>;
985
+ };
986
+
987
+ type ChainInfo = {
988
+ chainId: string;
989
+ status: ChainStatus;
990
+ chainName: string;
991
+ description: string;
992
+ platformChainId?: string;
993
+ subnetId?: string;
994
+ vmId?: string;
995
+ vmName: VmName;
996
+ explorerUrl?: string;
997
+ rpcUrl: string;
998
+ wsUrl?: string;
999
+ isTestnet: boolean;
1000
+ utilityAddresses?: UtilityAddresses;
1001
+ networkToken: NetworkToken;
1002
+ chainLogoUri?: string;
1003
+ private?: boolean;
1004
+ enabledFeatures?: Array<'nftIndexing' | 'webhooks' | 'teleporter'>;
1005
+ };
1006
+
1007
+ type ListChainsResponse = {
1008
+ chains: Array<ChainInfo>;
1009
+ };
1010
+
1011
+ declare enum NetworkType {
1012
+ MAINNET = "mainnet",
1013
+ TESTNET = "testnet"
1014
+ }
1015
+
1016
+ declare class EvmChainsService {
1017
+ readonly httpRequest: BaseHttpRequest;
1018
+ constructor(httpRequest: BaseHttpRequest);
1123
1019
  /**
1124
- * A wallet or contract address in mixed-case checksum encoding.
1020
+ * List chains
1021
+ * Lists the supported EVM-compatible chains. Filterable by network.
1022
+ * @returns ListChainsResponse Successful response
1023
+ * @throws ApiError
1125
1024
  */
1126
- address: string;
1025
+ supportedChains({ network, feature, }: {
1026
+ /**
1027
+ * mainnet or testnet.
1028
+ */
1029
+ network?: NetworkType;
1030
+ /**
1031
+ * Filter by feature.
1032
+ */
1033
+ feature?: ApiFeature;
1034
+ }): CancelablePromise<ListChainsResponse>;
1035
+ /**
1036
+ * Get chain information
1037
+ * Gets chain information for the EVM-compatible chain if supported by the api.
1038
+ * @returns GetChainResponse Successful response
1039
+ * @throws ApiError
1040
+ */
1041
+ getChainInfo({ chainId, }: {
1042
+ /**
1043
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1044
+ */
1045
+ chainId: string;
1046
+ }): CancelablePromise<GetChainResponse>;
1047
+ }
1048
+
1049
+ type ImageAsset = {
1050
+ assetId?: string;
1051
+ /**
1052
+ * OUTPUT ONLY
1053
+ */
1054
+ imageUri?: string;
1055
+ };
1056
+
1057
+ type PricingProviders = {
1058
+ coingeckoCoinId?: string;
1059
+ };
1060
+
1061
+ declare enum ResourceLinkType {
1062
+ BLOG = "Blog",
1063
+ COIN_GECKO = "CoinGecko",
1064
+ COIN_MARKET_CAP = "CoinMarketCap",
1065
+ DISCORD = "Discord",
1066
+ DOCUMENTATION = "Documentation",
1067
+ FACEBOOK = "Facebook",
1068
+ GITHUB = "Github",
1069
+ INSTAGRAM = "Instagram",
1070
+ LINKED_IN = "LinkedIn",
1071
+ MEDIUM = "Medium",
1072
+ REDDIT = "Reddit",
1073
+ SUPPORT = "Support",
1074
+ TELEGRAM = "Telegram",
1075
+ TIK_TOK = "TikTok",
1076
+ TWITTER = "Twitter",
1077
+ WEBSITE = "Website",
1078
+ WHITEPAPER = "Whitepaper",
1079
+ YOUTUBE = "Youtube"
1080
+ }
1081
+
1082
+ type ResourceLink = {
1083
+ type: ResourceLinkType;
1084
+ url: string;
1085
+ };
1086
+
1087
+ type ContractSubmissionErc1155 = {
1088
+ description?: string;
1089
+ officialSite?: string;
1090
+ email?: string;
1091
+ logoAsset?: ImageAsset;
1092
+ bannerAsset?: ImageAsset;
1093
+ color?: string;
1094
+ resourceLinks?: Array<ResourceLink>;
1095
+ tags?: Array<string>;
1127
1096
  /**
1128
1097
  * The contract name.
1129
1098
  */
1130
1099
  name: string;
1100
+ ercType: ContractSubmissionErc1155.ercType;
1131
1101
  /**
1132
1102
  * The contract symbol.
1133
1103
  */
1134
1104
  symbol: string;
1105
+ pricingProviders?: PricingProviders;
1106
+ };
1107
+ declare namespace ContractSubmissionErc1155 {
1108
+ enum ercType {
1109
+ ERC_1155 = "ERC-1155"
1110
+ }
1111
+ }
1112
+
1113
+ type ContractSubmissionErc20 = {
1114
+ description?: string;
1115
+ officialSite?: string;
1116
+ email?: string;
1117
+ logoAsset?: ImageAsset;
1118
+ bannerAsset?: ImageAsset;
1119
+ color?: string;
1120
+ resourceLinks?: Array<ResourceLink>;
1121
+ tags?: Array<string>;
1135
1122
  /**
1136
- * The number of decimals the token uses. For example `6`, means to divide the token amount by `1000000` to get its user representation.
1137
- */
1138
- decimals: number;
1139
- /**
1140
- * The logo uri for the address.
1123
+ * The contract name.
1141
1124
  */
1142
- logoUri?: string;
1143
- ercType: Erc20Token.ercType;
1125
+ name: string;
1126
+ ercType: ContractSubmissionErc20.ercType;
1144
1127
  /**
1145
- * The token price, if available.
1128
+ * The contract symbol.
1146
1129
  */
1147
- price?: Money;
1130
+ symbol: string;
1131
+ pricingProviders?: PricingProviders;
1148
1132
  };
1149
- declare namespace Erc20Token {
1133
+ declare namespace ContractSubmissionErc20 {
1150
1134
  enum ercType {
1151
1135
  ERC_20 = "ERC-20"
1152
1136
  }
1153
1137
  }
1154
1138
 
1155
- type Erc20TransferDetails = {
1156
- from: RichAddress;
1157
- to: RichAddress;
1158
- logIndex: number;
1159
- value: string;
1160
- erc20Token: Erc20Token;
1161
- };
1162
-
1163
- type Erc721Token = {
1164
- /**
1165
- * A wallet or contract address in mixed-case checksum encoding.
1166
- */
1167
- address: string;
1139
+ type ContractSubmissionErc721 = {
1140
+ description?: string;
1141
+ officialSite?: string;
1142
+ email?: string;
1143
+ logoAsset?: ImageAsset;
1144
+ bannerAsset?: ImageAsset;
1145
+ color?: string;
1146
+ resourceLinks?: Array<ResourceLink>;
1147
+ tags?: Array<string>;
1168
1148
  /**
1169
1149
  * The contract name.
1170
1150
  */
1171
1151
  name: string;
1152
+ ercType: ContractSubmissionErc721.ercType;
1172
1153
  /**
1173
1154
  * The contract symbol.
1174
1155
  */
1175
1156
  symbol: string;
1176
- ercType: Erc721Token.ercType;
1177
- tokenId: string;
1178
- tokenUri: string;
1179
- metadata: Erc721TokenMetadata;
1180
- /**
1181
- * A wallet or contract address in mixed-case checksum encoding.
1182
- */
1183
- ownerAddress?: string;
1184
1157
  };
1185
- declare namespace Erc721Token {
1158
+ declare namespace ContractSubmissionErc721 {
1186
1159
  enum ercType {
1187
1160
  ERC_721 = "ERC-721"
1188
1161
  }
1189
1162
  }
1190
1163
 
1191
- type Erc721TransferDetails = {
1192
- from: RichAddress;
1193
- to: RichAddress;
1194
- logIndex: number;
1195
- erc721Token: Erc721Token;
1196
- };
1197
-
1198
- /**
1199
- * The contract call type. NATIVE_TRANSFER indicates a transfer of the native token without any smart-contract interaction. CONTRACT_CALL indicates a smart-contract interaction. CONTRACT_CREATION indicates a smart-contract creation.
1200
- */
1201
- declare enum TransactionMethodType {
1202
- NATIVE_TRANSFER = "NATIVE_TRANSFER",
1203
- CONTRACT_CALL = "CONTRACT_CALL",
1204
- CONTRACT_CREATION = "CONTRACT_CREATION"
1205
- }
1206
-
1207
- type Method = {
1208
- callType: TransactionMethodType;
1209
- /**
1210
- * The contract method hash identifier. The method hash is only set if the `callType` is `CONTRACT_CALL`.
1211
- */
1212
- methodHash: string;
1164
+ type ContractSubmissionUnknown = {
1165
+ description?: string;
1166
+ officialSite?: string;
1167
+ email?: string;
1168
+ logoAsset?: ImageAsset;
1169
+ bannerAsset?: ImageAsset;
1170
+ color?: string;
1171
+ resourceLinks?: Array<ResourceLink>;
1172
+ tags?: Array<string>;
1213
1173
  /**
1214
- * The contract method name including parameter types. If the `callType` is `NATIVE_TRANSFER` this is set to 'Native Transfer'. If the `callType` is `CONTRACT_CREATION` this is set to 'Contract Created'.
1174
+ * The contract name.
1215
1175
  */
1216
- methodName?: string;
1176
+ name: string;
1177
+ ercType: ContractSubmissionUnknown.ercType;
1178
+ };
1179
+ declare namespace ContractSubmissionUnknown {
1180
+ enum ercType {
1181
+ UNKNOWN = "UNKNOWN"
1182
+ }
1183
+ }
1184
+
1185
+ type ContractSubmissionBody = {
1186
+ contract: (ContractSubmissionErc1155 | ContractSubmissionErc20 | ContractSubmissionErc721 | ContractSubmissionUnknown);
1217
1187
  };
1218
1188
 
1219
- type FullNativeTransactionDetails = {
1189
+ type ContractDeploymentDetails = {
1190
+ txHash: string;
1220
1191
  /**
1221
- * The block number on the chain.
1192
+ * The address that initiated the transaction which deployed this contract.
1222
1193
  */
1223
- blockNumber: string;
1194
+ deployerAddress: string;
1224
1195
  /**
1225
- * The block finality timestamp.
1196
+ * The contract address which deployed this contract via smart contract. This field is only populated when the contract was deployed as part of smart contract execution.
1226
1197
  */
1227
- blockTimestamp: number;
1198
+ deployerContractAddress?: string;
1199
+ };
1200
+
1201
+ type Erc1155Contract = {
1228
1202
  /**
1229
- * The block hash identifier.
1203
+ * The contract name.
1230
1204
  */
1231
- blockHash: string;
1205
+ name?: string;
1206
+ description?: string;
1207
+ officialSite?: string;
1208
+ email?: string;
1209
+ logoAsset?: ImageAsset;
1210
+ bannerAsset?: ImageAsset;
1211
+ color?: string;
1212
+ resourceLinks?: Array<ResourceLink>;
1213
+ tags?: Array<string>;
1232
1214
  /**
1233
- * The index at which the transaction occured in the block (0-indexed).
1215
+ * A wallet or contract address in mixed-case checksum encoding.
1234
1216
  */
1235
- blockIndex: number;
1217
+ address: string;
1218
+ deploymentDetails: ContractDeploymentDetails;
1219
+ ercType: Erc1155Contract.ercType;
1236
1220
  /**
1237
- * The transaction hash identifier.
1221
+ * The contract symbol.
1238
1222
  */
1239
- txHash: string;
1223
+ symbol?: string;
1224
+ pricingProviders?: PricingProviders;
1225
+ };
1226
+ declare namespace Erc1155Contract {
1227
+ enum ercType {
1228
+ ERC_1155 = "ERC-1155"
1229
+ }
1230
+ }
1231
+
1232
+ type Erc20Contract = {
1240
1233
  /**
1241
- * The transaction status, which is either 0 (failed) or 1 (successful).
1234
+ * The contract name.
1242
1235
  */
1243
- txStatus: string;
1236
+ name?: string;
1237
+ description?: string;
1238
+ officialSite?: string;
1239
+ email?: string;
1240
+ logoAsset?: ImageAsset;
1241
+ bannerAsset?: ImageAsset;
1242
+ color?: string;
1243
+ resourceLinks?: Array<ResourceLink>;
1244
+ tags?: Array<string>;
1244
1245
  /**
1245
- * The transaction type.
1246
+ * A wallet or contract address in mixed-case checksum encoding.
1246
1247
  */
1247
- txType: number;
1248
+ address: string;
1249
+ deploymentDetails: ContractDeploymentDetails;
1250
+ ercType: Erc20Contract.ercType;
1248
1251
  /**
1249
- * The gas limit set for the transaction.
1252
+ * The contract symbol.
1250
1253
  */
1251
- gasLimit: string;
1254
+ symbol?: string;
1252
1255
  /**
1253
- * The amount of gas used.
1256
+ * The number of decimals the token uses. For example `6`, means to divide the token amount by `1000000` to get its user representation.
1254
1257
  */
1255
- gasUsed: string;
1258
+ decimals: number;
1259
+ pricingProviders?: PricingProviders;
1260
+ };
1261
+ declare namespace Erc20Contract {
1262
+ enum ercType {
1263
+ ERC_20 = "ERC-20"
1264
+ }
1265
+ }
1266
+
1267
+ type Erc721Contract = {
1256
1268
  /**
1257
- * The gas price denominated by the number of decimals of the native token.
1269
+ * The contract name.
1258
1270
  */
1259
- gasPrice: string;
1271
+ name?: string;
1272
+ description?: string;
1273
+ officialSite?: string;
1274
+ email?: string;
1275
+ logoAsset?: ImageAsset;
1276
+ bannerAsset?: ImageAsset;
1277
+ color?: string;
1278
+ resourceLinks?: Array<ResourceLink>;
1279
+ tags?: Array<string>;
1260
1280
  /**
1261
- * The nonce used by the sender of the transaction.
1281
+ * A wallet or contract address in mixed-case checksum encoding.
1262
1282
  */
1263
- nonce: string;
1264
- from: RichAddress;
1265
- to: RichAddress;
1266
- method?: Method;
1267
- value: string;
1283
+ address: string;
1284
+ deploymentDetails: ContractDeploymentDetails;
1285
+ ercType: Erc721Contract.ercType;
1268
1286
  /**
1269
- * The data sent for the transaction.
1287
+ * The contract symbol.
1270
1288
  */
1271
- input: string;
1272
- baseFeePerGas: string;
1273
- maxFeePerGas?: string;
1274
- maxPriorityFeePerGas?: string;
1289
+ symbol?: string;
1275
1290
  };
1276
-
1277
- declare enum InternalTransactionOpCall {
1278
- UNKNOWN = "UNKNOWN",
1279
- CALL = "CALL",
1280
- CREATE = "CREATE",
1281
- CREATE2 = "CREATE2",
1282
- CALLCODE = "CALLCODE",
1283
- DELEGATECALL = "DELEGATECALL",
1284
- STATICCALL = "STATICCALL"
1291
+ declare namespace Erc721Contract {
1292
+ enum ercType {
1293
+ ERC_721 = "ERC-721"
1294
+ }
1285
1295
  }
1286
1296
 
1287
- type InternalTransactionDetails = {
1288
- from: RichAddress;
1289
- to: RichAddress;
1290
- internalTxType: InternalTransactionOpCall;
1291
- value: string;
1297
+ type UnknownContract = {
1292
1298
  /**
1293
- * True if the internal transaction was reverted.
1299
+ * The contract name.
1294
1300
  */
1295
- isReverted: boolean;
1296
- gasUsed: string;
1297
- gasLimit: string;
1301
+ name?: string;
1302
+ description?: string;
1303
+ officialSite?: string;
1304
+ email?: string;
1305
+ logoAsset?: ImageAsset;
1306
+ bannerAsset?: ImageAsset;
1307
+ color?: string;
1308
+ resourceLinks?: Array<ResourceLink>;
1309
+ tags?: Array<string>;
1310
+ /**
1311
+ * A wallet or contract address in mixed-case checksum encoding.
1312
+ */
1313
+ address: string;
1314
+ deploymentDetails: ContractDeploymentDetails;
1315
+ ercType: UnknownContract.ercType;
1298
1316
  };
1317
+ declare namespace UnknownContract {
1318
+ enum ercType {
1319
+ UNKNOWN = "UNKNOWN"
1320
+ }
1321
+ }
1299
1322
 
1300
- type NetworkTokenDetails = {
1301
- networkToken: NetworkToken;
1323
+ type UpdateContractResponse = {
1324
+ contract: (UnknownContract | Erc20Contract | Erc721Contract | Erc1155Contract);
1325
+ };
1326
+
1327
+ declare class EvmContractsService {
1328
+ readonly httpRequest: BaseHttpRequest;
1329
+ constructor(httpRequest: BaseHttpRequest);
1302
1330
  /**
1303
- * The current token price, if available.
1331
+ * Get contract metadata
1332
+ * Gets metadata about the contract at the given address.
1333
+ * @returns any Successful response
1334
+ * @throws ApiError
1304
1335
  */
1305
- currentPrice?: Money;
1336
+ getContractMetadata({ chainId, address, }: {
1337
+ /**
1338
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1339
+ */
1340
+ chainId: string;
1341
+ /**
1342
+ * Contract address on the relevant chain.
1343
+ */
1344
+ address: string;
1345
+ }): CancelablePromise<(Erc721Contract | Erc1155Contract | Erc20Contract | UnknownContract)>;
1306
1346
  /**
1307
- * The historical token price at the time the transaction occured, if available. Note, this is only provided if the transaction occured more than 24 hours ago.
1347
+ * Update contract information
1348
+ * Update contract information. Updates will be reviewed by the Ava Labs team before they are published.
1349
+ * @returns UpdateContractResponse Successful response
1350
+ * @throws ApiError
1308
1351
  */
1309
- historicalPrice?: Money;
1310
- };
1311
-
1312
- declare enum TransactionDirectionType {
1313
- SOURCE_TRANSACTION = "SOURCE_TRANSACTION",
1314
- DESTINATION_TRANSACTION = "DESTINATION_TRANSACTION"
1352
+ updateContractInfo({ chainId, address, requestBody, }: {
1353
+ /**
1354
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1355
+ */
1356
+ chainId: string;
1357
+ /**
1358
+ * Contract address on the relevant chain.
1359
+ */
1360
+ address: string;
1361
+ requestBody: ContractSubmissionBody;
1362
+ }): CancelablePromise<UpdateContractResponse>;
1315
1363
  }
1316
1364
 
1317
- type TeleporterMessageInfo = {
1318
- teleporterMessageId: string;
1319
- direction: TransactionDirectionType;
1320
- /**
1321
- * chain id of the source chain. valid only for destination transactions
1322
- */
1323
- sourceChainId?: Record<string, any>;
1365
+ type Erc1155Token = {
1324
1366
  /**
1325
- * chain id of the destination chain. valid only for source transactions
1367
+ * A wallet or contract address in mixed-case checksum encoding.
1326
1368
  */
1327
- destinationChainId?: Record<string, any>;
1369
+ address: string;
1370
+ ercType: Erc1155Token.ercType;
1371
+ tokenId: string;
1372
+ tokenUri: string;
1373
+ metadata: Erc1155TokenMetadata;
1328
1374
  };
1375
+ declare namespace Erc1155Token {
1376
+ enum ercType {
1377
+ ERC_1155 = "ERC-1155"
1378
+ }
1379
+ }
1329
1380
 
1330
- type GetTransactionResponse = {
1381
+ type RichAddress = {
1331
1382
  /**
1332
- * The list of ERC-20 transfers.
1383
+ * The contract name.
1333
1384
  */
1334
- erc20Transfers?: Array<Erc20TransferDetails>;
1385
+ name?: string;
1335
1386
  /**
1336
- * The list of ERC-721 transfers.
1337
- */
1338
- erc721Transfers?: Array<Erc721TransferDetails>;
1339
- /**
1340
- * The list of ERC-1155 transfers.
1387
+ * The contract symbol.
1341
1388
  */
1342
- erc1155Transfers?: Array<Erc1155TransferDetails>;
1389
+ symbol?: string;
1343
1390
  /**
1344
- * The list of internal transactions. Note that this list only includes CALL and CALLCODE internal transactions that had a non-zero value and CREATE/CREATE2 calls. Use a client provider to recieve a full debug trace of the transaction.
1391
+ * The number of decimals the token uses. For example `6`, means to divide the token amount by `1000000` to get its user representation.
1345
1392
  */
1346
- internalTransactions?: Array<InternalTransactionDetails>;
1347
- networkTokenDetails: NetworkTokenDetails;
1348
- nativeTransaction: FullNativeTransactionDetails;
1393
+ decimals?: number;
1349
1394
  /**
1350
- * Corresponding teleporter message info if available.
1395
+ * The logo uri for the address.
1351
1396
  */
1352
- teleporterMessageInfo?: TeleporterMessageInfo;
1353
- };
1354
-
1355
- type ListContractsResponse = {
1397
+ logoUri?: string;
1356
1398
  /**
1357
- * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
1399
+ * A wallet or contract address in mixed-case checksum encoding.
1358
1400
  */
1359
- nextPageToken?: string;
1360
- contracts: Array<(Erc721Contract | Erc1155Contract | Erc20Contract | UnknownContract)>;
1401
+ address: string;
1361
1402
  };
1362
1403
 
1363
- type Erc1155Transfer = {
1364
- /**
1365
- * The block number on the chain.
1366
- */
1367
- blockNumber: string;
1368
- /**
1369
- * The block finality timestamp.
1370
- */
1371
- blockTimestamp: number;
1372
- /**
1373
- * The block hash identifier.
1374
- */
1375
- blockHash: string;
1376
- /**
1377
- * The transaction hash identifier.
1378
- */
1379
- txHash: string;
1404
+ type Erc1155TransferDetails = {
1380
1405
  from: RichAddress;
1381
1406
  to: RichAddress;
1382
1407
  logIndex: number;
@@ -1384,31 +1409,40 @@ type Erc1155Transfer = {
1384
1409
  erc1155Token: Erc1155Token;
1385
1410
  };
1386
1411
 
1387
- type ListErc1155TransactionsResponse = {
1412
+ type Erc20Token = {
1388
1413
  /**
1389
- * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
1414
+ * A wallet or contract address in mixed-case checksum encoding.
1390
1415
  */
1391
- nextPageToken?: string;
1392
- transactions: Array<Erc1155Transfer>;
1393
- };
1394
-
1395
- type Erc20Transfer = {
1416
+ address: string;
1396
1417
  /**
1397
- * The block number on the chain.
1418
+ * The contract name.
1398
1419
  */
1399
- blockNumber: string;
1420
+ name: string;
1400
1421
  /**
1401
- * The block finality timestamp.
1422
+ * The contract symbol.
1402
1423
  */
1403
- blockTimestamp: number;
1424
+ symbol: string;
1404
1425
  /**
1405
- * The block hash identifier.
1426
+ * The number of decimals the token uses. For example `6`, means to divide the token amount by `1000000` to get its user representation.
1406
1427
  */
1407
- blockHash: string;
1428
+ decimals: number;
1408
1429
  /**
1409
- * The transaction hash identifier.
1430
+ * The logo uri for the address.
1410
1431
  */
1411
- txHash: string;
1432
+ logoUri?: string;
1433
+ ercType: Erc20Token.ercType;
1434
+ /**
1435
+ * The token price, if available.
1436
+ */
1437
+ price?: Money;
1438
+ };
1439
+ declare namespace Erc20Token {
1440
+ enum ercType {
1441
+ ERC_20 = "ERC-20"
1442
+ }
1443
+ }
1444
+
1445
+ type Erc20TransferDetails = {
1412
1446
  from: RichAddress;
1413
1447
  to: RichAddress;
1414
1448
  logIndex: number;
@@ -1416,83 +1450,63 @@ type Erc20Transfer = {
1416
1450
  erc20Token: Erc20Token;
1417
1451
  };
1418
1452
 
1419
- type ListErc20TransactionsResponse = {
1420
- /**
1421
- * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
1422
- */
1423
- nextPageToken?: string;
1424
- transactions: Array<Erc20Transfer>;
1425
- };
1426
-
1427
- type Erc721Transfer = {
1453
+ type Erc721Token = {
1428
1454
  /**
1429
- * The block number on the chain.
1455
+ * A wallet or contract address in mixed-case checksum encoding.
1430
1456
  */
1431
- blockNumber: string;
1457
+ address: string;
1432
1458
  /**
1433
- * The block finality timestamp.
1459
+ * The contract name.
1434
1460
  */
1435
- blockTimestamp: number;
1461
+ name: string;
1436
1462
  /**
1437
- * The block hash identifier.
1463
+ * The contract symbol.
1438
1464
  */
1439
- blockHash: string;
1465
+ symbol: string;
1466
+ ercType: Erc721Token.ercType;
1467
+ tokenId: string;
1468
+ tokenUri: string;
1469
+ metadata: Erc721TokenMetadata;
1440
1470
  /**
1441
- * The transaction hash identifier.
1471
+ * A wallet or contract address in mixed-case checksum encoding.
1442
1472
  */
1443
- txHash: string;
1473
+ ownerAddress?: string;
1474
+ };
1475
+ declare namespace Erc721Token {
1476
+ enum ercType {
1477
+ ERC_721 = "ERC-721"
1478
+ }
1479
+ }
1480
+
1481
+ type Erc721TransferDetails = {
1444
1482
  from: RichAddress;
1445
1483
  to: RichAddress;
1446
1484
  logIndex: number;
1447
1485
  erc721Token: Erc721Token;
1448
1486
  };
1449
1487
 
1450
- type ListErc721TransactionsResponse = {
1451
- /**
1452
- * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
1453
- */
1454
- nextPageToken?: string;
1455
- transactions: Array<Erc721Transfer>;
1456
- };
1488
+ /**
1489
+ * The contract call type. NATIVE_TRANSFER indicates a transfer of the native token without any smart-contract interaction. CONTRACT_CALL indicates a smart-contract interaction. CONTRACT_CREATION indicates a smart-contract creation.
1490
+ */
1491
+ declare enum TransactionMethodType {
1492
+ NATIVE_TRANSFER = "NATIVE_TRANSFER",
1493
+ CONTRACT_CALL = "CONTRACT_CALL",
1494
+ CONTRACT_CREATION = "CONTRACT_CREATION"
1495
+ }
1457
1496
 
1458
- type InternalTransaction = {
1459
- /**
1460
- * The block number on the chain.
1461
- */
1462
- blockNumber: string;
1463
- /**
1464
- * The block finality timestamp.
1465
- */
1466
- blockTimestamp: number;
1467
- /**
1468
- * The block hash identifier.
1469
- */
1470
- blockHash: string;
1471
- /**
1472
- * The transaction hash identifier.
1473
- */
1474
- txHash: string;
1475
- from: RichAddress;
1476
- to: RichAddress;
1477
- internalTxType: InternalTransactionOpCall;
1478
- value: string;
1497
+ type Method = {
1498
+ callType: TransactionMethodType;
1479
1499
  /**
1480
- * True if the internal transaction was reverted.
1500
+ * The contract method hash identifier. The method hash is only set if the `callType` is `CONTRACT_CALL`.
1481
1501
  */
1482
- isReverted: boolean;
1483
- gasUsed: string;
1484
- gasLimit: string;
1485
- };
1486
-
1487
- type ListInternalTransactionsResponse = {
1502
+ methodHash: string;
1488
1503
  /**
1489
- * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
1504
+ * The contract method name including parameter types. If the `callType` is `NATIVE_TRANSFER` this is set to 'Native Transfer'. If the `callType` is `CONTRACT_CREATION` this is set to 'Contract Created'.
1490
1505
  */
1491
- nextPageToken?: string;
1492
- transactions: Array<InternalTransaction>;
1506
+ methodName?: string;
1493
1507
  };
1494
1508
 
1495
- type NativeTransaction = {
1509
+ type FullNativeTransactionDetails = {
1496
1510
  /**
1497
1511
  * The block number on the chain.
1498
1512
  */
@@ -1541,21 +1555,69 @@ type NativeTransaction = {
1541
1555
  to: RichAddress;
1542
1556
  method?: Method;
1543
1557
  value: string;
1558
+ /**
1559
+ * The data sent for the transaction.
1560
+ */
1561
+ input: string;
1562
+ baseFeePerGas: string;
1563
+ maxFeePerGas?: string;
1564
+ maxPriorityFeePerGas?: string;
1544
1565
  };
1545
1566
 
1546
- type ListNativeTransactionsResponse = {
1567
+ declare enum InternalTransactionOpCall {
1568
+ UNKNOWN = "UNKNOWN",
1569
+ CALL = "CALL",
1570
+ CREATE = "CREATE",
1571
+ CREATE2 = "CREATE2",
1572
+ CALLCODE = "CALLCODE",
1573
+ DELEGATECALL = "DELEGATECALL",
1574
+ STATICCALL = "STATICCALL"
1575
+ }
1576
+
1577
+ type InternalTransactionDetails = {
1578
+ from: RichAddress;
1579
+ to: RichAddress;
1580
+ internalTxType: InternalTransactionOpCall;
1581
+ value: string;
1547
1582
  /**
1548
- * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
1583
+ * True if the internal transaction was reverted.
1549
1584
  */
1550
- nextPageToken?: string;
1551
- transactions: Array<NativeTransaction>;
1585
+ isReverted: boolean;
1586
+ gasUsed: string;
1587
+ gasLimit: string;
1552
1588
  };
1553
1589
 
1554
- type TransactionDetails = {
1590
+ type NetworkTokenDetails = {
1591
+ networkToken: NetworkToken;
1555
1592
  /**
1556
- * The native (top-level) transaction details.
1593
+ * The current token price, if available.
1557
1594
  */
1558
- nativeTransaction: NativeTransaction;
1595
+ currentPrice?: Money;
1596
+ /**
1597
+ * The historical token price at the time the transaction occured, if available. Note, this is only provided if the transaction occured more than 24 hours ago.
1598
+ */
1599
+ historicalPrice?: Money;
1600
+ };
1601
+
1602
+ declare enum TransactionDirectionType {
1603
+ SOURCE_TRANSACTION = "SOURCE_TRANSACTION",
1604
+ DESTINATION_TRANSACTION = "DESTINATION_TRANSACTION"
1605
+ }
1606
+
1607
+ type TeleporterMessageInfo = {
1608
+ teleporterMessageId: string;
1609
+ direction: TransactionDirectionType;
1610
+ /**
1611
+ * chain id of the source chain. valid only for destination transactions
1612
+ */
1613
+ sourceChainId?: Record<string, any>;
1614
+ /**
1615
+ * chain id of the destination chain. valid only for source transactions
1616
+ */
1617
+ destinationChainId?: Record<string, any>;
1618
+ };
1619
+
1620
+ type GetTransactionResponse = {
1559
1621
  /**
1560
1622
  * The list of ERC-20 transfers.
1561
1623
  */
@@ -1572,658 +1634,597 @@ type TransactionDetails = {
1572
1634
  * The list of internal transactions. Note that this list only includes CALL and CALLCODE internal transactions that had a non-zero value and CREATE/CREATE2 calls. Use a client provider to recieve a full debug trace of the transaction.
1573
1635
  */
1574
1636
  internalTransactions?: Array<InternalTransactionDetails>;
1575
- };
1576
-
1577
- type ListTransactionDetailsResponse = {
1637
+ networkTokenDetails: NetworkTokenDetails;
1638
+ nativeTransaction: FullNativeTransactionDetails;
1578
1639
  /**
1579
- * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
1640
+ * Corresponding teleporter message info if available.
1580
1641
  */
1581
- nextPageToken?: string;
1582
- transactions: Array<TransactionDetails>;
1642
+ teleporterMessageInfo?: TeleporterMessageInfo;
1583
1643
  };
1584
1644
 
1585
- type ListTransfersResponse = {
1645
+ type ListContractsResponse = {
1586
1646
  /**
1587
1647
  * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
1588
1648
  */
1589
1649
  nextPageToken?: string;
1590
- transfers: Array<(Erc20Transfer | Erc721Transfer | Erc1155Transfer)>;
1650
+ contracts: Array<(Erc721Contract | Erc1155Contract | Erc20Contract | UnknownContract)>;
1591
1651
  };
1592
1652
 
1593
- declare enum SortOrder {
1594
- ASC = "asc",
1595
- DESC = "desc"
1596
- }
1597
-
1598
- declare enum TransactionStatus {
1599
- FAILED = "failed",
1600
- SUCCESS = "success"
1601
- }
1602
-
1603
- declare class EvmTransactionsService {
1604
- readonly httpRequest: BaseHttpRequest;
1605
- constructor(httpRequest: BaseHttpRequest);
1606
- /**
1607
- * Get deployment transaction
1608
- * If the address is a smart contract, returns the transaction in which it was deployed.
1609
- * @returns GetTransactionResponse Successful response
1610
- * @throws ApiError
1611
- */
1612
- getDeploymentTransaction({ chainId, address, currency, }: {
1613
- /**
1614
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1615
- */
1616
- chainId: string;
1617
- /**
1618
- * Contract address on the relevant chain.
1619
- */
1620
- address: string;
1621
- /**
1622
- * The currency that return values should use. Defaults to USD.
1623
- */
1624
- currency?: CurrencyCode;
1625
- }): CancelablePromise<GetTransactionResponse>;
1653
+ type Erc1155Transfer = {
1626
1654
  /**
1627
- * List deployed contracts
1628
- * Lists all contracts deployed by the given address.
1629
- * @returns ListContractsResponse Successful response
1630
- * @throws ApiError
1655
+ * The block number on the chain.
1631
1656
  */
1632
- listContractDeployments({ chainId, address, pageToken, pageSize, }: {
1633
- /**
1634
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1635
- */
1636
- chainId: string;
1637
- /**
1638
- * A wallet address.
1639
- */
1640
- address: string;
1641
- /**
1642
- * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
1643
- */
1644
- pageToken?: string;
1645
- /**
1646
- * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
1647
- */
1648
- pageSize?: number;
1649
- }): CancelablePromise<ListContractsResponse>;
1657
+ blockNumber: string;
1650
1658
  /**
1651
- * List ERC transfers
1652
- * Lists ERC transfers for an ERC-20, ERC-721, or ERC-1155 contract address.
1653
- * @returns ListTransfersResponse Successful response
1654
- * @throws ApiError
1659
+ * The block finality timestamp.
1655
1660
  */
1656
- listTransfers({ chainId, address, startBlock, endBlock, pageToken, pageSize, }: {
1657
- /**
1658
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1659
- */
1660
- chainId: string;
1661
- /**
1662
- * A wallet address.
1663
- */
1664
- address: string;
1665
- /**
1666
- * The block range start number, inclusive. If endBlock is not defined when startBlock is defined, the end of the range will be the most recent block.
1667
- */
1668
- startBlock?: number;
1669
- /**
1670
- * The block range end number, exclusive. If startBlock is not defined when endBlock is defined, the start of the range will be the genesis block.
1671
- */
1672
- endBlock?: number;
1673
- /**
1674
- * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
1675
- */
1676
- pageToken?: string;
1677
- /**
1678
- * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
1679
- */
1680
- pageSize?: number;
1681
- }): CancelablePromise<ListTransfersResponse>;
1661
+ blockTimestamp: number;
1682
1662
  /**
1683
- * List transactions
1684
- * Returns a list of transactions where the given wallet address had an on-chain interaction for the given chain. The ERC-20 transfers, ERC-721 transfers, ERC-1155, and internal transactions returned are only those where the input address had an interaction. Specifically, those lists only inlcude entries where the input address was the sender (`from` field) or the receiver (`to` field) for the sub-transaction. Therefore the transactions returned from this list may not be complete representations of the on-chain data. For a complete view of a transaction use the `/chains/:chainId/transactions/:txHash` endpoint.
1685
- *
1686
- * Filterable by block ranges.
1687
- * @returns ListTransactionDetailsResponse Successful response
1688
- * @throws ApiError
1663
+ * The block hash identifier.
1689
1664
  */
1690
- listTransactions({ chainId, address, pageToken, pageSize, startBlock, endBlock, sortOrder, }: {
1691
- /**
1692
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1693
- */
1694
- chainId: string;
1695
- /**
1696
- * A wallet address.
1697
- */
1698
- address: string;
1699
- /**
1700
- * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
1701
- */
1702
- pageToken?: string;
1703
- /**
1704
- * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
1705
- */
1706
- pageSize?: number;
1707
- /**
1708
- * The block range start number, inclusive. If endBlock is not defined when startBlock is defined, the end of the range will be the most recent block.
1709
- */
1710
- startBlock?: number;
1711
- /**
1712
- * The block range end number, exclusive. If startBlock is not defined when endBlock is defined, the start of the range will be the genesis block.
1713
- */
1714
- endBlock?: number;
1715
- /**
1716
- * The order by which to sort results. Use "asc" for ascending order, "desc" for descending order. Sorted by timestamp or the `sortBy` query parameter, if provided.
1717
- */
1718
- sortOrder?: SortOrder;
1719
- }): CancelablePromise<ListTransactionDetailsResponse>;
1665
+ blockHash: string;
1720
1666
  /**
1721
- * List native transactions
1722
- * Lists native transactions for an address. Filterable by block range.
1723
- * @returns ListNativeTransactionsResponse Successful response
1724
- * @throws ApiError
1667
+ * The transaction hash identifier.
1725
1668
  */
1726
- listNativeTransactions({ chainId, address, startBlock, endBlock, pageToken, pageSize, }: {
1727
- /**
1728
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1729
- */
1730
- chainId: string;
1731
- /**
1732
- * A wallet address.
1733
- */
1734
- address: string;
1735
- /**
1736
- * The block range start number, inclusive. If endBlock is not defined when startBlock is defined, the end of the range will be the most recent block.
1737
- */
1738
- startBlock?: number;
1739
- /**
1740
- * The block range end number, exclusive. If startBlock is not defined when endBlock is defined, the start of the range will be the genesis block.
1741
- */
1742
- endBlock?: number;
1743
- /**
1744
- * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
1745
- */
1746
- pageToken?: string;
1747
- /**
1748
- * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
1749
- */
1750
- pageSize?: number;
1751
- }): CancelablePromise<ListNativeTransactionsResponse>;
1669
+ txHash: string;
1670
+ from: RichAddress;
1671
+ to: RichAddress;
1672
+ logIndex: number;
1673
+ value: string;
1674
+ erc1155Token: Erc1155Token;
1675
+ };
1676
+
1677
+ type ListErc1155TransactionsResponse = {
1752
1678
  /**
1753
- * List ERC-20 transfers
1754
- * Lists ERC-20 transfers for an address. Filterable by block range.
1755
- * @returns ListErc20TransactionsResponse Successful response
1756
- * @throws ApiError
1679
+ * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
1757
1680
  */
1758
- listErc20Transactions({ chainId, address, startBlock, endBlock, pageToken, pageSize, }: {
1759
- /**
1760
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1761
- */
1762
- chainId: string;
1763
- /**
1764
- * A wallet address.
1765
- */
1766
- address: string;
1767
- /**
1768
- * The block range start number, inclusive. If endBlock is not defined when startBlock is defined, the end of the range will be the most recent block.
1769
- */
1770
- startBlock?: number;
1771
- /**
1772
- * The block range end number, exclusive. If startBlock is not defined when endBlock is defined, the start of the range will be the genesis block.
1773
- */
1774
- endBlock?: number;
1775
- /**
1776
- * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
1777
- */
1778
- pageToken?: string;
1779
- /**
1780
- * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
1781
- */
1782
- pageSize?: number;
1783
- }): CancelablePromise<ListErc20TransactionsResponse>;
1681
+ nextPageToken?: string;
1682
+ transactions: Array<Erc1155Transfer>;
1683
+ };
1684
+
1685
+ type Erc20Transfer = {
1784
1686
  /**
1785
- * List ERC-721 transfers
1786
- * Lists ERC-721 transfers for an address. Filterable by block range.
1787
- * @returns ListErc721TransactionsResponse Successful response
1788
- * @throws ApiError
1687
+ * The block number on the chain.
1789
1688
  */
1790
- listErc721Transactions({ chainId, address, startBlock, endBlock, pageToken, pageSize, }: {
1791
- /**
1792
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1793
- */
1794
- chainId: string;
1795
- /**
1796
- * A wallet address.
1797
- */
1798
- address: string;
1799
- /**
1800
- * The block range start number, inclusive. If endBlock is not defined when startBlock is defined, the end of the range will be the most recent block.
1801
- */
1802
- startBlock?: number;
1803
- /**
1804
- * The block range end number, exclusive. If startBlock is not defined when endBlock is defined, the start of the range will be the genesis block.
1805
- */
1806
- endBlock?: number;
1807
- /**
1808
- * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
1809
- */
1810
- pageToken?: string;
1811
- /**
1812
- * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
1813
- */
1814
- pageSize?: number;
1815
- }): CancelablePromise<ListErc721TransactionsResponse>;
1689
+ blockNumber: string;
1816
1690
  /**
1817
- * List ERC-1155 transfers
1818
- * Lists ERC-1155 transfers for an address. Filterable by block range.
1819
- * @returns ListErc1155TransactionsResponse Successful response
1820
- * @throws ApiError
1691
+ * The block finality timestamp.
1821
1692
  */
1822
- listErc1155Transactions({ chainId, address, startBlock, endBlock, pageToken, pageSize, }: {
1823
- /**
1824
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1825
- */
1826
- chainId: string;
1827
- /**
1828
- * A wallet address.
1829
- */
1830
- address: string;
1831
- /**
1832
- * The block range start number, inclusive. If endBlock is not defined when startBlock is defined, the end of the range will be the most recent block.
1833
- */
1834
- startBlock?: number;
1835
- /**
1836
- * The block range end number, exclusive. If startBlock is not defined when endBlock is defined, the start of the range will be the genesis block.
1837
- */
1838
- endBlock?: number;
1839
- /**
1840
- * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
1841
- */
1842
- pageToken?: string;
1843
- /**
1844
- * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
1845
- */
1846
- pageSize?: number;
1847
- }): CancelablePromise<ListErc1155TransactionsResponse>;
1693
+ blockTimestamp: number;
1848
1694
  /**
1849
- * List internal transactions
1850
- * Returns a list of internal transactions for an address and chain. Filterable by block range.
1851
- *
1852
- * Note that the internal transactions list only contains `CALL` or `CALLCODE` transactions with a non-zero value and `CREATE`/`CREATE2` transactions. To get a complete list of internal transactions use the `debug_` prefixed RPC methods on an archive node.
1853
- * @returns ListInternalTransactionsResponse Successful response
1854
- * @throws ApiError
1695
+ * The block hash identifier.
1855
1696
  */
1856
- listInternalTransactions({ chainId, address, startBlock, endBlock, pageToken, pageSize, }: {
1857
- /**
1858
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1859
- */
1860
- chainId: string;
1861
- /**
1862
- * A wallet address.
1863
- */
1864
- address: string;
1865
- /**
1866
- * The block range start number, inclusive. If endBlock is not defined when startBlock is defined, the end of the range will be the most recent block.
1867
- */
1868
- startBlock?: number;
1869
- /**
1870
- * The block range end number, exclusive. If startBlock is not defined when endBlock is defined, the start of the range will be the genesis block.
1871
- */
1872
- endBlock?: number;
1873
- /**
1874
- * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
1875
- */
1876
- pageToken?: string;
1877
- /**
1878
- * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
1879
- */
1880
- pageSize?: number;
1881
- }): CancelablePromise<ListInternalTransactionsResponse>;
1697
+ blockHash: string;
1882
1698
  /**
1883
- * Get transaction
1884
- * Gets the details of a single transaction.
1885
- * @returns GetTransactionResponse Successful response
1886
- * @throws ApiError
1699
+ * The transaction hash identifier.
1887
1700
  */
1888
- getTransaction({ chainId, txHash, }: {
1889
- /**
1890
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1891
- */
1892
- chainId: string;
1893
- /**
1894
- * A transaction hash.
1895
- */
1896
- txHash: string;
1897
- }): CancelablePromise<GetTransactionResponse>;
1701
+ txHash: string;
1702
+ from: RichAddress;
1703
+ to: RichAddress;
1704
+ logIndex: number;
1705
+ value: string;
1706
+ erc20Token: Erc20Token;
1707
+ };
1708
+
1709
+ type ListErc20TransactionsResponse = {
1898
1710
  /**
1899
- * List transactions for a block
1900
- * Lists the transactions that occured in a given block.
1901
- * @returns ListNativeTransactionsResponse Successful response
1902
- * @throws ApiError
1711
+ * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
1903
1712
  */
1904
- getTransactionsForBlock({ chainId, blockId, }: {
1905
- /**
1906
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1907
- */
1908
- chainId: string;
1909
- /**
1910
- * A block identifier which is either a block number or the block hash.
1911
- */
1912
- blockId: string;
1913
- }): CancelablePromise<ListNativeTransactionsResponse>;
1713
+ nextPageToken?: string;
1714
+ transactions: Array<Erc20Transfer>;
1715
+ };
1716
+
1717
+ type Erc721Transfer = {
1914
1718
  /**
1915
- * List latest transactions
1916
- * Lists the latest transactions. Filterable by status.
1917
- * @returns ListNativeTransactionsResponse Successful response
1918
- * @throws ApiError
1719
+ * The block number on the chain.
1919
1720
  */
1920
- listLatestTransactions({ chainId, pageToken, pageSize, status, }: {
1921
- /**
1922
- * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1923
- */
1924
- chainId: string;
1925
- /**
1926
- * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
1927
- */
1928
- pageToken?: string;
1929
- /**
1930
- * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
1931
- */
1932
- pageSize?: number;
1933
- /**
1934
- * A status filter for listed transactions.
1935
- */
1936
- status?: TransactionStatus;
1937
- }): CancelablePromise<ListNativeTransactionsResponse>;
1938
- }
1939
-
1940
- type LogsFormatMetadata = {
1721
+ blockNumber: string;
1941
1722
  /**
1942
- * The IP address of the client that made the request.
1723
+ * The block finality timestamp.
1943
1724
  */
1944
- ipAddress: string;
1725
+ blockTimestamp: number;
1945
1726
  /**
1946
- * The host for the request made by the client.
1727
+ * The block hash identifier.
1947
1728
  */
1948
- host: string;
1729
+ blockHash: string;
1949
1730
  /**
1950
- * The user agent of the client that made the request.
1731
+ * The transaction hash identifier.
1951
1732
  */
1952
- userAgent: string;
1733
+ txHash: string;
1734
+ from: RichAddress;
1735
+ to: RichAddress;
1736
+ logIndex: number;
1737
+ erc721Token: Erc721Token;
1953
1738
  };
1954
1739
 
1955
- /**
1956
- * The type of request made by the client.
1957
- */
1958
- declare enum RequestType {
1959
- DATA = "data",
1960
- RPC = "rpc"
1961
- }
1962
-
1963
- type LogsFormat = {
1740
+ type ListErc721TransactionsResponse = {
1964
1741
  /**
1965
- * The organization id of the request.
1742
+ * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
1966
1743
  */
1967
- orgId: string;
1744
+ nextPageToken?: string;
1745
+ transactions: Array<Erc721Transfer>;
1746
+ };
1747
+
1748
+ type InternalTransaction = {
1968
1749
  /**
1969
- * The unique log id of the request.
1750
+ * The block number on the chain.
1970
1751
  */
1971
- logId: string;
1752
+ blockNumber: string;
1972
1753
  /**
1973
- * The timestamp of the request.
1754
+ * The block finality timestamp.
1974
1755
  */
1975
- eventTimestamp: number;
1756
+ blockTimestamp: number;
1976
1757
  /**
1977
- * The apiKey used to make the request.
1758
+ * The block hash identifier.
1978
1759
  */
1979
- apiKeyId: string;
1760
+ blockHash: string;
1980
1761
  /**
1981
- * The alias of the apiKey used to make the request.
1762
+ * The transaction hash identifier.
1982
1763
  */
1983
- apiKeyAlias: string;
1764
+ txHash: string;
1765
+ from: RichAddress;
1766
+ to: RichAddress;
1767
+ internalTxType: InternalTransactionOpCall;
1768
+ value: string;
1984
1769
  /**
1985
- * The region of the host for the request made by the client.
1770
+ * True if the internal transaction was reverted.
1986
1771
  */
1987
- hostRegion: string;
1988
- requestType: RequestType;
1772
+ isReverted: boolean;
1773
+ gasUsed: string;
1774
+ gasLimit: string;
1775
+ };
1776
+
1777
+ type ListInternalTransactionsResponse = {
1989
1778
  /**
1990
- * The path of the request made by the client.
1779
+ * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
1991
1780
  */
1992
- requestPath: string;
1781
+ nextPageToken?: string;
1782
+ transactions: Array<InternalTransaction>;
1783
+ };
1784
+
1785
+ type NativeTransaction = {
1993
1786
  /**
1994
- * The number of API credits consumed by the request.
1787
+ * The block number on the chain.
1995
1788
  */
1996
- apiCreditsConsumed: number;
1789
+ blockNumber: string;
1997
1790
  /**
1998
- * The duration of the request in milliseconds.
1791
+ * The block finality timestamp.
1999
1792
  */
2000
- requestDurationMsecs: number;
1793
+ blockTimestamp: number;
2001
1794
  /**
2002
- * The response code of the request.
1795
+ * The block hash identifier.
2003
1796
  */
2004
- responseCode: number;
1797
+ blockHash: string;
2005
1798
  /**
2006
- * The chain id of the request.
1799
+ * The index at which the transaction occured in the block (0-indexed).
2007
1800
  */
2008
- chainId?: string;
1801
+ blockIndex: number;
2009
1802
  /**
2010
- * The rpc method of the request.
1803
+ * The transaction hash identifier.
2011
1804
  */
2012
- rpcMethod?: string;
1805
+ txHash: string;
2013
1806
  /**
2014
- * The metadata of the request.
1807
+ * The transaction status, which is either 0 (failed) or 1 (successful).
2015
1808
  */
2016
- metadata: LogsFormatMetadata;
2017
- };
2018
-
2019
- type LogsResponseDTO = {
1809
+ txStatus: string;
2020
1810
  /**
2021
- * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
1811
+ * The transaction type.
2022
1812
  */
2023
- nextPageToken?: string;
1813
+ txType: number;
2024
1814
  /**
2025
- * The organization id of the request.
1815
+ * The gas limit set for the transaction.
2026
1816
  */
2027
- orgId: string;
1817
+ gasLimit: string;
2028
1818
  /**
2029
- * An array of logs representing the requests made by clients.
1819
+ * The amount of gas used.
2030
1820
  */
2031
- logs: Array<LogsFormat>;
2032
- };
2033
-
2034
- declare enum TimeIntervalGranularityExtended {
2035
- MINUTE = "minute",
2036
- HOURLY = "hourly",
2037
- DAILY = "daily",
2038
- WEEKLY = "weekly",
2039
- MONTHLY = "monthly"
2040
- }
2041
-
2042
- declare enum UsageMetricsGroupByEnum {
2043
- REQUEST_PATH = "requestPath",
2044
- RESPONSE_CODE = "responseCode",
2045
- CHAIN_ID = "chainId",
2046
- API_KEY_ID = "apiKeyId",
2047
- REQUEST_TYPE = "requestType"
2048
- }
2049
-
2050
- type UsageMetricsValueDTO = {
1821
+ gasUsed: string;
2051
1822
  /**
2052
- * Column name used for data aggregation
1823
+ * The gas price denominated by the number of decimals of the native token.
2053
1824
  */
2054
- groupedBy: UsageMetricsValueDTO.groupedBy;
1825
+ gasPrice: string;
2055
1826
  /**
2056
- * The value of the column used for data aggregation
1827
+ * The nonce used by the sender of the transaction.
2057
1828
  */
2058
- groupValue?: (string | number);
1829
+ nonce: string;
1830
+ from: RichAddress;
1831
+ to: RichAddress;
1832
+ method?: Method;
1833
+ value: string;
1834
+ };
1835
+
1836
+ type ListNativeTransactionsResponse = {
2059
1837
  /**
2060
- * The total number of requests
1838
+ * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
2061
1839
  */
2062
- totalRequests: number;
1840
+ nextPageToken?: string;
1841
+ transactions: Array<NativeTransaction>;
1842
+ };
1843
+
1844
+ type TransactionDetails = {
2063
1845
  /**
2064
- * The number of requests per second
1846
+ * The native (top-level) transaction details.
2065
1847
  */
2066
- requestsPerSecond: number;
1848
+ nativeTransaction: NativeTransaction;
2067
1849
  /**
2068
- * The success rate percentage
1850
+ * The list of ERC-20 transfers.
2069
1851
  */
2070
- successRatePercent: number;
1852
+ erc20Transfers?: Array<Erc20TransferDetails>;
2071
1853
  /**
2072
- * The median response time in milliseconds
1854
+ * The list of ERC-721 transfers.
2073
1855
  */
2074
- medianResponseTimeMsecs: number;
1856
+ erc721Transfers?: Array<Erc721TransferDetails>;
2075
1857
  /**
2076
- * The number of invalid requests
1858
+ * The list of ERC-1155 transfers.
2077
1859
  */
2078
- invalidRequests: number;
1860
+ erc1155Transfers?: Array<Erc1155TransferDetails>;
2079
1861
  /**
2080
- * The number of API credits used
1862
+ * The list of internal transactions. Note that this list only includes CALL and CALLCODE internal transactions that had a non-zero value and CREATE/CREATE2 calls. Use a client provider to recieve a full debug trace of the transaction.
2081
1863
  */
2082
- apiCreditsUsed: number;
1864
+ internalTransactions?: Array<InternalTransactionDetails>;
1865
+ };
1866
+
1867
+ type ListTransactionDetailsResponse = {
2083
1868
  /**
2084
- * The number of API credits wasted on invalid requests
1869
+ * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
2085
1870
  */
2086
- apiCreditsWasted: number;
1871
+ nextPageToken?: string;
1872
+ transactions: Array<TransactionDetails>;
2087
1873
  };
2088
- declare namespace UsageMetricsValueDTO {
1874
+
1875
+ type ListTransfersResponse = {
2089
1876
  /**
2090
- * Column name used for data aggregation
1877
+ * A token, which can be sent as `pageToken` to retrieve the next page. If this field is omitted or empty, there are no subsequent pages.
2091
1878
  */
2092
- enum groupedBy {
2093
- REQUEST_PATH = "requestPath",
2094
- RESPONSE_CODE = "responseCode",
2095
- CHAIN_ID = "chainId",
2096
- API_KEY_ID = "apiKeyId",
2097
- REQUEST_TYPE = "requestType",
2098
- NONE = "None"
2099
- }
1879
+ nextPageToken?: string;
1880
+ transfers: Array<(Erc20Transfer | Erc721Transfer | Erc1155Transfer)>;
1881
+ };
1882
+
1883
+ declare enum SortOrder {
1884
+ ASC = "asc",
1885
+ DESC = "desc"
2100
1886
  }
2101
1887
 
2102
- type Metric = {
1888
+ declare enum TransactionStatus {
1889
+ FAILED = "failed",
1890
+ SUCCESS = "success"
1891
+ }
1892
+
1893
+ declare class EvmTransactionsService {
1894
+ readonly httpRequest: BaseHttpRequest;
1895
+ constructor(httpRequest: BaseHttpRequest);
2103
1896
  /**
2104
- * The timestamp of the metrics value
1897
+ * Get deployment transaction
1898
+ * If the address is a smart contract, returns the transaction in which it was deployed.
1899
+ * @returns GetTransactionResponse Successful response
1900
+ * @throws ApiError
2105
1901
  */
2106
- timestamp: number;
1902
+ getDeploymentTransaction({ chainId, address, currency, }: {
1903
+ /**
1904
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1905
+ */
1906
+ chainId: string;
1907
+ /**
1908
+ * Contract address on the relevant chain.
1909
+ */
1910
+ address: string;
1911
+ /**
1912
+ * The currency that return values should use. Defaults to USD.
1913
+ */
1914
+ currency?: CurrencyCode;
1915
+ }): CancelablePromise<GetTransactionResponse>;
2107
1916
  /**
2108
- * The metrics values for the timestamp
1917
+ * List deployed contracts
1918
+ * Lists all contracts deployed by the given address.
1919
+ * @returns ListContractsResponse Successful response
1920
+ * @throws ApiError
2109
1921
  */
2110
- values: Array<UsageMetricsValueDTO>;
2111
- };
2112
-
2113
- type UsageMetricsResponseDTO = {
1922
+ listContractDeployments({ chainId, address, pageToken, pageSize, }: {
1923
+ /**
1924
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1925
+ */
1926
+ chainId: string;
1927
+ /**
1928
+ * A wallet address.
1929
+ */
1930
+ address: string;
1931
+ /**
1932
+ * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
1933
+ */
1934
+ pageToken?: string;
1935
+ /**
1936
+ * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
1937
+ */
1938
+ pageSize?: number;
1939
+ }): CancelablePromise<ListContractsResponse>;
2114
1940
  /**
2115
- * Duration in which the metrics value is aggregated
1941
+ * List ERC transfers
1942
+ * Lists ERC transfers for an ERC-20, ERC-721, or ERC-1155 contract address.
1943
+ * @returns ListTransfersResponse Successful response
1944
+ * @throws ApiError
1945
+ */
1946
+ listTransfers({ chainId, address, startBlock, endBlock, pageToken, pageSize, }: {
1947
+ /**
1948
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1949
+ */
1950
+ chainId: string;
1951
+ /**
1952
+ * A wallet address.
1953
+ */
1954
+ address: string;
1955
+ /**
1956
+ * The block range start number, inclusive. If endBlock is not defined when startBlock is defined, the end of the range will be the most recent block.
1957
+ */
1958
+ startBlock?: number;
1959
+ /**
1960
+ * The block range end number, exclusive. If startBlock is not defined when endBlock is defined, the start of the range will be the genesis block.
1961
+ */
1962
+ endBlock?: number;
1963
+ /**
1964
+ * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
1965
+ */
1966
+ pageToken?: string;
1967
+ /**
1968
+ * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
1969
+ */
1970
+ pageSize?: number;
1971
+ }): CancelablePromise<ListTransfersResponse>;
1972
+ /**
1973
+ * List transactions
1974
+ * Returns a list of transactions where the given wallet address had an on-chain interaction for the given chain. The ERC-20 transfers, ERC-721 transfers, ERC-1155, and internal transactions returned are only those where the input address had an interaction. Specifically, those lists only inlcude entries where the input address was the sender (`from` field) or the receiver (`to` field) for the sub-transaction. Therefore the transactions returned from this list may not be complete representations of the on-chain data. For a complete view of a transaction use the `/chains/:chainId/transactions/:txHash` endpoint.
1975
+ *
1976
+ * Filterable by block ranges.
1977
+ * @returns ListTransactionDetailsResponse Successful response
1978
+ * @throws ApiError
2116
1979
  */
2117
- aggregateDuration: string;
1980
+ listTransactions({ chainId, address, pageToken, pageSize, startBlock, endBlock, sortOrder, }: {
1981
+ /**
1982
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
1983
+ */
1984
+ chainId: string;
1985
+ /**
1986
+ * A wallet address.
1987
+ */
1988
+ address: string;
1989
+ /**
1990
+ * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
1991
+ */
1992
+ pageToken?: string;
1993
+ /**
1994
+ * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
1995
+ */
1996
+ pageSize?: number;
1997
+ /**
1998
+ * The block range start number, inclusive. If endBlock is not defined when startBlock is defined, the end of the range will be the most recent block.
1999
+ */
2000
+ startBlock?: number;
2001
+ /**
2002
+ * The block range end number, exclusive. If startBlock is not defined when endBlock is defined, the start of the range will be the genesis block.
2003
+ */
2004
+ endBlock?: number;
2005
+ /**
2006
+ * The order by which to sort results. Use "asc" for ascending order, "desc" for descending order. Sorted by timestamp or the `sortBy` query parameter, if provided.
2007
+ */
2008
+ sortOrder?: SortOrder;
2009
+ }): CancelablePromise<ListTransactionDetailsResponse>;
2118
2010
  /**
2119
- * Org ID for which the metrics are aggregated
2011
+ * List native transactions
2012
+ * Lists native transactions for an address. Filterable by block range.
2013
+ * @returns ListNativeTransactionsResponse Successful response
2014
+ * @throws ApiError
2120
2015
  */
2121
- orgId: string;
2016
+ listNativeTransactions({ chainId, address, startBlock, endBlock, pageToken, pageSize, }: {
2017
+ /**
2018
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
2019
+ */
2020
+ chainId: string;
2021
+ /**
2022
+ * A wallet address.
2023
+ */
2024
+ address: string;
2025
+ /**
2026
+ * The block range start number, inclusive. If endBlock is not defined when startBlock is defined, the end of the range will be the most recent block.
2027
+ */
2028
+ startBlock?: number;
2029
+ /**
2030
+ * The block range end number, exclusive. If startBlock is not defined when endBlock is defined, the start of the range will be the genesis block.
2031
+ */
2032
+ endBlock?: number;
2033
+ /**
2034
+ * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
2035
+ */
2036
+ pageToken?: string;
2037
+ /**
2038
+ * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
2039
+ */
2040
+ pageSize?: number;
2041
+ }): CancelablePromise<ListNativeTransactionsResponse>;
2122
2042
  /**
2123
- * Metrics values
2043
+ * List ERC-20 transfers
2044
+ * Lists ERC-20 transfers for an address. Filterable by block range.
2045
+ * @returns ListErc20TransactionsResponse Successful response
2046
+ * @throws ApiError
2124
2047
  */
2125
- metrics: Array<Metric>;
2126
- };
2127
-
2128
- declare class GlacierApiUsageMetricsService {
2129
- readonly httpRequest: BaseHttpRequest;
2130
- constructor(httpRequest: BaseHttpRequest);
2048
+ listErc20Transactions({ chainId, address, startBlock, endBlock, pageToken, pageSize, }: {
2049
+ /**
2050
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
2051
+ */
2052
+ chainId: string;
2053
+ /**
2054
+ * A wallet address.
2055
+ */
2056
+ address: string;
2057
+ /**
2058
+ * The block range start number, inclusive. If endBlock is not defined when startBlock is defined, the end of the range will be the most recent block.
2059
+ */
2060
+ startBlock?: number;
2061
+ /**
2062
+ * The block range end number, exclusive. If startBlock is not defined when endBlock is defined, the start of the range will be the genesis block.
2063
+ */
2064
+ endBlock?: number;
2065
+ /**
2066
+ * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
2067
+ */
2068
+ pageToken?: string;
2069
+ /**
2070
+ * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
2071
+ */
2072
+ pageSize?: number;
2073
+ }): CancelablePromise<ListErc20TransactionsResponse>;
2131
2074
  /**
2132
- * Get usage metrics for the Glacier API
2133
- * Gets metrics for Glacier API usage over a specified time interval aggregated at the specified time-duration granularity.
2134
- * @returns UsageMetricsResponseDTO Successful response
2075
+ * List ERC-721 transfers
2076
+ * Lists ERC-721 transfers for an address. Filterable by block range.
2077
+ * @returns ListErc721TransactionsResponse Successful response
2135
2078
  * @throws ApiError
2136
2079
  */
2137
- getApiUsageMetrics({ orgId, startTimestamp, endTimestamp, timeInterval, groupBy, requestPath, requestType, responseCode, chainId, apiKeyId, }: {
2080
+ listErc721Transactions({ chainId, address, startBlock, endBlock, pageToken, pageSize, }: {
2138
2081
  /**
2139
- * Organization ID to fetch usage metrics for
2082
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
2140
2083
  */
2141
- orgId?: string;
2084
+ chainId: string;
2142
2085
  /**
2143
- * Query param for retrieving items after a specific timestamp.
2086
+ * A wallet address.
2144
2087
  */
2145
- startTimestamp?: number;
2088
+ address: string;
2146
2089
  /**
2147
- * Query param for retrieving items before a specific timestamp.
2090
+ * The block range start number, inclusive. If endBlock is not defined when startBlock is defined, the end of the range will be the most recent block.
2148
2091
  */
2149
- endTimestamp?: number;
2092
+ startBlock?: number;
2150
2093
  /**
2151
- * Time interval granularity for data aggregation
2094
+ * The block range end number, exclusive. If startBlock is not defined when endBlock is defined, the start of the range will be the genesis block.
2152
2095
  */
2153
- timeInterval?: TimeIntervalGranularityExtended;
2096
+ endBlock?: number;
2154
2097
  /**
2155
- * Query param for the criterion used for grouping metrics
2098
+ * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
2156
2099
  */
2157
- groupBy?: UsageMetricsGroupByEnum;
2100
+ pageToken?: string;
2158
2101
  /**
2159
- * Filter data by request path.
2102
+ * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
2160
2103
  */
2161
- requestPath?: string;
2104
+ pageSize?: number;
2105
+ }): CancelablePromise<ListErc721TransactionsResponse>;
2106
+ /**
2107
+ * List ERC-1155 transfers
2108
+ * Lists ERC-1155 transfers for an address. Filterable by block range.
2109
+ * @returns ListErc1155TransactionsResponse Successful response
2110
+ * @throws ApiError
2111
+ */
2112
+ listErc1155Transactions({ chainId, address, startBlock, endBlock, pageToken, pageSize, }: {
2162
2113
  /**
2163
- * Filter data by request type.
2114
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
2164
2115
  */
2165
- requestType?: 'data' | 'rpc';
2116
+ chainId: string;
2166
2117
  /**
2167
- * Filter data by response status code.
2118
+ * A wallet address.
2168
2119
  */
2169
- responseCode?: string;
2120
+ address: string;
2170
2121
  /**
2171
- * Filter data by chain ID.
2122
+ * The block range start number, inclusive. If endBlock is not defined when startBlock is defined, the end of the range will be the most recent block.
2172
2123
  */
2173
- chainId?: string;
2124
+ startBlock?: number;
2174
2125
  /**
2175
- * Filter data by API key ID.
2126
+ * The block range end number, exclusive. If startBlock is not defined when endBlock is defined, the start of the range will be the genesis block.
2176
2127
  */
2177
- apiKeyId?: string;
2178
- }): CancelablePromise<UsageMetricsResponseDTO>;
2128
+ endBlock?: number;
2129
+ /**
2130
+ * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
2131
+ */
2132
+ pageToken?: string;
2133
+ /**
2134
+ * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
2135
+ */
2136
+ pageSize?: number;
2137
+ }): CancelablePromise<ListErc1155TransactionsResponse>;
2179
2138
  /**
2180
- * Get logs for requests made by client
2181
- * Gets logs for requests made by client over a specified time interval for a specific organization.
2182
- * @returns LogsResponseDTO Successful response
2139
+ * List internal transactions
2140
+ * Returns a list of internal transactions for an address and chain. Filterable by block range.
2141
+ *
2142
+ * Note that the internal transactions list only contains `CALL` or `CALLCODE` transactions with a non-zero value and `CREATE`/`CREATE2` transactions. To get a complete list of internal transactions use the `debug_` prefixed RPC methods on an archive node.
2143
+ * @returns ListInternalTransactionsResponse Successful response
2183
2144
  * @throws ApiError
2184
2145
  */
2185
- getApiLogs({ orgId, startTimestamp, endTimestamp, requestPath, requestType, responseCode, chainId, apiKeyId, pageToken, pageSize, }: {
2146
+ listInternalTransactions({ chainId, address, startBlock, endBlock, pageToken, pageSize, }: {
2186
2147
  /**
2187
- * Organization ID to fetch usage metrics for
2148
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
2188
2149
  */
2189
- orgId?: string;
2150
+ chainId: string;
2190
2151
  /**
2191
- * Query param for retrieving items after a specific timestamp.
2152
+ * A wallet address.
2192
2153
  */
2193
- startTimestamp?: number;
2154
+ address: string;
2194
2155
  /**
2195
- * Query param for retrieving items before a specific timestamp.
2156
+ * The block range start number, inclusive. If endBlock is not defined when startBlock is defined, the end of the range will be the most recent block.
2196
2157
  */
2197
- endTimestamp?: number;
2158
+ startBlock?: number;
2198
2159
  /**
2199
- * Filter data by request path.
2160
+ * The block range end number, exclusive. If startBlock is not defined when endBlock is defined, the start of the range will be the genesis block.
2200
2161
  */
2201
- requestPath?: string;
2162
+ endBlock?: number;
2202
2163
  /**
2203
- * Filter data by request type.
2164
+ * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
2204
2165
  */
2205
- requestType?: 'data' | 'rpc';
2166
+ pageToken?: string;
2206
2167
  /**
2207
- * Filter data by response status code.
2168
+ * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
2208
2169
  */
2209
- responseCode?: string;
2170
+ pageSize?: number;
2171
+ }): CancelablePromise<ListInternalTransactionsResponse>;
2172
+ /**
2173
+ * Get transaction
2174
+ * Gets the details of a single transaction.
2175
+ * @returns GetTransactionResponse Successful response
2176
+ * @throws ApiError
2177
+ */
2178
+ getTransaction({ chainId, txHash, }: {
2210
2179
  /**
2211
- * Filter data by chain ID.
2180
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
2212
2181
  */
2213
- chainId?: string;
2182
+ chainId: string;
2214
2183
  /**
2215
- * Filter data by API key ID.
2184
+ * A transaction hash.
2216
2185
  */
2217
- apiKeyId?: string;
2186
+ txHash: string;
2187
+ }): CancelablePromise<GetTransactionResponse>;
2188
+ /**
2189
+ * List transactions for a block
2190
+ * Lists the transactions that occured in a given block.
2191
+ * @returns ListNativeTransactionsResponse Successful response
2192
+ * @throws ApiError
2193
+ */
2194
+ getTransactionsForBlock({ chainId, blockId, }: {
2195
+ /**
2196
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
2197
+ */
2198
+ chainId: string;
2199
+ /**
2200
+ * A block identifier which is either a block number or the block hash.
2201
+ */
2202
+ blockId: string;
2203
+ }): CancelablePromise<ListNativeTransactionsResponse>;
2204
+ /**
2205
+ * List latest transactions
2206
+ * Lists the latest transactions. Filterable by status.
2207
+ * @returns ListNativeTransactionsResponse Successful response
2208
+ * @throws ApiError
2209
+ */
2210
+ listLatestTransactions({ chainId, pageToken, pageSize, status, }: {
2211
+ /**
2212
+ * A supported evm chain id, chain alias or blockchain id. Use the `/chains` endpoint to get a list of supported chain ids.
2213
+ */
2214
+ chainId: string;
2218
2215
  /**
2219
2216
  * A page token, received from a previous list call. Provide this to retrieve the subsequent page.
2220
2217
  */
2221
2218
  pageToken?: string;
2222
2219
  /**
2223
- * The maximum number of items to return.
2220
+ * The maximum number of items to return. The minimum page size is 1. The maximum pageSize is 100.
2224
2221
  */
2225
2222
  pageSize?: number;
2226
- }): CancelablePromise<LogsResponseDTO>;
2223
+ /**
2224
+ * A status filter for listed transactions.
2225
+ */
2226
+ status?: TransactionStatus;
2227
+ }): CancelablePromise<ListNativeTransactionsResponse>;
2227
2228
  }
2228
2229
 
2229
2230
  declare class HealthCheckService {
@@ -2694,6 +2695,7 @@ type CompletedValidatorDetails = {
2694
2695
  */
2695
2696
  blsCredentials?: BlsCredentials;
2696
2697
  delegatorCount: number;
2698
+ amountDelegated?: string;
2697
2699
  rewards: Rewards;
2698
2700
  validationStatus: CompletedValidatorDetails.validationStatus;
2699
2701
  };
@@ -4971,13 +4973,13 @@ declare class WebhooksService {
4971
4973
 
4972
4974
  type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;
4973
4975
  declare class Glacier {
4976
+ readonly dataApiUsageMetrics: DataApiUsageMetricsService;
4974
4977
  readonly default: DefaultService;
4975
4978
  readonly evmBalances: EvmBalancesService;
4976
4979
  readonly evmBlocks: EvmBlocksService;
4977
4980
  readonly evmChains: EvmChainsService;
4978
4981
  readonly evmContracts: EvmContractsService;
4979
4982
  readonly evmTransactions: EvmTransactionsService;
4980
- readonly glacierApiUsageMetrics: GlacierApiUsageMetricsService;
4981
4983
  readonly healthCheck: HealthCheckService;
4982
4984
  readonly nfTs: NfTsService;
4983
4985
  readonly operations: OperationsService;
@@ -5143,4 +5145,4 @@ type Unauthorized = {
5143
5145
  error: string;
5144
5146
  };
5145
5147
 
5146
- export { ActiveDelegatorDetails, ActiveValidatorDetails, AddressActivityMetadata, AddressesChangeRequest, AggregatedAssetAmount, ApiError, AssetAmount, AssetWithPriceInfo, BadGateway, BadRequest, BaseHttpRequest, Blockchain, BlockchainId, BlockchainIds, BlockchainInfo, BlsCredentials, CChainAtomicBalances, CChainExportTransaction, CChainImportTransaction, CChainSharedAssetBalance, CancelError, CancelablePromise, ChainAddressChainIdMap, ChainAddressChainIdMapListResponse, ChainInfo, ChainStatus, CompletedDelegatorDetails, CompletedValidatorDetails, ContractDeploymentDetails, ContractSubmissionBody, ContractSubmissionErc1155, ContractSubmissionErc20, ContractSubmissionErc721, ContractSubmissionUnknown, CreateEvmTransactionExportRequest, CreatePrimaryNetworkTransactionExportRequest, CreateWebhookRequest, CurrencyCode, DataListChainsResponse, DefaultService, DelegationStatusType, DelegatorsDetails, DeliveredSourceNotIndexedTeleporterMessage, DeliveredTeleporterMessage, EVMInput, EVMOperationType, EVMOutput, Erc1155Contract, Erc1155Token, Erc1155TokenBalance, Erc1155TokenMetadata, Erc1155Transfer, Erc1155TransferDetails, Erc20Contract, Erc20Token, Erc20TokenBalance, Erc20Transfer, Erc20TransferDetails, Erc721Contract, Erc721Token, Erc721TokenBalance, Erc721TokenMetadata, Erc721Transfer, Erc721TransferDetails, EventType, EvmBalancesService, EvmBlock, EvmBlocksService, EvmChainsService, EvmContractsService, EvmNetworkOptions, EvmTransactionsService, Forbidden, FullNativeTransactionDetails, GetChainResponse, GetEvmBlockResponse, GetNativeBalanceResponse, GetNetworkDetailsResponse, GetPrimaryNetworkBlockResponse, GetTransactionResponse, Glacier, GlacierApiFeature, GlacierApiUsageMetricsService, HealthCheckService, HistoricalReward, ImageAsset, InternalServerError, InternalTransaction, InternalTransactionDetails, InternalTransactionOpCall, ListBlockchainsResponse, ListCChainAtomicBalancesResponse, ListCChainAtomicTransactionsResponse, ListChainsResponse, ListCollectibleBalancesResponse, ListContractsResponse, ListDelegatorDetailsResponse, ListErc1155BalancesResponse, ListErc1155TransactionsResponse, ListErc20BalancesResponse, ListErc20TransactionsResponse, ListErc721BalancesResponse, ListErc721TransactionsResponse, ListEvmBlocksResponse, ListHistoricalRewardsResponse, ListInternalTransactionsResponse, ListNativeTransactionsResponse, ListNftTokens, ListPChainBalancesResponse, ListPChainTransactionsResponse, ListPChainUtxosResponse, ListPendingRewardsResponse, ListPrimaryNetworkBlocksResponse, ListSubnetsResponse, ListTeleporterMessagesResponse, ListTransactionDetailsResponse, ListTransfersResponse, ListUtxosResponse, ListValidatorDetailsResponse, ListWebhookAddressesResponse, ListWebhooksResponse, ListXChainBalancesResponse, ListXChainTransactionsResponse, ListXChainVerticesResponse, LogsFormat, LogsFormatMetadata, LogsResponseDTO, Method, Metric, Money, NativeTokenBalance, NativeTransaction, Network, NetworkToken, NetworkTokenDetails, NetworkType, NextPageToken, NfTsService, NftTokenMetadataStatus, NotFound, OpenAPI, OpenAPIConfig, OperationStatus, OperationStatusCode, OperationStatusResponse, OperationType, OperationsService, PChainBalance, PChainId, PChainSharedAsset, PChainTransaction, PChainTransactionType, PChainUtxo, PendingDelegatorDetails, PendingReward, PendingTeleporterMessage, PendingValidatorDetails, PricingProviders, PrimaryNetwork, PrimaryNetworkAssetCap, PrimaryNetworkAssetType, PrimaryNetworkBalancesService, PrimaryNetworkBlock, PrimaryNetworkBlocksService, PrimaryNetworkChainInfo, PrimaryNetworkChainName, PrimaryNetworkOperationType, PrimaryNetworkOptions, PrimaryNetworkRewardsService, PrimaryNetworkService, PrimaryNetworkTransactionsService, PrimaryNetworkTxType, PrimaryNetworkUtxOsService, PrimaryNetworkVerticesService, ProposerDetails, RemovedValidatorDetails, RequestType, ResourceLink, ResourceLinkType, RewardType, Rewards, RichAddress, RpcErrorDto, RpcErrorResponseDto, RpcRequestBodyDto, RpcService, RpcSuccessResponseDto, ServiceUnavailable, SharedSecretsResponse, SortByOption, SortOrder, StakingDistribution, Subnet, SubnetOwnershipInfo, TeleporterDestinationTransaction, TeleporterMessageInfo, TeleporterReceipt, TeleporterRewardDetails, TeleporterService, TeleporterSourceTransaction, TimeIntervalGranularityExtended, TooManyRequests, TransactionDetails, TransactionDirectionType, TransactionExportMetadata, TransactionMethodType, TransactionStatus, TransactionVertexDetail, Unauthorized, UnknownContract, UpdateContractResponse, UpdateWebhookRequest, UsageMetricsGroupByEnum, UsageMetricsResponseDTO, UsageMetricsValueDTO, UtilityAddresses, Utxo, UtxoCredential, UtxoType, ValidationStatusType, ValidatorHealthDetails, ValidatorsDetails, VmName, WebhookResponse, WebhookStatus, WebhookStatusType, WebhooksService, XChainAssetDetails, XChainBalances, XChainId, XChainLinearTransaction, XChainNonLinearTransaction, XChainSharedAssetBalance, XChainTransactionType, XChainVertex };
5148
+ export { ActiveDelegatorDetails, ActiveValidatorDetails, AddressActivityMetadata, AddressesChangeRequest, AggregatedAssetAmount, ApiError, ApiFeature, AssetAmount, AssetWithPriceInfo, BadGateway, BadRequest, BaseHttpRequest, Blockchain, BlockchainId, BlockchainIds, BlockchainInfo, BlsCredentials, CChainAtomicBalances, CChainExportTransaction, CChainImportTransaction, CChainSharedAssetBalance, CancelError, CancelablePromise, ChainAddressChainIdMap, ChainAddressChainIdMapListResponse, ChainInfo, ChainStatus, CompletedDelegatorDetails, CompletedValidatorDetails, ContractDeploymentDetails, ContractSubmissionBody, ContractSubmissionErc1155, ContractSubmissionErc20, ContractSubmissionErc721, ContractSubmissionUnknown, CreateEvmTransactionExportRequest, CreatePrimaryNetworkTransactionExportRequest, CreateWebhookRequest, CurrencyCode, DataApiUsageMetricsService, DataListChainsResponse, DefaultService, DelegationStatusType, DelegatorsDetails, DeliveredSourceNotIndexedTeleporterMessage, DeliveredTeleporterMessage, EVMInput, EVMOperationType, EVMOutput, Erc1155Contract, Erc1155Token, Erc1155TokenBalance, Erc1155TokenMetadata, Erc1155Transfer, Erc1155TransferDetails, Erc20Contract, Erc20Token, Erc20TokenBalance, Erc20Transfer, Erc20TransferDetails, Erc721Contract, Erc721Token, Erc721TokenBalance, Erc721TokenMetadata, Erc721Transfer, Erc721TransferDetails, EventType, EvmBalancesService, EvmBlock, EvmBlocksService, EvmChainsService, EvmContractsService, EvmNetworkOptions, EvmTransactionsService, Forbidden, FullNativeTransactionDetails, GetChainResponse, GetEvmBlockResponse, GetNativeBalanceResponse, GetNetworkDetailsResponse, GetPrimaryNetworkBlockResponse, GetTransactionResponse, Glacier, HealthCheckService, HistoricalReward, ImageAsset, InternalServerError, InternalTransaction, InternalTransactionDetails, InternalTransactionOpCall, ListBlockchainsResponse, ListCChainAtomicBalancesResponse, ListCChainAtomicTransactionsResponse, ListChainsResponse, ListCollectibleBalancesResponse, ListContractsResponse, ListDelegatorDetailsResponse, ListErc1155BalancesResponse, ListErc1155TransactionsResponse, ListErc20BalancesResponse, ListErc20TransactionsResponse, ListErc721BalancesResponse, ListErc721TransactionsResponse, ListEvmBlocksResponse, ListHistoricalRewardsResponse, ListInternalTransactionsResponse, ListNativeTransactionsResponse, ListNftTokens, ListPChainBalancesResponse, ListPChainTransactionsResponse, ListPChainUtxosResponse, ListPendingRewardsResponse, ListPrimaryNetworkBlocksResponse, ListSubnetsResponse, ListTeleporterMessagesResponse, ListTransactionDetailsResponse, ListTransfersResponse, ListUtxosResponse, ListValidatorDetailsResponse, ListWebhookAddressesResponse, ListWebhooksResponse, ListXChainBalancesResponse, ListXChainTransactionsResponse, ListXChainVerticesResponse, LogsFormat, LogsFormatMetadata, LogsResponseDTO, Method, Metric, Money, NativeTokenBalance, NativeTransaction, Network, NetworkToken, NetworkTokenDetails, NetworkType, NextPageToken, NfTsService, NftTokenMetadataStatus, NotFound, OpenAPI, OpenAPIConfig, OperationStatus, OperationStatusCode, OperationStatusResponse, OperationType, OperationsService, PChainBalance, PChainId, PChainSharedAsset, PChainTransaction, PChainTransactionType, PChainUtxo, PendingDelegatorDetails, PendingReward, PendingTeleporterMessage, PendingValidatorDetails, PricingProviders, PrimaryNetwork, PrimaryNetworkAssetCap, PrimaryNetworkAssetType, PrimaryNetworkBalancesService, PrimaryNetworkBlock, PrimaryNetworkBlocksService, PrimaryNetworkChainInfo, PrimaryNetworkChainName, PrimaryNetworkOperationType, PrimaryNetworkOptions, PrimaryNetworkRewardsService, PrimaryNetworkService, PrimaryNetworkTransactionsService, PrimaryNetworkTxType, PrimaryNetworkUtxOsService, PrimaryNetworkVerticesService, ProposerDetails, RemovedValidatorDetails, RequestType, ResourceLink, ResourceLinkType, RewardType, Rewards, RichAddress, RpcErrorDto, RpcErrorResponseDto, RpcRequestBodyDto, RpcService, RpcSuccessResponseDto, ServiceUnavailable, SharedSecretsResponse, SortByOption, SortOrder, StakingDistribution, Subnet, SubnetOwnershipInfo, TeleporterDestinationTransaction, TeleporterMessageInfo, TeleporterReceipt, TeleporterRewardDetails, TeleporterService, TeleporterSourceTransaction, TimeIntervalGranularityExtended, TooManyRequests, TransactionDetails, TransactionDirectionType, TransactionExportMetadata, TransactionMethodType, TransactionStatus, TransactionVertexDetail, Unauthorized, UnknownContract, UpdateContractResponse, UpdateWebhookRequest, UsageMetricsGroupByEnum, UsageMetricsResponseDTO, UsageMetricsValueDTO, UtilityAddresses, Utxo, UtxoCredential, UtxoType, ValidationStatusType, ValidatorHealthDetails, ValidatorsDetails, VmName, WebhookResponse, WebhookStatus, WebhookStatusType, WebhooksService, XChainAssetDetails, XChainBalances, XChainId, XChainLinearTransaction, XChainNonLinearTransaction, XChainSharedAssetBalance, XChainTransactionType, XChainVertex };