) -> CertificatePendingMessage {
CertificatePendingMessage {
epoch,
beacon: None,
@@ -57,3 +46,4 @@ impl CertificatePendingMessage {
}
}
}
+
diff --git a/rust/src/models/drep.rs b/rust/src/models/drep.rs
index cac1132e..82f75364 100644
--- a/rust/src/models/drep.rs
+++ b/rust/src/models/drep.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -31,10 +31,10 @@ pub struct Drep {
/// Flag which shows if this DRep credentials are a script hash
#[serde(rename = "has_script")]
pub has_script: bool,
- /// Indicates the registration state of the DRep. Set to `true` if the DRep has been deregistered; otherwise, `false`.
+ /// Registration state of the DRep. Set to `true` if the DRep has been deregistered; otherwise, `false`.
#[serde(rename = "retired")]
pub retired: bool,
- /// Indicates whether the DRep has been inactive for a consecutive number of epochs (determined by a epoch parameter `drep_activity`)
+ /// Whether the DRep has been inactive for a consecutive number of epochs (determined by a epoch parameter `drep_activity`)
#[serde(rename = "expired")]
pub expired: bool,
/// Epoch of the most recent action - registration, update, deregistration or voting
diff --git a/rust/src/models/drep_delegators_inner.rs b/rust/src/models/drep_delegators_inner.rs
index a3e5e3f7..1f80d1ce 100644
--- a/rust/src/models/drep_delegators_inner.rs
+++ b/rust/src/models/drep_delegators_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/drep_metadata.rs b/rust/src/models/drep_metadata.rs
index 6acf9099..94916f9d 100644
--- a/rust/src/models/drep_metadata.rs
+++ b/rust/src/models/drep_metadata.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/drep_updates_inner.rs b/rust/src/models/drep_updates_inner.rs
index d3ae8615..a41c986f 100644
--- a/rust/src/models/drep_updates_inner.rs
+++ b/rust/src/models/drep_updates_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -40,6 +40,8 @@ pub enum Action {
Registered,
#[serde(rename = "deregistered")]
Deregistered,
+ #[serde(rename = "updated")]
+ Updated,
}
impl Default for Action {
diff --git a/rust/src/models/drep_votes_inner.rs b/rust/src/models/drep_votes_inner.rs
index 84222d5e..069f9dd1 100644
--- a/rust/src/models/drep_votes_inner.rs
+++ b/rust/src/models/drep_votes_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -13,22 +13,34 @@ use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct DrepVotesInner {
- /// Hash of the proposal transaction.
+ /// Hash of the vote transaction.
#[serde(rename = "tx_hash")]
pub tx_hash: String,
- /// Index of the certificate within the proposal transaction.
+ /// Index of the certificate within the vote transaction.
#[serde(rename = "cert_index")]
pub cert_index: i32,
+ /// Governance Action Identifier (CIP-0129) of the proposal being voted on.
+ #[serde(rename = "proposal_id")]
+ pub proposal_id: String,
+ /// Hash of the proposal transaction.
+ #[serde(rename = "proposal_tx_hash")]
+ pub proposal_tx_hash: String,
+ /// Index of the certificate within the proposal transaction.
+ #[serde(rename = "proposal_cert_index")]
+ pub proposal_cert_index: i32,
/// The Vote. Can be one of yes, no, abstain.
#[serde(rename = "vote")]
pub vote: Vote,
}
impl DrepVotesInner {
- pub fn new(tx_hash: String, cert_index: i32, vote: Vote) -> DrepVotesInner {
+ pub fn new(tx_hash: String, cert_index: i32, proposal_id: String, proposal_tx_hash: String, proposal_cert_index: i32, vote: Vote) -> DrepVotesInner {
DrepVotesInner {
tx_hash,
cert_index,
+ proposal_id,
+ proposal_tx_hash,
+ proposal_cert_index,
vote,
}
}
diff --git a/rust/src/models/dreps_inner.rs b/rust/src/models/dreps_inner.rs
index 46540321..3a631887 100644
--- a/rust/src/models/dreps_inner.rs
+++ b/rust/src/models/dreps_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/epoch_content.rs b/rust/src/models/epoch_content.rs
index 3ae7892b..4f5462e3 100644
--- a/rust/src/models/epoch_content.rs
+++ b/rust/src/models/epoch_content.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/epoch_param_content.rs b/rust/src/models/epoch_param_content.rs
index 21c4e142..ee9dacd5 100644
--- a/rust/src/models/epoch_param_content.rs
+++ b/rust/src/models/epoch_param_content.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/epoch_settings_message.rs b/rust/src/models/epoch_settings_message.rs
index 548ffe39..34cf5ba3 100644
--- a/rust/src/models/epoch_settings_message.rs
+++ b/rust/src/models/epoch_settings_message.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -11,8 +11,6 @@
use crate::models;
use serde::{Deserialize, Serialize};
-use super::protocol_parameters::ProtocolParameters;
-
/// EpochSettingsMessage : Epoch settings
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct EpochSettingsMessage {
@@ -20,18 +18,14 @@ pub struct EpochSettingsMessage {
#[serde(rename = "epoch")]
pub epoch: i64,
#[serde(rename = "protocol")]
- pub protocol: ProtocolParameters,
+ pub protocol: models::ProtocolParameters,
#[serde(rename = "next_protocol")]
- pub next_protocol: ProtocolParameters,
+ pub next_protocol: models::ProtocolParameters,
}
impl EpochSettingsMessage {
/// Epoch settings
- pub fn new(
- epoch: i64,
- protocol: ProtocolParameters,
- next_protocol: ProtocolParameters,
- ) -> EpochSettingsMessage {
+ pub fn new(epoch: i64, protocol: models::ProtocolParameters, next_protocol: models::ProtocolParameters) -> EpochSettingsMessage {
EpochSettingsMessage {
epoch,
protocol,
@@ -39,3 +33,4 @@ impl EpochSettingsMessage {
}
}
}
+
diff --git a/rust/src/models/epoch_stake_content_inner.rs b/rust/src/models/epoch_stake_content_inner.rs
index 55553b8f..ad8e2814 100644
--- a/rust/src/models/epoch_stake_content_inner.rs
+++ b/rust/src/models/epoch_stake_content_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/epoch_stake_pool_content_inner.rs b/rust/src/models/epoch_stake_pool_content_inner.rs
index 89b4cc24..46e5c85b 100644
--- a/rust/src/models/epoch_stake_pool_content_inner.rs
+++ b/rust/src/models/epoch_stake_pool_content_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/error.rs b/rust/src/models/error.rs
index a0989a22..ad8b0581 100644
--- a/rust/src/models/error.rs
+++ b/rust/src/models/error.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/genesis_content.rs b/rust/src/models/genesis_content.rs
index c59cad77..eb63d829 100644
--- a/rust/src/models/genesis_content.rs
+++ b/rust/src/models/genesis_content.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/ipfs_add_200_response.rs b/rust/src/models/ipfs_add_200_response.rs
index 8f0357b7..e399326d 100644
--- a/rust/src/models/ipfs_add_200_response.rs
+++ b/rust/src/models/ipfs_add_200_response.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/mempool_content_inner.rs b/rust/src/models/mempool_content_inner.rs
index 0a786a78..944ed115 100644
--- a/rust/src/models/mempool_content_inner.rs
+++ b/rust/src/models/mempool_content_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/mempool_tx_content.rs b/rust/src/models/mempool_tx_content.rs
index 49b390f0..3b175760 100644
--- a/rust/src/models/mempool_tx_content.rs
+++ b/rust/src/models/mempool_tx_content.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -11,31 +11,20 @@
use crate::models;
use serde::{Deserialize, Serialize};
-use super::{
- mempool_tx_content_inputs_inner::MempoolTxContentInputsInner,
- mempool_tx_content_outputs_inner::MempoolTxContentOutputsInner,
- mempool_tx_content_redeemers_inner::MempoolTxContentRedeemersInner,
- mempool_tx_content_tx::MempoolTxContentTx,
-};
-
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct MempoolTxContent {
#[serde(rename = "tx")]
- pub tx: Box,
+ pub tx: Box,
#[serde(rename = "inputs")]
- pub inputs: Vec,
+ pub inputs: Vec,
#[serde(rename = "outputs")]
- pub outputs: Vec,
+ pub outputs: Vec,
#[serde(rename = "redeemers", skip_serializing_if = "Option::is_none")]
- pub redeemers: Option>,
+ pub redeemers: Option>,
}
impl MempoolTxContent {
- pub fn new(
- tx: MempoolTxContentTx,
- inputs: Vec,
- outputs: Vec,
- ) -> MempoolTxContent {
+ pub fn new(tx: models::MempoolTxContentTx, inputs: Vec, outputs: Vec) -> MempoolTxContent {
MempoolTxContent {
tx: Box::new(tx),
inputs,
@@ -44,3 +33,4 @@ impl MempoolTxContent {
}
}
}
+
diff --git a/rust/src/models/mempool_tx_content_inputs_inner.rs b/rust/src/models/mempool_tx_content_inputs_inner.rs
index 6fcfaf7b..dd9f02a5 100644
--- a/rust/src/models/mempool_tx_content_inputs_inner.rs
+++ b/rust/src/models/mempool_tx_content_inputs_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/mempool_tx_content_outputs_inner.rs b/rust/src/models/mempool_tx_content_outputs_inner.rs
index ee82af51..c98ea924 100644
--- a/rust/src/models/mempool_tx_content_outputs_inner.rs
+++ b/rust/src/models/mempool_tx_content_outputs_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -11,15 +11,13 @@
use crate::models;
use serde::{Deserialize, Serialize};
-use super::tx_content_output_amount_inner::TxContentOutputAmountInner;
-
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct MempoolTxContentOutputsInner {
/// Output address
#[serde(rename = "address")]
pub address: String,
#[serde(rename = "amount")]
- pub amount: Vec,
+ pub amount: Vec,
/// UTXO index in the transaction
#[serde(rename = "output_index")]
pub output_index: i32,
@@ -33,23 +31,12 @@ pub struct MempoolTxContentOutputsInner {
#[serde(rename = "collateral")]
pub collateral: bool,
/// The hash of the reference script of the output
- #[serde(
- rename = "reference_script_hash",
- deserialize_with = "Option::deserialize"
- )]
+ #[serde(rename = "reference_script_hash", deserialize_with = "Option::deserialize")]
pub reference_script_hash: Option,
}
impl MempoolTxContentOutputsInner {
- pub fn new(
- address: String,
- amount: Vec,
- output_index: i32,
- data_hash: Option,
- inline_datum: Option,
- collateral: bool,
- reference_script_hash: Option,
- ) -> MempoolTxContentOutputsInner {
+ pub fn new(address: String, amount: Vec, output_index: i32, data_hash: Option, inline_datum: Option, collateral: bool, reference_script_hash: Option) -> MempoolTxContentOutputsInner {
MempoolTxContentOutputsInner {
address,
amount,
@@ -61,3 +48,4 @@ impl MempoolTxContentOutputsInner {
}
}
}
+
diff --git a/rust/src/models/mempool_tx_content_redeemers_inner.rs b/rust/src/models/mempool_tx_content_redeemers_inner.rs
index 0d6748fd..06782523 100644
--- a/rust/src/models/mempool_tx_content_redeemers_inner.rs
+++ b/rust/src/models/mempool_tx_content_redeemers_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/mempool_tx_content_tx.rs b/rust/src/models/mempool_tx_content_tx.rs
index 9b0e7568..9be70b99 100644
--- a/rust/src/models/mempool_tx_content_tx.rs
+++ b/rust/src/models/mempool_tx_content_tx.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -11,15 +11,13 @@
use crate::models;
use serde::{Deserialize, Serialize};
-use super::tx_content_output_amount_inner::TxContentOutputAmountInner;
-
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct MempoolTxContentTx {
/// Transaction hash
#[serde(rename = "hash")]
pub hash: String,
#[serde(rename = "output_amount")]
- pub output_amount: Vec,
+ pub output_amount: Vec,
/// Fees of the transaction in Lovelaces
#[serde(rename = "fees")]
pub fees: String,
@@ -68,25 +66,7 @@ pub struct MempoolTxContentTx {
}
impl MempoolTxContentTx {
- pub fn new(
- hash: String,
- output_amount: Vec,
- fees: String,
- deposit: String,
- size: i32,
- invalid_before: Option,
- invalid_hereafter: Option,
- utxo_count: i32,
- withdrawal_count: i32,
- mir_cert_count: i32,
- delegation_count: i32,
- stake_cert_count: i32,
- pool_update_count: i32,
- pool_retire_count: i32,
- asset_mint_or_burn_count: i32,
- redeemer_count: i32,
- valid_contract: bool,
- ) -> MempoolTxContentTx {
+ pub fn new(hash: String, output_amount: Vec, fees: String, deposit: String, size: i32, invalid_before: Option, invalid_hereafter: Option, utxo_count: i32, withdrawal_count: i32, mir_cert_count: i32, delegation_count: i32, stake_cert_count: i32, pool_update_count: i32, pool_retire_count: i32, asset_mint_or_burn_count: i32, redeemer_count: i32, valid_contract: bool) -> MempoolTxContentTx {
MempoolTxContentTx {
hash,
output_amount,
@@ -108,3 +88,4 @@ impl MempoolTxContentTx {
}
}
}
+
diff --git a/rust/src/models/metrics_endpoints_inner.rs b/rust/src/models/metrics_endpoints_inner.rs
index b2f569b8..9ce07f8c 100644
--- a/rust/src/models/metrics_endpoints_inner.rs
+++ b/rust/src/models/metrics_endpoints_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/metrics_inner.rs b/rust/src/models/metrics_inner.rs
index fd699fbf..5825f420 100644
--- a/rust/src/models/metrics_inner.rs
+++ b/rust/src/models/metrics_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/mithril_stake_distribution_list_message_inner.rs b/rust/src/models/mithril_stake_distribution_list_message_inner.rs
index a425d353..ba8e6f64 100644
--- a/rust/src/models/mithril_stake_distribution_list_message_inner.rs
+++ b/rust/src/models/mithril_stake_distribution_list_message_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/mithril_stake_distribution_message.rs b/rust/src/models/mithril_stake_distribution_message.rs
index b63630fa..c847d417 100644
--- a/rust/src/models/mithril_stake_distribution_message.rs
+++ b/rust/src/models/mithril_stake_distribution_message.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -11,8 +11,6 @@
use crate::models;
use serde::{Deserialize, Serialize};
-use super::{protocol_parameters::ProtocolParameters, signer_with_stake::SignerWithStake};
-
/// MithrilStakeDistributionMessage : This message represents a Mithril stake distribution.
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct MithrilStakeDistributionMessage {
@@ -27,23 +25,17 @@ pub struct MithrilStakeDistributionMessage {
pub certificate_hash: Option,
/// The list of the signers with their stakes and verification keys
#[serde(rename = "signers")]
- pub signers: Vec,
+ pub signers: Vec,
/// Date and time of the entity creation
#[serde(rename = "created_at")]
pub created_at: String,
#[serde(rename = "protocol_parameters")]
- pub protocol_parameters: ProtocolParameters,
+ pub protocol_parameters: models::ProtocolParameters,
}
impl MithrilStakeDistributionMessage {
/// This message represents a Mithril stake distribution.
- pub fn new(
- epoch: i64,
- hash: String,
- signers: Vec,
- created_at: String,
- protocol_parameters: ProtocolParameters,
- ) -> MithrilStakeDistributionMessage {
+ pub fn new(epoch: i64, hash: String, signers: Vec, created_at: String, protocol_parameters: models::ProtocolParameters) -> MithrilStakeDistributionMessage {
MithrilStakeDistributionMessage {
epoch,
hash,
@@ -54,3 +46,4 @@ impl MithrilStakeDistributionMessage {
}
}
}
+
diff --git a/rust/src/models/mod.rs b/rust/src/models/mod.rs
index 14f5f9c7..7fe8363e 100644
--- a/rust/src/models/mod.rs
+++ b/rust/src/models/mod.rs
@@ -1,165 +1,344 @@
-pub mod signer_registrations_list_item_message;
-pub mod certificate_pending_message;
-pub mod tx_metadata_label_json_inner;
-pub mod signer_with_stake;
+pub mod account_addresses_assets_inner;
+pub use self::account_addresses_assets_inner::AccountAddressesAssetsInner;
+pub mod account_addresses_content_inner;
+pub use self::account_addresses_content_inner::AccountAddressesContentInner;
+pub mod account_addresses_total;
+pub use self::account_addresses_total::AccountAddressesTotal;
+pub mod account_addresses_total_received_sum_inner;
+pub use self::account_addresses_total_received_sum_inner::AccountAddressesTotalReceivedSumInner;
+pub mod account_content;
+pub use self::account_content::AccountContent;
+pub mod account_delegation_content_inner;
+pub use self::account_delegation_content_inner::AccountDelegationContentInner;
+pub mod account_history_content_inner;
+pub use self::account_history_content_inner::AccountHistoryContentInner;
pub mod account_mir_content_inner;
-pub mod asset_transactions_inner;
-pub mod network_eras_inner;
-pub mod ipfs_add_200_response;
-pub mod pool_metadata;
-pub mod drep_votes_inner;
-pub mod signers_tickers_message;
-pub mod proposal;
-pub mod _tx_submit_post_425_response;
-pub mod address_transactions_content_inner;
-pub mod asset_onchain_metadata_cip25_files_inner_src;
-pub mod pool_list_retire_inner;
+pub use self::account_mir_content_inner::AccountMirContentInner;
+pub mod account_registration_content_inner;
+pub use self::account_registration_content_inner::AccountRegistrationContentInner;
+pub mod account_reward_content_inner;
+pub use self::account_reward_content_inner::AccountRewardContentInner;
+pub mod account_transactions_content_inner;
+pub use self::account_transactions_content_inner::AccountTransactionsContentInner;
+pub mod account_utxo_content_inner;
+pub use self::account_utxo_content_inner::AccountUtxoContentInner;
+pub mod account_withdrawal_content_inner;
+pub use self::account_withdrawal_content_inner::AccountWithdrawalContentInner;
pub mod address_content;
-pub mod tx_content_cbor;
+pub use self::address_content::AddressContent;
+pub mod address_content_extended;
+pub use self::address_content_extended::AddressContentExtended;
+pub mod address_content_extended_amount_inner;
+pub use self::address_content_extended_amount_inner::AddressContentExtendedAmountInner;
+pub mod address_content_total;
+pub use self::address_content_total::AddressContentTotal;
+pub mod address_transactions_content_inner;
+pub use self::address_transactions_content_inner::AddressTransactionsContentInner;
+pub mod address_utxo_content_inner;
+pub use self::address_utxo_content_inner::AddressUtxoContentInner;
+pub mod aggregator_features_message;
+pub use self::aggregator_features_message::AggregatorFeaturesMessage;
+pub mod aggregator_features_message_capabilities;
+pub use self::aggregator_features_message_capabilities::AggregatorFeaturesMessageCapabilities;
+pub mod aggregator_features_message_capabilities_cardano_transactions_prover;
+pub use self::aggregator_features_message_capabilities_cardano_transactions_prover::AggregatorFeaturesMessageCapabilitiesCardanoTransactionsProver;
+pub mod asset;
+pub use self::asset::Asset;
+pub mod asset_addresses_inner;
+pub use self::asset_addresses_inner::AssetAddressesInner;
+pub mod asset_history_inner;
+pub use self::asset_history_inner::AssetHistoryInner;
+pub mod asset_metadata;
+pub use self::asset_metadata::AssetMetadata;
+pub mod asset_onchain_metadata_cip25;
+pub use self::asset_onchain_metadata_cip25::AssetOnchainMetadataCip25;
+pub mod asset_onchain_metadata_cip25_description;
+pub use self::asset_onchain_metadata_cip25_description::AssetOnchainMetadataCip25Description;
pub mod asset_onchain_metadata_cip25_files_inner;
+pub use self::asset_onchain_metadata_cip25_files_inner::AssetOnchainMetadataCip25FilesInner;
+pub mod asset_onchain_metadata_cip25_files_inner_src;
+pub use self::asset_onchain_metadata_cip25_files_inner_src::AssetOnchainMetadataCip25FilesInnerSrc;
+pub mod asset_onchain_metadata_cip25_image;
+pub use self::asset_onchain_metadata_cip25_image::AssetOnchainMetadataCip25Image;
+pub mod asset_onchain_metadata_cip68_ft_333;
+pub use self::asset_onchain_metadata_cip68_ft_333::AssetOnchainMetadataCip68Ft333;
+pub mod asset_onchain_metadata_cip68_nft_222;
+pub use self::asset_onchain_metadata_cip68_nft_222::AssetOnchainMetadataCip68Nft222;
+pub mod asset_onchain_metadata_cip68_rft_444;
+pub use self::asset_onchain_metadata_cip68_rft_444::AssetOnchainMetadataCip68Rft444;
+pub mod asset_policy_inner;
+pub use self::asset_policy_inner::AssetPolicyInner;
+pub mod asset_transactions_inner;
+pub use self::asset_transactions_inner::AssetTransactionsInner;
+pub mod assets_inner;
+pub use self::assets_inner::AssetsInner;
pub mod block_content;
-pub mod protocol_parameters;
-pub mod __get_400_response;
-pub mod tx_content_delegations_inner;
-pub mod metrics_endpoints_inner;
-pub mod pool_list_extended_inner;
-pub mod dreps_inner;
-pub mod protocol_message_parts;
-pub mod network_stake;
-pub mod account_utxo_content_inner;
-pub mod mempool_tx_content;
-pub mod protocol_message;
-pub mod account_history_content_inner;
-pub mod proposal_metadata;
-pub mod mempool_tx_content_inputs_inner;
-pub mod cardano_transaction_snapshot_message;
-pub mod script_datum_cbor;
-pub mod pool_delegators_inner;
-pub mod error;
-pub mod mithril_stake_distribution_list_message_inner;
-pub mod network_supply;
-pub mod asset_onchain_metadata_cip25;
-pub mod address_content_extended_amount_inner;
+pub use self::block_content::BlockContent;
+pub mod block_content_addresses_inner;
+pub use self::block_content_addresses_inner::BlockContentAddressesInner;
+pub mod block_content_addresses_inner_transactions_inner;
+pub use self::block_content_addresses_inner_transactions_inner::BlockContentAddressesInnerTransactionsInner;
+pub mod block_content_txs_cbor_inner;
+pub use self::block_content_txs_cbor_inner::BlockContentTxsCborInner;
+pub mod _blocks_latest_get_404_response;
+pub use self::_blocks_latest_get_404_response::BlocksLatestGet404Response;
pub mod cardano_db_beacon;
-pub mod mithril_stake_distribution_message;
-pub mod drep;
-pub mod _ipfs_pin_list__ipfs_path__get_200_response;
-pub mod address_content_extended;
-pub mod drep_metadata;
-pub mod _pools__pool_id__metadata_get_200_response;
-pub mod register_single_signature_message;
-pub mod utils_addresses_xpub;
-pub mod nutlink_tickers_ticker_inner;
-pub mod stake;
+pub use self::cardano_db_beacon::CardanoDbBeacon;
pub mod cardano_transaction_proof_message;
-pub mod block_content_addresses_inner;
-pub mod asset;
-pub mod __get_403_response;
-pub mod tx_content_utxo;
-pub mod proposals_inner;
-pub mod signer_registrations_message;
-pub mod tx_content_metadata_inner;
-pub mod tx_content_metadata_inner_json_metadata;
-pub mod nutlink_address;
-pub mod tx_content_pool_certs_inner_metadata;
-pub mod certificate_message;
+pub use self::cardano_transaction_proof_message::CardanoTransactionProofMessage;
+pub mod cardano_transaction_proof_message_certified_transactions_inner;
+pub use self::cardano_transaction_proof_message_certified_transactions_inner::CardanoTransactionProofMessageCertifiedTransactionsInner;
+pub mod cardano_transaction_snapshot_list_message_inner;
+pub use self::cardano_transaction_snapshot_list_message_inner::CardanoTransactionSnapshotListMessageInner;
+pub mod cardano_transaction_snapshot_message;
+pub use self::cardano_transaction_snapshot_message::CardanoTransactionSnapshotMessage;
pub mod certificate_list_item_message;
-pub mod tx_content_withdrawals_inner;
-pub mod scripts_inner;
-pub mod metrics_inner;
-pub mod signer_ticker_list_item_message;
-pub mod snapshot_message;
+pub use self::certificate_list_item_message::CertificateListItemMessage;
+pub mod certificate_list_item_message_metadata;
+pub use self::certificate_list_item_message_metadata::CertificateListItemMessageMetadata;
+pub mod certificate_message;
+pub use self::certificate_message::CertificateMessage;
+pub mod certificate_metadata;
+pub use self::certificate_metadata::CertificateMetadata;
+pub mod certificate_pending_message;
+pub use self::certificate_pending_message::CertificatePendingMessage;
+pub mod drep;
+pub use self::drep::Drep;
+pub mod drep_delegators_inner;
+pub use self::drep_delegators_inner::DrepDelegatorsInner;
+pub mod drep_metadata;
+pub use self::drep_metadata::DrepMetadata;
pub mod drep_updates_inner;
-pub mod proposal_votes_inner;
-pub mod cardano_transaction_proof_message_certified_transactions_inner;
-pub mod tx_content_pool_certs_inner_relays_inner;
-pub mod nutlink_address_tickers_inner;
-pub mod block_content_addresses_inner_transactions_inner;
-pub mod account_addresses_assets_inner;
-pub mod asset_addresses_inner;
+pub use self::drep_updates_inner::DrepUpdatesInner;
+pub mod drep_votes_inner;
+pub use self::drep_votes_inner::DrepVotesInner;
+pub mod dreps_inner;
+pub use self::dreps_inner::DrepsInner;
+pub mod epoch_content;
+pub use self::epoch_content::EpochContent;
+pub mod epoch_param_content;
+pub use self::epoch_param_content::EpochParamContent;
+pub mod epoch_settings_message;
+pub use self::epoch_settings_message::EpochSettingsMessage;
pub mod epoch_stake_content_inner;
-pub mod _ipfs_pin_add__ipfs_path__post_425_response;
-pub mod _ipfs_pin_remove__ipfs_path__post_200_response;
+pub use self::epoch_stake_content_inner::EpochStakeContentInner;
+pub mod epoch_stake_pool_content_inner;
+pub use self::epoch_stake_pool_content_inner::EpochStakePoolContentInner;
+pub mod error;
+pub use self::error::Error;
+pub mod genesis_content;
+pub use self::genesis_content::GenesisContent;
+pub mod __get_200_response;
+pub use self::__get_200_response::Get200Response;
+pub mod __get_400_response;
+pub use self::__get_400_response::Get400Response;
+pub mod __get_403_response;
+pub use self::__get_403_response::Get403Response;
+pub mod __get_418_response;
+pub use self::__get_418_response::Get418Response;
+pub mod __get_429_response;
+pub use self::__get_429_response::Get429Response;
+pub mod __get_500_response;
+pub use self::__get_500_response::Get500Response;
+pub mod _health_clock_get_200_response;
+pub use self::_health_clock_get_200_response::HealthClockGet200Response;
pub mod _health_get_200_response;
+pub use self::_health_get_200_response::HealthGet200Response;
+pub mod ipfs_add_200_response;
+pub use self::ipfs_add_200_response::IpfsAdd200Response;
pub mod _ipfs_pin_add__ipfs_path__post_200_response;
-pub mod account_delegation_content_inner;
-pub mod tx_metadata_labels_inner;
-pub mod epoch_content;
-pub mod tx_content_pool_certs_inner;
-pub mod asset_onchain_metadata_cip68_rft_444;
-pub mod pool_updates_inner;
-pub mod account_content;
-pub mod snapshot_download_message;
-pub mod script_cbor;
-pub mod aggregator_features_message_capabilities_cardano_transactions_prover;
-pub mod asset_history_inner;
-pub mod certificate_list_item_message_metadata;
-pub mod account_registration_content_inner;
-pub mod network_eras_inner_parameters;
-pub mod cardano_transaction_snapshot_list_message_inner;
-pub mod asset_metadata;
-pub mod _utils_txs_evaluate_utxos_post_request;
-pub mod script_json;
-pub mod account_addresses_total_received_sum_inner;
-pub mod snapshot;
-pub mod network_eras_inner_start;
-pub mod proposal_parameters_parameters;
-pub mod account_addresses_content_inner;
-pub mod _health_clock_get_200_response;
-pub mod __get_418_response;
-pub mod address_utxo_content_inner;
-pub mod asset_onchain_metadata_cip25_description;
-pub mod script_datum;
-pub mod aggregator_features_message_capabilities;
+pub use self::_ipfs_pin_add__ipfs_path__post_200_response::IpfsPinAddIpfsPathPost200Response;
+pub mod _ipfs_pin_add__ipfs_path__post_425_response;
+pub use self::_ipfs_pin_add__ipfs_path__post_425_response::IpfsPinAddIpfsPathPost425Response;
+pub mod _ipfs_pin_list_get_200_response_inner;
+pub use self::_ipfs_pin_list_get_200_response_inner::IpfsPinListGet200ResponseInner;
+pub mod _ipfs_pin_list__ipfs_path__get_200_response;
+pub use self::_ipfs_pin_list__ipfs_path__get_200_response::IpfsPinListIpfsPathGet200Response;
+pub mod _ipfs_pin_remove__ipfs_path__post_200_response;
+pub use self::_ipfs_pin_remove__ipfs_path__post_200_response::IpfsPinRemoveIpfsPathPost200Response;
+pub mod mempool_content_inner;
+pub use self::mempool_content_inner::MempoolContentInner;
+pub mod mempool_tx_content;
+pub use self::mempool_tx_content::MempoolTxContent;
+pub mod mempool_tx_content_inputs_inner;
+pub use self::mempool_tx_content_inputs_inner::MempoolTxContentInputsInner;
pub mod mempool_tx_content_outputs_inner;
+pub use self::mempool_tx_content_outputs_inner::MempoolTxContentOutputsInner;
+pub mod mempool_tx_content_redeemers_inner;
+pub use self::mempool_tx_content_redeemers_inner::MempoolTxContentRedeemersInner;
+pub mod mempool_tx_content_tx;
+pub use self::mempool_tx_content_tx::MempoolTxContentTx;
+pub mod metrics_endpoints_inner;
+pub use self::metrics_endpoints_inner::MetricsEndpointsInner;
+pub mod metrics_inner;
+pub use self::metrics_inner::MetricsInner;
+pub mod mithril_stake_distribution_list_message_inner;
+pub use self::mithril_stake_distribution_list_message_inner::MithrilStakeDistributionListMessageInner;
+pub mod mithril_stake_distribution_message;
+pub use self::mithril_stake_distribution_message::MithrilStakeDistributionMessage;
+pub mod network;
+pub use self::network::Network;
+pub mod network_eras_inner;
+pub use self::network_eras_inner::NetworkErasInner;
pub mod network_eras_inner_end;
-pub mod _blocks_latest_get_404_response;
+pub use self::network_eras_inner_end::NetworkErasInnerEnd;
+pub mod network_eras_inner_parameters;
+pub use self::network_eras_inner_parameters::NetworkErasInnerParameters;
+pub mod network_eras_inner_start;
+pub use self::network_eras_inner_start::NetworkErasInnerStart;
+pub mod network_stake;
+pub use self::network_stake::NetworkStake;
+pub mod network_supply;
+pub use self::network_supply::NetworkSupply;
+pub mod nutlink_address;
+pub use self::nutlink_address::NutlinkAddress;
+pub mod nutlink_address_ticker_inner;
+pub use self::nutlink_address_ticker_inner::NutlinkAddressTickerInner;
+pub mod nutlink_address_tickers_inner;
+pub use self::nutlink_address_tickers_inner::NutlinkAddressTickersInner;
+pub mod nutlink_tickers_ticker_inner;
+pub use self::nutlink_tickers_ticker_inner::NutlinkTickersTickerInner;
pub mod pool;
-pub mod _utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of_1_value;
-pub mod signer;
-pub mod script_redeemers_inner;
-pub mod script;
-pub mod mempool_content_inner;
+pub use self::pool::Pool;
+pub mod pool_calidus_key;
+pub use self::pool_calidus_key::PoolCalidusKey;
+pub mod pool_delegators_inner;
+pub use self::pool_delegators_inner::PoolDelegatorsInner;
pub mod pool_history_inner;
-pub mod account_reward_content_inner;
-pub mod tx_content_pool_retires_inner;
-pub mod asset_onchain_metadata_cip68_nft_222;
-pub mod genesis_content;
-pub mod _ipfs_pin_list_get_200_response_inner;
-pub mod epoch_settings_message;
-pub mod mempool_tx_content_tx;
+pub use self::pool_history_inner::PoolHistoryInner;
+pub mod pool_list_extended_inner;
+pub use self::pool_list_extended_inner::PoolListExtendedInner;
+pub mod pool_list_extended_inner_metadata;
+pub use self::pool_list_extended_inner_metadata::PoolListExtendedInnerMetadata;
+pub mod pool_list_retire_inner;
+pub use self::pool_list_retire_inner::PoolListRetireInner;
+pub mod pool_metadata;
+pub use self::pool_metadata::PoolMetadata;
+pub mod pool_updates_inner;
+pub use self::pool_updates_inner::PoolUpdatesInner;
+pub mod pool_votes_inner;
+pub use self::pool_votes_inner::PoolVotesInner;
+pub mod _pools__pool_id__metadata_get_200_response;
+pub use self::_pools__pool_id__metadata_get_200_response::PoolsPoolIdMetadataGet200Response;
+pub mod proposal;
+pub use self::proposal::Proposal;
+pub mod proposal_metadata;
+pub use self::proposal_metadata::ProposalMetadata;
+pub mod proposal_metadata_v2;
+pub use self::proposal_metadata_v2::ProposalMetadataV2;
+pub mod proposal_metadata_v2_error;
+pub use self::proposal_metadata_v2_error::ProposalMetadataV2Error;
pub mod proposal_parameters;
-pub mod __get_500_response;
+pub use self::proposal_parameters::ProposalParameters;
+pub mod proposal_parameters_parameters;
+pub use self::proposal_parameters_parameters::ProposalParametersParameters;
+pub mod proposal_votes_inner;
+pub use self::proposal_votes_inner::ProposalVotesInner;
+pub mod proposal_withdrawals_inner;
+pub use self::proposal_withdrawals_inner::ProposalWithdrawalsInner;
+pub mod proposals_inner;
+pub use self::proposals_inner::ProposalsInner;
+pub mod protocol_message;
+pub use self::protocol_message::ProtocolMessage;
+pub mod protocol_message_parts;
+pub use self::protocol_message_parts::ProtocolMessageParts;
+pub mod protocol_parameters;
+pub use self::protocol_parameters::ProtocolParameters;
+pub mod register_signer_message;
+pub use self::register_signer_message::RegisterSignerMessage;
+pub mod register_single_signature_message;
+pub use self::register_single_signature_message::RegisterSingleSignatureMessage;
+pub mod script;
+pub use self::script::Script;
+pub mod script_cbor;
+pub use self::script_cbor::ScriptCbor;
+pub mod script_datum;
+pub use self::script_datum::ScriptDatum;
+pub mod script_datum_cbor;
+pub use self::script_datum_cbor::ScriptDatumCbor;
+pub mod script_json;
+pub use self::script_json::ScriptJson;
+pub mod script_redeemers_inner;
+pub use self::script_redeemers_inner::ScriptRedeemersInner;
+pub mod scripts_inner;
+pub use self::scripts_inner::ScriptsInner;
+pub mod signer;
+pub use self::signer::Signer;
+pub mod signer_registrations_list_item_message;
+pub use self::signer_registrations_list_item_message::SignerRegistrationsListItemMessage;
+pub mod signer_registrations_message;
+pub use self::signer_registrations_message::SignerRegistrationsMessage;
+pub mod signer_ticker_list_item_message;
+pub use self::signer_ticker_list_item_message::SignerTickerListItemMessage;
+pub mod signer_with_stake;
+pub use self::signer_with_stake::SignerWithStake;
+pub mod signers_tickers_message;
+pub use self::signers_tickers_message::SignersTickersMessage;
+pub mod snapshot;
+pub use self::snapshot::Snapshot;
+pub mod snapshot_download_message;
+pub use self::snapshot_download_message::SnapshotDownloadMessage;
+pub mod snapshot_message;
+pub use self::snapshot_message::SnapshotMessage;
+pub mod stake;
+pub use self::stake::Stake;
pub mod stake_distribution_party;
-pub mod tx_metadata_label_cbor_inner;
-pub mod address_content_total;
-pub mod aggregator_features_message;
-pub mod asset_policy_inner;
-pub mod tx_content_redeemers_inner;
+pub use self::stake_distribution_party::StakeDistributionParty;
pub mod tx_content;
-pub mod asset_onchain_metadata_cip68_ft_333;
-pub mod register_signer_message;
-pub mod drep_delegators_inner;
-pub mod account_addresses_total;
+pub use self::tx_content::TxContent;
+pub mod tx_content_cbor;
+pub use self::tx_content_cbor::TxContentCbor;
+pub mod tx_content_delegations_inner;
+pub use self::tx_content_delegations_inner::TxContentDelegationsInner;
+pub mod tx_content_metadata_cbor_inner;
+pub use self::tx_content_metadata_cbor_inner::TxContentMetadataCborInner;
+pub mod tx_content_metadata_inner;
+pub use self::tx_content_metadata_inner::TxContentMetadataInner;
+pub mod tx_content_metadata_inner_json_metadata;
+pub use self::tx_content_metadata_inner_json_metadata::TxContentMetadataInnerJsonMetadata;
pub mod tx_content_mirs_inner;
-pub mod assets_inner;
-pub mod epoch_param_content;
-pub mod proposal_withdrawals_inner;
-pub mod network;
-pub mod certificate_metadata;
-pub mod __get_429_response;
-pub mod epoch_stake_pool_content_inner;
-pub mod _utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner;
-pub mod tx_content_utxo_inputs_inner;
-pub mod account_withdrawal_content_inner;
-pub mod _utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of_1;
+pub use self::tx_content_mirs_inner::TxContentMirsInner;
+pub mod tx_content_output_amount_inner;
+pub use self::tx_content_output_amount_inner::TxContentOutputAmountInner;
+pub mod tx_content_pool_certs_inner;
+pub use self::tx_content_pool_certs_inner::TxContentPoolCertsInner;
+pub mod tx_content_pool_certs_inner_metadata;
+pub use self::tx_content_pool_certs_inner_metadata::TxContentPoolCertsInnerMetadata;
+pub mod tx_content_pool_certs_inner_relays_inner;
+pub use self::tx_content_pool_certs_inner_relays_inner::TxContentPoolCertsInnerRelaysInner;
+pub mod tx_content_pool_retires_inner;
+pub use self::tx_content_pool_retires_inner::TxContentPoolRetiresInner;
+pub mod tx_content_redeemers_inner;
+pub use self::tx_content_redeemers_inner::TxContentRedeemersInner;
+pub mod tx_content_required_signers_inner;
+pub use self::tx_content_required_signers_inner::TxContentRequiredSignersInner;
pub mod tx_content_stake_addr_inner;
-pub mod mempool_tx_content_redeemers_inner;
-pub mod _utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of;
+pub use self::tx_content_stake_addr_inner::TxContentStakeAddrInner;
+pub mod tx_content_utxo;
+pub use self::tx_content_utxo::TxContentUtxo;
+pub mod tx_content_utxo_inputs_inner;
+pub use self::tx_content_utxo_inputs_inner::TxContentUtxoInputsInner;
pub mod tx_content_utxo_outputs_inner;
-pub mod tx_content_required_signers_inner;
-pub mod nutlink_address_ticker_inner;
-pub mod tx_content_metadata_cbor_inner;
-pub mod __get_200_response;
-pub mod asset_onchain_metadata_cip25_image;
-pub mod tx_content_output_amount_inner;
+pub use self::tx_content_utxo_outputs_inner::TxContentUtxoOutputsInner;
+pub mod tx_content_withdrawals_inner;
+pub use self::tx_content_withdrawals_inner::TxContentWithdrawalsInner;
+pub mod tx_metadata_label_cbor_inner;
+pub use self::tx_metadata_label_cbor_inner::TxMetadataLabelCborInner;
+pub mod tx_metadata_label_json_inner;
+pub use self::tx_metadata_label_json_inner::TxMetadataLabelJsonInner;
+pub mod tx_metadata_labels_inner;
+pub use self::tx_metadata_labels_inner::TxMetadataLabelsInner;
+pub mod _tx_submit_post_425_response;
+pub use self::_tx_submit_post_425_response::TxSubmitPost425Response;
+pub mod utils_addresses_xpub;
+pub use self::utils_addresses_xpub::UtilsAddressesXpub;
+pub mod _utils_txs_evaluate_utxos_post_request;
+pub use self::_utils_txs_evaluate_utxos_post_request::UtilsTxsEvaluateUtxosPostRequest;
+pub mod _utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner;
+pub use self::_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner::UtilsTxsEvaluateUtxosPostRequestAdditionalUtxoSetInnerInner;
+pub mod _utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of;
+pub use self::_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of::UtilsTxsEvaluateUtxosPostRequestAdditionalUtxoSetInnerInnerAnyOf;
+pub mod _utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of_1;
+pub use self::_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of_1::UtilsTxsEvaluateUtxosPostRequestAdditionalUtxoSetInnerInnerAnyOf1;
+pub mod _utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of_1_value;
+pub use self::_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of_1_value::UtilsTxsEvaluateUtxosPostRequestAdditionalUtxoSetInnerInnerAnyOf1Value;
diff --git a/rust/src/models/network.rs b/rust/src/models/network.rs
index 37ac9e14..291d4b8e 100644
--- a/rust/src/models/network.rs
+++ b/rust/src/models/network.rs
@@ -1,30 +1,30 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
-use super::{network_stake::NetworkStake, network_supply::NetworkSupply};
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct Network {
#[serde(rename = "supply")]
- pub supply: Box,
+ pub supply: Box,
#[serde(rename = "stake")]
- pub stake: Box,
+ pub stake: Box,
}
impl Network {
- pub fn new(supply: NetworkSupply, stake: NetworkStake) -> Network {
+ pub fn new(supply: models::NetworkSupply, stake: models::NetworkStake) -> Network {
Network {
supply: Box::new(supply),
stake: Box::new(stake),
}
}
}
+
diff --git a/rust/src/models/network_eras_inner.rs b/rust/src/models/network_eras_inner.rs
index f70e4eac..40efb056 100644
--- a/rust/src/models/network_eras_inner.rs
+++ b/rust/src/models/network_eras_inner.rs
@@ -1,37 +1,28 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
-use super::{
- network_eras_inner_end::NetworkErasInnerEnd,
- network_eras_inner_parameters::NetworkErasInnerParameters,
- network_eras_inner_start::NetworkErasInnerStart,
-};
use crate::models;
use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct NetworkErasInner {
#[serde(rename = "start")]
- pub start: Box,
+ pub start: Box,
#[serde(rename = "end")]
- pub end: Box,
+ pub end: Box,
#[serde(rename = "parameters")]
- pub parameters: Box,
+ pub parameters: Box,
}
impl NetworkErasInner {
- pub fn new(
- start: NetworkErasInnerStart,
- end: NetworkErasInnerEnd,
- parameters: NetworkErasInnerParameters,
- ) -> NetworkErasInner {
+ pub fn new(start: models::NetworkErasInnerStart, end: models::NetworkErasInnerEnd, parameters: models::NetworkErasInnerParameters) -> NetworkErasInner {
NetworkErasInner {
start: Box::new(start),
end: Box::new(end),
@@ -39,3 +30,4 @@ impl NetworkErasInner {
}
}
}
+
diff --git a/rust/src/models/network_eras_inner_end.rs b/rust/src/models/network_eras_inner_end.rs
index 2b71bd04..04e98bc3 100644
--- a/rust/src/models/network_eras_inner_end.rs
+++ b/rust/src/models/network_eras_inner_end.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -16,7 +16,7 @@ use serde::{Deserialize, Serialize};
pub struct NetworkErasInnerEnd {
/// Time in seconds relative to the start time of the network
#[serde(rename = "time")]
- pub time: f64,
+ pub time: i32,
/// Absolute slot number
#[serde(rename = "slot")]
pub slot: i32,
@@ -27,7 +27,7 @@ pub struct NetworkErasInnerEnd {
impl NetworkErasInnerEnd {
/// End of the blockchain era, relative to the start of the network
- pub fn new(time: f64, slot: i32, epoch: i32) -> NetworkErasInnerEnd {
+ pub fn new(time: i32, slot: i32, epoch: i32) -> NetworkErasInnerEnd {
NetworkErasInnerEnd {
time,
slot,
diff --git a/rust/src/models/network_eras_inner_parameters.rs b/rust/src/models/network_eras_inner_parameters.rs
index b60c12f0..6f257938 100644
--- a/rust/src/models/network_eras_inner_parameters.rs
+++ b/rust/src/models/network_eras_inner_parameters.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -19,7 +19,7 @@ pub struct NetworkErasInnerParameters {
pub epoch_length: i32,
/// Slot length in seconds
#[serde(rename = "slot_length")]
- pub slot_length: f64,
+ pub slot_length: i32,
/// Zone in which it is guaranteed that no hard fork can take place
#[serde(rename = "safe_zone")]
pub safe_zone: i32,
@@ -27,7 +27,7 @@ pub struct NetworkErasInnerParameters {
impl NetworkErasInnerParameters {
/// Era parameters
- pub fn new(epoch_length: i32, slot_length: f64, safe_zone: i32) -> NetworkErasInnerParameters {
+ pub fn new(epoch_length: i32, slot_length: i32, safe_zone: i32) -> NetworkErasInnerParameters {
NetworkErasInnerParameters {
epoch_length,
slot_length,
diff --git a/rust/src/models/network_eras_inner_start.rs b/rust/src/models/network_eras_inner_start.rs
index 96d24129..034ffb08 100644
--- a/rust/src/models/network_eras_inner_start.rs
+++ b/rust/src/models/network_eras_inner_start.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -16,7 +16,7 @@ use serde::{Deserialize, Serialize};
pub struct NetworkErasInnerStart {
/// Time in seconds relative to the start time of the network
#[serde(rename = "time")]
- pub time: f64,
+ pub time: i32,
/// Absolute slot number
#[serde(rename = "slot")]
pub slot: i32,
@@ -27,7 +27,7 @@ pub struct NetworkErasInnerStart {
impl NetworkErasInnerStart {
/// Start of the blockchain era, relative to the start of the network
- pub fn new(time: f64, slot: i32, epoch: i32) -> NetworkErasInnerStart {
+ pub fn new(time: i32, slot: i32, epoch: i32) -> NetworkErasInnerStart {
NetworkErasInnerStart {
time,
slot,
diff --git a/rust/src/models/network_stake.rs b/rust/src/models/network_stake.rs
index 5d19b0e2..e2349856 100644
--- a/rust/src/models/network_stake.rs
+++ b/rust/src/models/network_stake.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/network_supply.rs b/rust/src/models/network_supply.rs
index 1c773bd3..b4a5cc1d 100644
--- a/rust/src/models/network_supply.rs
+++ b/rust/src/models/network_supply.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/nutlink_address.rs b/rust/src/models/nutlink_address.rs
index 2e29ce63..6b690856 100644
--- a/rust/src/models/nutlink_address.rs
+++ b/rust/src/models/nutlink_address.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/nutlink_address_ticker_inner.rs b/rust/src/models/nutlink_address_ticker_inner.rs
index ccc302f0..42cd0ac3 100644
--- a/rust/src/models/nutlink_address_ticker_inner.rs
+++ b/rust/src/models/nutlink_address_ticker_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/nutlink_address_tickers_inner.rs b/rust/src/models/nutlink_address_tickers_inner.rs
index 6a3a061c..d606b26a 100644
--- a/rust/src/models/nutlink_address_tickers_inner.rs
+++ b/rust/src/models/nutlink_address_tickers_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/nutlink_tickers_ticker_inner.rs b/rust/src/models/nutlink_tickers_ticker_inner.rs
index 144b14df..1247f0db 100644
--- a/rust/src/models/nutlink_tickers_ticker_inner.rs
+++ b/rust/src/models/nutlink_tickers_ticker_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/pool.rs b/rust/src/models/pool.rs
index 00cb9965..7cb68c1c 100644
--- a/rust/src/models/pool.rs
+++ b/rust/src/models/pool.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -61,10 +61,12 @@ pub struct Pool {
pub registration: Vec,
#[serde(rename = "retirement")]
pub retirement: Vec,
+ #[serde(rename = "calidus_key", deserialize_with = "Option::deserialize")]
+ pub calidus_key: Option>,
}
impl Pool {
- pub fn new(pool_id: String, hex: String, vrf_key: String, blocks_minted: i32, blocks_epoch: i32, live_stake: String, live_size: f64, live_saturation: f64, live_delegators: f64, active_stake: String, active_size: f64, declared_pledge: String, live_pledge: String, margin_cost: f64, fixed_cost: String, reward_account: String, owners: Vec, registration: Vec, retirement: Vec) -> Pool {
+ pub fn new(pool_id: String, hex: String, vrf_key: String, blocks_minted: i32, blocks_epoch: i32, live_stake: String, live_size: f64, live_saturation: f64, live_delegators: f64, active_stake: String, active_size: f64, declared_pledge: String, live_pledge: String, margin_cost: f64, fixed_cost: String, reward_account: String, owners: Vec, registration: Vec, retirement: Vec, calidus_key: Option) -> Pool {
Pool {
pool_id,
hex,
@@ -85,6 +87,7 @@ impl Pool {
owners,
registration,
retirement,
+ calidus_key: if let Some(x) = calidus_key {Some(Box::new(x))} else {None},
}
}
}
diff --git a/rust/src/models/pool_calidus_key.rs b/rust/src/models/pool_calidus_key.rs
new file mode 100644
index 00000000..dd70bcae
--- /dev/null
+++ b/rust/src/models/pool_calidus_key.rs
@@ -0,0 +1,54 @@
+/*
+ * Blockfrost.io ~ API Documentation
+ *
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ *
+ * The version of the OpenAPI document: 0.1.83
+ * Contact: contact@blockfrost.io
+ * Generated by: https://openapi-generator.tech
+ */
+
+use crate::models;
+use serde::{Deserialize, Serialize};
+
+/// PoolCalidusKey : Last valid Calidus key for the pool
+#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PoolCalidusKey {
+ /// A Bech32-encoded identifier derived from the calidus public key
+ #[serde(rename = "id")]
+ pub id: String,
+ /// The raw hexadecimal-encoded calidus public key used for verification purposes
+ #[serde(rename = "pub_key")]
+ pub pub_key: String,
+ /// A unique number used once to prevent replay attacks and ensure the uniqueness of the key registration
+ #[serde(rename = "nonce")]
+ pub nonce: i32,
+ /// The transaction hash that submitted the Calidus key registration
+ #[serde(rename = "tx_hash")]
+ pub tx_hash: String,
+ /// The block height at which this key registration was recorded
+ #[serde(rename = "block_height")]
+ pub block_height: i32,
+ /// Block time of the key registration
+ #[serde(rename = "block_time")]
+ pub block_time: i32,
+ /// Epoch number of the key registration
+ #[serde(rename = "epoch")]
+ pub epoch: i32,
+}
+
+impl PoolCalidusKey {
+ /// Last valid Calidus key for the pool
+ pub fn new(id: String, pub_key: String, nonce: i32, tx_hash: String, block_height: i32, block_time: i32, epoch: i32) -> PoolCalidusKey {
+ PoolCalidusKey {
+ id,
+ pub_key,
+ nonce,
+ tx_hash,
+ block_height,
+ block_time,
+ epoch,
+ }
+ }
+}
+
diff --git a/rust/src/models/pool_delegators_inner.rs b/rust/src/models/pool_delegators_inner.rs
index 0a9f4ab6..65b99511 100644
--- a/rust/src/models/pool_delegators_inner.rs
+++ b/rust/src/models/pool_delegators_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/pool_history_inner.rs b/rust/src/models/pool_history_inner.rs
index f8cb2f3e..f869bb5c 100644
--- a/rust/src/models/pool_history_inner.rs
+++ b/rust/src/models/pool_history_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/pool_list_extended_inner.rs b/rust/src/models/pool_list_extended_inner.rs
index bdbf6394..9c8f3f95 100644
--- a/rust/src/models/pool_list_extended_inner.rs
+++ b/rust/src/models/pool_list_extended_inner.rs
@@ -1,16 +1,15 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
use crate::models;
use serde::{Deserialize, Serialize};
-use serde_json::Value;
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct PoolListExtendedInner {
@@ -40,22 +39,12 @@ pub struct PoolListExtendedInner {
/// Fixed tax cost of the stake pool
#[serde(rename = "fixed_cost")]
pub fixed_cost: String,
- #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")]
- pub metadata: Option>,
+ #[serde(rename = "metadata", deserialize_with = "Option::deserialize")]
+ pub metadata: Option>,
}
impl PoolListExtendedInner {
- pub fn new(
- pool_id: String,
- hex: String,
- active_stake: String,
- live_stake: String,
- live_saturation: f64,
- blocks_minted: i32,
- declared_pledge: String,
- margin_cost: f64,
- fixed_cost: String,
- ) -> PoolListExtendedInner {
+ pub fn new(pool_id: String, hex: String, active_stake: String, live_stake: String, live_saturation: f64, blocks_minted: i32, declared_pledge: String, margin_cost: f64, fixed_cost: String, metadata: Option) -> PoolListExtendedInner {
PoolListExtendedInner {
pool_id,
hex,
@@ -66,7 +55,8 @@ impl PoolListExtendedInner {
declared_pledge,
margin_cost,
fixed_cost,
- metadata: None,
+ metadata: if let Some(x) = metadata {Some(Box::new(x))} else {None},
}
}
}
+
diff --git a/rust/src/models/pool_list_extended_inner_metadata.rs b/rust/src/models/pool_list_extended_inner_metadata.rs
index 54f91d86..07ac88c9 100644
--- a/rust/src/models/pool_list_extended_inner_metadata.rs
+++ b/rust/src/models/pool_list_extended_inner_metadata.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -19,6 +19,8 @@ pub struct PoolListExtendedInnerMetadata {
/// Hash of the metadata file
#[serde(rename = "hash", deserialize_with = "Option::deserialize")]
pub hash: Option,
+ #[serde(rename = "error", skip_serializing_if = "Option::is_none")]
+ pub error: Option>,
/// Ticker of the stake pool
#[serde(rename = "ticker", deserialize_with = "Option::deserialize")]
pub ticker: Option,
@@ -38,6 +40,7 @@ impl PoolListExtendedInnerMetadata {
PoolListExtendedInnerMetadata {
url,
hash,
+ error: None,
ticker,
name,
description,
diff --git a/rust/src/models/pool_list_retire_inner.rs b/rust/src/models/pool_list_retire_inner.rs
index 243a5d2f..ff798a3b 100644
--- a/rust/src/models/pool_list_retire_inner.rs
+++ b/rust/src/models/pool_list_retire_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/pool_metadata.rs b/rust/src/models/pool_metadata.rs
index 8e59e316..5e03d665 100644
--- a/rust/src/models/pool_metadata.rs
+++ b/rust/src/models/pool_metadata.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -25,6 +25,8 @@ pub struct PoolMetadata {
/// Hash of the metadata file
#[serde(rename = "hash", deserialize_with = "Option::deserialize")]
pub hash: Option,
+ #[serde(rename = "error", skip_serializing_if = "Option::is_none")]
+ pub error: Option>,
/// Ticker of the stake pool
#[serde(rename = "ticker", deserialize_with = "Option::deserialize")]
pub ticker: Option,
@@ -46,6 +48,7 @@ impl PoolMetadata {
hex,
url,
hash,
+ error: None,
ticker,
name,
description,
diff --git a/rust/src/models/pool_updates_inner.rs b/rust/src/models/pool_updates_inner.rs
index 0866e804..57e5af0e 100644
--- a/rust/src/models/pool_updates_inner.rs
+++ b/rust/src/models/pool_updates_inner.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
diff --git a/rust/src/models/pool_votes_inner.rs b/rust/src/models/pool_votes_inner.rs
new file mode 100644
index 00000000..d542d13c
--- /dev/null
+++ b/rust/src/models/pool_votes_inner.rs
@@ -0,0 +1,52 @@
+/*
+ * Blockfrost.io ~ API Documentation
+ *
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ *
+ * The version of the OpenAPI document: 0.1.83
+ * Contact: contact@blockfrost.io
+ * Generated by: https://openapi-generator.tech
+ */
+
+use crate::models;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PoolVotesInner {
+ /// Hash of the proposal transaction.
+ #[serde(rename = "tx_hash")]
+ pub tx_hash: String,
+ /// Index of the certificate within the proposal transaction.
+ #[serde(rename = "cert_index")]
+ pub cert_index: i32,
+ /// The Vote. Can be one of yes, no, abstain.
+ #[serde(rename = "vote")]
+ pub vote: Vote,
+}
+
+impl PoolVotesInner {
+ pub fn new(tx_hash: String, cert_index: i32, vote: Vote) -> PoolVotesInner {
+ PoolVotesInner {
+ tx_hash,
+ cert_index,
+ vote,
+ }
+ }
+}
+/// The Vote. Can be one of yes, no, abstain.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
+pub enum Vote {
+ #[serde(rename = "yes")]
+ Yes,
+ #[serde(rename = "no")]
+ No,
+ #[serde(rename = "abstain")]
+ Abstain,
+}
+
+impl Default for Vote {
+ fn default() -> Vote {
+ Self::Yes
+ }
+}
+
diff --git a/rust/src/models/proposal.rs b/rust/src/models/proposal.rs
index b23c67ba..95f9ad5b 100644
--- a/rust/src/models/proposal.rs
+++ b/rust/src/models/proposal.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
| Milkomeda mainnet | https://milkomeda-mainnet.blockfrost.io/api/v0 |
| Milkomeda testnet | https://milkomeda-testnet.blockfrost.io/api/v0 |
## Milkomeda For more information about how to use Milkomeda as well as the list of available endpoints, see the Milkomeda section.
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
+ * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`. | Network | Endpoint |
| Cardano mainnet | https://cardano-mainnet.blockfrost.io/api/v0 |
| Cardano preprod | https://cardano-preprod.blockfrost.io/api/v0 |
| Cardano preview | https://cardano-preview.blockfrost.io/api/v0 |
| InterPlanetary File System | https://ipfs.blockfrost.io/api/v0 |
## Concepts * All endpoints return either a JSON object or an array. * Data is returned in *ascending* (oldest first, newest last) order, if not stated otherwise. * You might use the `?order=desc` query parameter to reverse this order. * By default, we return 100 results at a time. You have to use `?page=2` to list through the results. * All time and timestamp related fields (except `server_time`) are in seconds of UNIX time. * All amounts are returned in Lovelaces, where 1 ADA = 1 000 000 Lovelaces. * Addresses, accounts and pool IDs are in Bech32 format. * All values are case sensitive. * All hex encoded values are lower case. * Examples are not based on real data. Any resemblance to actual events is purely coincidental. * We allow to upload files up to 100MB of size to IPFS. This might increase in the future. * Only pinned IPFS files are counted towards the IPFS quota. * Non-pinned IPFS files are subject to regular garbage collection and will be removed unless pinned. * We allow maximum of 100 queued pins per IPFS user. ## Errors ### HTTP Status codes The following are HTTP status code your application might receive when reaching Blockfrost endpoints and it should handle all of these cases. * HTTP `400` return code is used when the request is not valid. * HTTP `402` return code is used when the projects exceed their daily request limit. * HTTP `403` return code is used when the request is not authenticated. * HTTP `404` return code is used when the resource doesn't exist. * HTTP `418` return code is used when the user has been auto-banned for flooding too much after previously receiving error code `402` or `429`. * HTTP `425` return code is used in Cardano networks, when the user has submitted a transaction when the mempool is already full, not accepting new txs straight away. * HTTP `425` return code is used in IPFS network, when the user has submitted a pin when the pin queue is already full, not accepting new pins straight away. * HTTP `429` return code is used when the user has sent too many requests in a given amount of time and therefore has been rate-limited. * HTTP `500` return code is used when our endpoints are having a problem. ### Error codes An internal error code number is used for better indication of the error in question. It is passed using the following payload. ```json { \"status_code\": 403, \"error\": \"Forbidden\", \"message\": \"Invalid project token.\" } ``` ## Limits There are two types of limits we are enforcing: The first depends on your plan and is the number of request we allow per day. We defined the day from midnight to midnight of UTC time. The second is rate limiting. We limit an end user, distinguished by IP address, to 10 requests per second. On top of that, we allow each user to send burst of 500 requests, which cools off at rate of 10 requests per second. In essence, a user is allowed to make another whole burst after (currently) 500/10 = 50 seconds. E.g. if a user attempts to make a call 3 seconds after whole burst, 30 requests will be processed. We believe this should be sufficient for most of the use cases. If it is not and you have a specific use case, please get in touch with us, and we will make sure to take it into account as much as we can. ## SDKs We support a number of SDKs that will help you in developing your application on top of Blockfrost.
*
- * The version of the OpenAPI document: 0.1.76
+ * The version of the OpenAPI document: 0.1.83
* Contact: contact@blockfrost.io
* Generated by: https://openapi-generator.tech
*/
@@ -13,6 +13,9 @@ use serde::{Deserialize, Serialize};
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct Proposal {
+ /// Governance Action Identifier (CIP-0129)
+ #[serde(rename = "id")]
+ pub id: String,
/// Hash of the proposal transaction.
#[serde(rename = "tx_hash")]
pub tx_hash: String,
@@ -37,7 +40,7 @@ pub struct Proposal {
/// The epoch at which the proposal was enacted. Null if the proposal has not been enacted.
#[serde(rename = "enacted_epoch", deserialize_with = "Option::deserialize")]
pub enacted_epoch: Option,
- /// The epoch at which the proposal was dropped. A proposal is dropped if it expires, is enacted, or if any of its dependencies expire.
+ /// The epoch at which the proposal was dropped. A proposal is dropped if it expires or if any of its dependencies expire.
#[serde(rename = "dropped_epoch", deserialize_with = "Option::deserialize")]
pub dropped_epoch: Option,
/// The epoch at which the proposal expired. Null if the proposal has not expired.
@@ -49,8 +52,9 @@ pub struct Proposal {
}
impl Proposal {
- pub fn new(tx_hash: String, cert_index: i32, governance_type: GovernanceType, governance_description: Option>, deposit: String, return_address: String, ratified_epoch: Option, enacted_epoch: Option, dropped_epoch: Option, expired_epoch: Option, expiration: i32) -> Proposal {
+ pub fn new(id: String, tx_hash: String, cert_index: i32, governance_type: GovernanceType, governance_description: Option>, deposit: String, return_address: String, ratified_epoch: Option, enacted_epoch: Option, dropped_epoch: Option, expired_epoch: Option, expiration: i32) -> Proposal {
Proposal {
+ id,
tx_hash,
cert_index,
governance_type,
diff --git a/rust/src/models/proposal_metadata.rs b/rust/src/models/proposal_metadata.rs
index 2807d798..b00648a8 100644
--- a/rust/src/models/proposal_metadata.rs
+++ b/rust/src/models/proposal_metadata.rs
@@ -1,9 +1,9 @@
/*
* Blockfrost.io ~ API Documentation
*
- * Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. ## Tokens After signing up on https://blockfrost.io, a `project_id` token is automatically generated for each project. HTTP header of your request MUST include this `project_id` in order to authenticate against Blockfrost servers. ## Available networks At the moment, you can use the following networks. Please, note that each network has its own `project_id`.