diff --git a/flake.lock b/flake.lock new file mode 100644 index 00000000..74b9ff0f --- /dev/null +++ b/flake.lock @@ -0,0 +1,61 @@ +{ + "nodes": { + "flake-utils": { + "inputs": { + "systems": "systems" + }, + "locked": { + "lastModified": 1731533236, + "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "nixpkgs": { + "locked": { + "lastModified": 1772082373, + "narHash": "sha256-wySf8a6hvuqgFdwvvzPPTARBCMLDz7WFAufGkllD1M4=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "26eaeac4e409d7b5a6bf6f90a2a2dc223c78d915", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixpkgs-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "root": { + "inputs": { + "flake-utils": "flake-utils", + "nixpkgs": "nixpkgs" + } + }, + "systems": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix new file mode 100644 index 00000000..73b549c8 --- /dev/null +++ b/flake.nix @@ -0,0 +1,27 @@ +{ + description = "Blockfrost OpenAPI specification"; + + inputs = { + nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable"; + flake-utils.url = "github:numtide/flake-utils"; + }; + + outputs = { self, nixpkgs, flake-utils }: + flake-utils.lib.eachDefaultSystem (system: + let + pkgs = import nixpkgs { inherit system; }; + in + { + devShells.default = pkgs.mkShell { + buildInputs = [ + pkgs.nodejs_20 + pkgs.openjdk21 + (pkgs.yarn.override { nodejs = pkgs.nodejs_20; }) + ]; + + shellHook = '' + export PATH="$PATH:$(pwd)/node_modules/.bin" + ''; + }; + }); +} diff --git a/package.json b/package.json index d5ec934f..29c7db8f 100644 --- a/package.json +++ b/package.json @@ -17,7 +17,7 @@ "lint": "scalar validate ./src/definitions.yaml", "bundle": "yarn redocly bundle -o ./blockfrost-openapi.yaml src/definitions.yaml && yarn openapi-merge-cli && yarn redocly bundle -o ./openapi.json ./openapi.yaml && yarn copy-spec", "generate-types": "yarn openapi-typescript ./openapi.yaml --output ./src/generated-types.ts", - "generate-types:rust": "openapi-generator-cli generate -i openapi.yaml -g rust -o ./rust --global-property models,modelDocs=false,apis=false,apiDocs=false,supportingFiles", + "generate-types:rust": "openapi-generator-cli generate -i openapi.yaml -g rust -o ./rust -c rust/openapi-generator.json --global-property models,modelDocs=false,apis=false,apiDocs=false,supportingFiles && node rust/fix-cargo.js", "generate-json-schema": "node lib/scripts/generate-json-schema.js > json-schema.json", "sync-version": "ts-node ./src/scripts/sync-version.ts", "test": "vitest", diff --git a/rust/Cargo.lock b/rust/Cargo.lock index e552f620..efde3f19 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -43,7 +43,7 @@ checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3" [[package]] name = "blockfrost-openapi" -version = "0.1.83" +version = "0.1.85" dependencies = [ "reqwest", "serde", diff --git a/rust/Cargo.toml b/rust/Cargo.toml index 22acbb36..6c718af0 100644 --- a/rust/Cargo.toml +++ b/rust/Cargo.toml @@ -1,8 +1,8 @@ [package] name = "blockfrost-openapi" -version = "0.1.83" +version = "0.1.85" authors = ["contact@blockfrost.io"] -description = "Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem." +description = "Blockfrost OpenAPI types for Cardano" license = "MIT" edition = "2021" diff --git a/rust/README.md b/rust/README.md index e5172d2e..0aa03092 100644 --- a/rust/README.md +++ b/rust/README.md @@ -1,4 +1,4 @@ -# Rust API client for openapi +# Rust API client for blockfrost-openapi Blockfrost is an API as a service that allows users to interact with the Cardano blockchain and parts of its ecosystem. @@ -215,17 +215,17 @@ For more information, please visit [https://blockfrost.io](https://blockfrost.io This API client was generated by the [OpenAPI Generator](https://openapi-generator.tech) project. By using the [openapi-spec](https://openapis.org) from a remote server, you can easily generate an API client. -- API version: 0.1.83 -- Package version: 0.1.83 +- API version: 0.1.85 +- Package version: 0.1.85 - Generator version: 7.12.0 - Build package: `org.openapitools.codegen.languages.RustClientCodegen` ## Installation -Put the package under your project folder in a directory named `openapi` and add the following to `Cargo.toml` under `[dependencies]`: +Put the package under your project folder in a directory named `blockfrost-openapi` and add the following to `Cargo.toml` under `[dependencies]`: ``` -openapi = { path = "./openapi" } +blockfrost-openapi = { path = "./blockfrost-openapi" } ``` ## Documentation for API Endpoints @@ -293,6 +293,7 @@ Class | Method | HTTP request | Description - [Drep](docs/Drep.md) - [DrepDelegatorsInner](docs/DrepDelegatorsInner.md) - [DrepMetadata](docs/DrepMetadata.md) + - [DrepMetadataError](docs/DrepMetadataError.md) - [DrepUpdatesInner](docs/DrepUpdatesInner.md) - [DrepVotesInner](docs/DrepVotesInner.md) - [DrepsInner](docs/DrepsInner.md) @@ -352,7 +353,6 @@ Class | Method | HTTP request | Description - [Proposal](docs/Proposal.md) - [ProposalMetadata](docs/ProposalMetadata.md) - [ProposalMetadataV2](docs/ProposalMetadataV2.md) - - [ProposalMetadataV2Error](docs/ProposalMetadataV2Error.md) - [ProposalParameters](docs/ProposalParameters.md) - [ProposalParametersParameters](docs/ProposalParametersParameters.md) - [ProposalVotesInner](docs/ProposalVotesInner.md) @@ -419,3 +419,5 @@ cargo doc --open ``` ## Author + + diff --git a/rust/fix-cargo.js b/rust/fix-cargo.js new file mode 100644 index 00000000..7b993670 --- /dev/null +++ b/rust/fix-cargo.js @@ -0,0 +1,25 @@ +const fs = require("fs"); +const path = require("path"); + +const config = JSON.parse( + fs.readFileSync(path.join(__dirname, "openapi-generator.json"), "utf-8") +); + +const cargoPath = path.join(__dirname, "Cargo.toml"); +let cargo = fs.readFileSync(cargoPath, "utf-8"); + +if (config.packageDescription) { + cargo = cargo.replace( + /^description = ".*"$/m, + `description = "${config.packageDescription}"` + ); +} + +if (config.packageName) { + cargo = cargo.replace( + /^name = ".*"$/m, + `name = "${config.packageName}"` + ); +} + +fs.writeFileSync(cargoPath, cargo); diff --git a/rust/openapi-generator.json b/rust/openapi-generator.json new file mode 100644 index 00000000..f57af50f --- /dev/null +++ b/rust/openapi-generator.json @@ -0,0 +1,4 @@ +{ + "packageName": "blockfrost-openapi", + "packageDescription": "Blockfrost OpenAPI types for Cardano" +} diff --git a/rust/src/apis/configuration.rs b/rust/src/apis/configuration.rs index 9df1ebb8..a95be8d3 100644 --- a/rust/src/apis/configuration.rs +++ b/rust/src/apis/configuration.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ @@ -40,7 +40,7 @@ impl Default for Configuration { fn default() -> Self { Configuration { base_path: "https://cardano-mainnet.blockfrost.io/api/v0".to_owned(), - user_agent: Some("OpenAPI-Generator/0.1.83/rust".to_owned()), + user_agent: Some("OpenAPI-Generator/0.1.85/rust".to_owned()), client: reqwest::Client::new(), basic_auth: None, oauth_access_token: None, diff --git a/rust/src/models/__get_200_response.rs b/rust/src/models/__get_200_response.rs index 2fad47f0..efda6c2f 100644 --- a/rust/src/models/__get_200_response.rs +++ b/rust/src/models/__get_200_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/__get_400_response.rs b/rust/src/models/__get_400_response.rs index 59729136..b270ee96 100644 --- a/rust/src/models/__get_400_response.rs +++ b/rust/src/models/__get_400_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/__get_403_response.rs b/rust/src/models/__get_403_response.rs index 322ab331..240a977e 100644 --- a/rust/src/models/__get_403_response.rs +++ b/rust/src/models/__get_403_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/__get_418_response.rs b/rust/src/models/__get_418_response.rs index c789515d..738b5625 100644 --- a/rust/src/models/__get_418_response.rs +++ b/rust/src/models/__get_418_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/__get_429_response.rs b/rust/src/models/__get_429_response.rs index fce61777..342cb9d5 100644 --- a/rust/src/models/__get_429_response.rs +++ b/rust/src/models/__get_429_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/__get_500_response.rs b/rust/src/models/__get_500_response.rs index f40e3495..076ee7f7 100644 --- a/rust/src/models/__get_500_response.rs +++ b/rust/src/models/__get_500_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/_blocks_latest_get_404_response.rs b/rust/src/models/_blocks_latest_get_404_response.rs index 6c115fca..e9be71e8 100644 --- a/rust/src/models/_blocks_latest_get_404_response.rs +++ b/rust/src/models/_blocks_latest_get_404_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/_health_clock_get_200_response.rs b/rust/src/models/_health_clock_get_200_response.rs index 4270c69e..3b146cac 100644 --- a/rust/src/models/_health_clock_get_200_response.rs +++ b/rust/src/models/_health_clock_get_200_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/_health_get_200_response.rs b/rust/src/models/_health_get_200_response.rs index 6e6260a6..e3fdab86 100644 --- a/rust/src/models/_health_get_200_response.rs +++ b/rust/src/models/_health_get_200_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/_ipfs_pin_add__ipfs_path__post_200_response.rs b/rust/src/models/_ipfs_pin_add__ipfs_path__post_200_response.rs index d4d510ff..379d4061 100644 --- a/rust/src/models/_ipfs_pin_add__ipfs_path__post_200_response.rs +++ b/rust/src/models/_ipfs_pin_add__ipfs_path__post_200_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/_ipfs_pin_add__ipfs_path__post_425_response.rs b/rust/src/models/_ipfs_pin_add__ipfs_path__post_425_response.rs index aa243862..b05176a4 100644 --- a/rust/src/models/_ipfs_pin_add__ipfs_path__post_425_response.rs +++ b/rust/src/models/_ipfs_pin_add__ipfs_path__post_425_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/_ipfs_pin_list__ipfs_path__get_200_response.rs b/rust/src/models/_ipfs_pin_list__ipfs_path__get_200_response.rs index 2244bbe3..2aba56b9 100644 --- a/rust/src/models/_ipfs_pin_list__ipfs_path__get_200_response.rs +++ b/rust/src/models/_ipfs_pin_list__ipfs_path__get_200_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/_ipfs_pin_list_get_200_response_inner.rs b/rust/src/models/_ipfs_pin_list_get_200_response_inner.rs index 197dd0a8..03ce13af 100644 --- a/rust/src/models/_ipfs_pin_list_get_200_response_inner.rs +++ b/rust/src/models/_ipfs_pin_list_get_200_response_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/_ipfs_pin_remove__ipfs_path__post_200_response.rs b/rust/src/models/_ipfs_pin_remove__ipfs_path__post_200_response.rs index 3ff957bf..f7164ef0 100644 --- a/rust/src/models/_ipfs_pin_remove__ipfs_path__post_200_response.rs +++ b/rust/src/models/_ipfs_pin_remove__ipfs_path__post_200_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/_pools__pool_id__metadata_get_200_response.rs b/rust/src/models/_pools__pool_id__metadata_get_200_response.rs index fa21c056..26a4bb72 100644 --- a/rust/src/models/_pools__pool_id__metadata_get_200_response.rs +++ b/rust/src/models/_pools__pool_id__metadata_get_200_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ @@ -26,7 +26,7 @@ pub struct PoolsPoolIdMetadataGet200Response { #[serde(rename = "hash", deserialize_with = "Option::deserialize")] pub hash: Option, #[serde(rename = "error", skip_serializing_if = "Option::is_none")] - pub error: Option>, + pub error: Option>, /// Ticker of the stake pool #[serde(rename = "ticker", deserialize_with = "Option::deserialize")] pub ticker: Option, diff --git a/rust/src/models/_tx_submit_post_425_response.rs b/rust/src/models/_tx_submit_post_425_response.rs index 25ac224f..e22db89a 100644 --- a/rust/src/models/_tx_submit_post_425_response.rs +++ b/rust/src/models/_tx_submit_post_425_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/_utils_txs_evaluate_utxos_post_request.rs b/rust/src/models/_utils_txs_evaluate_utxos_post_request.rs index 3dd24b0d..0036178d 100644 --- a/rust/src/models/_utils_txs_evaluate_utxos_post_request.rs +++ b/rust/src/models/_utils_txs_evaluate_utxos_post_request.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner.rs b/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner.rs index eda6fc30..643ddeb9 100644 --- a/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner.rs +++ b/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of.rs b/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of.rs index 37d248bb..9ae87d08 100644 --- a/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of.rs +++ b/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of_1.rs b/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of_1.rs index 4be8ed1a..27fa2ebd 100644 --- a/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of_1.rs +++ b/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of_1.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of_1_value.rs b/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of_1_value.rs index f9c72e54..6c43edf9 100644 --- a/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of_1_value.rs +++ b/rust/src/models/_utils_txs_evaluate_utxos_post_request_additional_utxo_set_inner_inner_any_of_1_value.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/account_addresses_assets_inner.rs b/rust/src/models/account_addresses_assets_inner.rs index 80800a8e..c117a93d 100644 --- a/rust/src/models/account_addresses_assets_inner.rs +++ b/rust/src/models/account_addresses_assets_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/account_addresses_content_inner.rs b/rust/src/models/account_addresses_content_inner.rs index fdcea64e..ae9ddc33 100644 --- a/rust/src/models/account_addresses_content_inner.rs +++ b/rust/src/models/account_addresses_content_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/account_addresses_total.rs b/rust/src/models/account_addresses_total.rs index bd166e5c..972d00c0 100644 --- a/rust/src/models/account_addresses_total.rs +++ b/rust/src/models/account_addresses_total.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/account_addresses_total_received_sum_inner.rs b/rust/src/models/account_addresses_total_received_sum_inner.rs index 73769850..cbcd8a75 100644 --- a/rust/src/models/account_addresses_total_received_sum_inner.rs +++ b/rust/src/models/account_addresses_total_received_sum_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/account_content.rs b/rust/src/models/account_content.rs index da8b6c49..0db4404f 100644 --- a/rust/src/models/account_content.rs +++ b/rust/src/models/account_content.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ @@ -16,9 +16,12 @@ pub struct AccountContent { /// Bech32 stake address #[serde(rename = "stake_address")] pub stake_address: String, - /// Registration state of an account + /// Delegation state of the account. **Note:** For registration state, use the `registered` field instead. #[serde(rename = "active")] pub active: bool, + /// Registration state of an account + #[serde(rename = "registered")] + pub registered: bool, /// Epoch of the most recent action - registration or deregistration #[serde(rename = "active_epoch", deserialize_with = "Option::deserialize")] pub active_epoch: Option, @@ -49,10 +52,11 @@ pub struct AccountContent { } impl AccountContent { - pub fn new(stake_address: String, active: bool, active_epoch: Option, controlled_amount: String, rewards_sum: String, withdrawals_sum: String, reserves_sum: String, treasury_sum: String, withdrawable_amount: String, pool_id: Option, drep_id: Option) -> AccountContent { + pub fn new(stake_address: String, active: bool, registered: bool, active_epoch: Option, controlled_amount: String, rewards_sum: String, withdrawals_sum: String, reserves_sum: String, treasury_sum: String, withdrawable_amount: String, pool_id: Option, drep_id: Option) -> AccountContent { AccountContent { stake_address, active, + registered, active_epoch, controlled_amount, rewards_sum, diff --git a/rust/src/models/account_delegation_content_inner.rs b/rust/src/models/account_delegation_content_inner.rs index 8a58393c..da6f80e8 100644 --- a/rust/src/models/account_delegation_content_inner.rs +++ b/rust/src/models/account_delegation_content_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/account_history_content_inner.rs b/rust/src/models/account_history_content_inner.rs index d6178798..db1b7bac 100644 --- a/rust/src/models/account_history_content_inner.rs +++ b/rust/src/models/account_history_content_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/account_mir_content_inner.rs b/rust/src/models/account_mir_content_inner.rs index 647e4ca9..5a598a10 100644 --- a/rust/src/models/account_mir_content_inner.rs +++ b/rust/src/models/account_mir_content_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/account_registration_content_inner.rs b/rust/src/models/account_registration_content_inner.rs index abdff3d3..a3d23b4a 100644 --- a/rust/src/models/account_registration_content_inner.rs +++ b/rust/src/models/account_registration_content_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/account_reward_content_inner.rs b/rust/src/models/account_reward_content_inner.rs index 27a370e6..3d89df3a 100644 --- a/rust/src/models/account_reward_content_inner.rs +++ b/rust/src/models/account_reward_content_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/account_transactions_content_inner.rs b/rust/src/models/account_transactions_content_inner.rs index 3948d76f..985e62aa 100644 --- a/rust/src/models/account_transactions_content_inner.rs +++ b/rust/src/models/account_transactions_content_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/account_utxo_content_inner.rs b/rust/src/models/account_utxo_content_inner.rs index 2f5b8d90..b5121aa2 100644 --- a/rust/src/models/account_utxo_content_inner.rs +++ b/rust/src/models/account_utxo_content_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/account_withdrawal_content_inner.rs b/rust/src/models/account_withdrawal_content_inner.rs index fe470730..bde94347 100644 --- a/rust/src/models/account_withdrawal_content_inner.rs +++ b/rust/src/models/account_withdrawal_content_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/address_content.rs b/rust/src/models/address_content.rs index 84bc2f57..e1dc7af8 100644 --- a/rust/src/models/address_content.rs +++ b/rust/src/models/address_content.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/address_content_extended.rs b/rust/src/models/address_content_extended.rs index 436bd46c..871709c5 100644 --- a/rust/src/models/address_content_extended.rs +++ b/rust/src/models/address_content_extended.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/address_content_extended_amount_inner.rs b/rust/src/models/address_content_extended_amount_inner.rs index 841354e2..781e6a6e 100644 --- a/rust/src/models/address_content_extended_amount_inner.rs +++ b/rust/src/models/address_content_extended_amount_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/address_content_total.rs b/rust/src/models/address_content_total.rs index a3346a71..4add4f39 100644 --- a/rust/src/models/address_content_total.rs +++ b/rust/src/models/address_content_total.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/address_transactions_content_inner.rs b/rust/src/models/address_transactions_content_inner.rs index 0359920d..abed7c82 100644 --- a/rust/src/models/address_transactions_content_inner.rs +++ b/rust/src/models/address_transactions_content_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/address_utxo_content_inner.rs b/rust/src/models/address_utxo_content_inner.rs index a5ba9133..2a110ff4 100644 --- a/rust/src/models/address_utxo_content_inner.rs +++ b/rust/src/models/address_utxo_content_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/aggregator_features_message.rs b/rust/src/models/aggregator_features_message.rs index 6e9efe63..52d8d112 100644 --- a/rust/src/models/aggregator_features_message.rs +++ b/rust/src/models/aggregator_features_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/aggregator_features_message_capabilities.rs b/rust/src/models/aggregator_features_message_capabilities.rs index 43c7f40f..370102ea 100644 --- a/rust/src/models/aggregator_features_message_capabilities.rs +++ b/rust/src/models/aggregator_features_message_capabilities.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/aggregator_features_message_capabilities_cardano_transactions_prover.rs b/rust/src/models/aggregator_features_message_capabilities_cardano_transactions_prover.rs index 10ff1c76..48dc30a2 100644 --- a/rust/src/models/aggregator_features_message_capabilities_cardano_transactions_prover.rs +++ b/rust/src/models/aggregator_features_message_capabilities_cardano_transactions_prover.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/asset.rs b/rust/src/models/asset.rs index 3d67aa33..b372423a 100644 --- a/rust/src/models/asset.rs +++ b/rust/src/models/asset.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/asset_addresses_inner.rs b/rust/src/models/asset_addresses_inner.rs index ce4a730c..7b58bb6e 100644 --- a/rust/src/models/asset_addresses_inner.rs +++ b/rust/src/models/asset_addresses_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/asset_history_inner.rs b/rust/src/models/asset_history_inner.rs index fc8d524f..28e901bb 100644 --- a/rust/src/models/asset_history_inner.rs +++ b/rust/src/models/asset_history_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/asset_metadata.rs b/rust/src/models/asset_metadata.rs index f7acf268..2b4d4b2e 100644 --- a/rust/src/models/asset_metadata.rs +++ b/rust/src/models/asset_metadata.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/asset_onchain_metadata_cip25.rs b/rust/src/models/asset_onchain_metadata_cip25.rs index 0befee97..50aa4248 100644 --- a/rust/src/models/asset_onchain_metadata_cip25.rs +++ b/rust/src/models/asset_onchain_metadata_cip25.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/asset_onchain_metadata_cip25_description.rs b/rust/src/models/asset_onchain_metadata_cip25_description.rs index 8d8829d1..0b90f32a 100644 --- a/rust/src/models/asset_onchain_metadata_cip25_description.rs +++ b/rust/src/models/asset_onchain_metadata_cip25_description.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/asset_onchain_metadata_cip25_files_inner.rs b/rust/src/models/asset_onchain_metadata_cip25_files_inner.rs index 20cbbff5..45ea6bc8 100644 --- a/rust/src/models/asset_onchain_metadata_cip25_files_inner.rs +++ b/rust/src/models/asset_onchain_metadata_cip25_files_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/asset_onchain_metadata_cip25_files_inner_src.rs b/rust/src/models/asset_onchain_metadata_cip25_files_inner_src.rs index be3235dc..65166316 100644 --- a/rust/src/models/asset_onchain_metadata_cip25_files_inner_src.rs +++ b/rust/src/models/asset_onchain_metadata_cip25_files_inner_src.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/asset_onchain_metadata_cip25_image.rs b/rust/src/models/asset_onchain_metadata_cip25_image.rs index cf8129d0..5842ed19 100644 --- a/rust/src/models/asset_onchain_metadata_cip25_image.rs +++ b/rust/src/models/asset_onchain_metadata_cip25_image.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/asset_onchain_metadata_cip68_ft_333.rs b/rust/src/models/asset_onchain_metadata_cip68_ft_333.rs index dd9f2e17..c4b5235e 100644 --- a/rust/src/models/asset_onchain_metadata_cip68_ft_333.rs +++ b/rust/src/models/asset_onchain_metadata_cip68_ft_333.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/asset_onchain_metadata_cip68_nft_222.rs b/rust/src/models/asset_onchain_metadata_cip68_nft_222.rs index 336937d2..a0996dd3 100644 --- a/rust/src/models/asset_onchain_metadata_cip68_nft_222.rs +++ b/rust/src/models/asset_onchain_metadata_cip68_nft_222.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/asset_onchain_metadata_cip68_rft_444.rs b/rust/src/models/asset_onchain_metadata_cip68_rft_444.rs index 1f7509e7..b299d769 100644 --- a/rust/src/models/asset_onchain_metadata_cip68_rft_444.rs +++ b/rust/src/models/asset_onchain_metadata_cip68_rft_444.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/asset_policy_inner.rs b/rust/src/models/asset_policy_inner.rs index 912f2208..a681d8ee 100644 --- a/rust/src/models/asset_policy_inner.rs +++ b/rust/src/models/asset_policy_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/asset_transactions_inner.rs b/rust/src/models/asset_transactions_inner.rs index bd9965e4..bc1302f1 100644 --- a/rust/src/models/asset_transactions_inner.rs +++ b/rust/src/models/asset_transactions_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/assets_inner.rs b/rust/src/models/assets_inner.rs index 49df51ee..3e506e78 100644 --- a/rust/src/models/assets_inner.rs +++ b/rust/src/models/assets_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/block_content.rs b/rust/src/models/block_content.rs index 822ca388..0ed5803d 100644 --- a/rust/src/models/block_content.rs +++ b/rust/src/models/block_content.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/block_content_addresses_inner.rs b/rust/src/models/block_content_addresses_inner.rs index c109c027..6cf28a79 100644 --- a/rust/src/models/block_content_addresses_inner.rs +++ b/rust/src/models/block_content_addresses_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/block_content_addresses_inner_transactions_inner.rs b/rust/src/models/block_content_addresses_inner_transactions_inner.rs index 7bae5f72..06213255 100644 --- a/rust/src/models/block_content_addresses_inner_transactions_inner.rs +++ b/rust/src/models/block_content_addresses_inner_transactions_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/block_content_txs_cbor_inner.rs b/rust/src/models/block_content_txs_cbor_inner.rs index 562b4844..1c1a98e2 100644 --- a/rust/src/models/block_content_txs_cbor_inner.rs +++ b/rust/src/models/block_content_txs_cbor_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/cardano_db_beacon.rs b/rust/src/models/cardano_db_beacon.rs index dd4c246e..ce502d95 100644 --- a/rust/src/models/cardano_db_beacon.rs +++ b/rust/src/models/cardano_db_beacon.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/cardano_transaction_proof_message.rs b/rust/src/models/cardano_transaction_proof_message.rs index 91034868..3205b9fd 100644 --- a/rust/src/models/cardano_transaction_proof_message.rs +++ b/rust/src/models/cardano_transaction_proof_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/cardano_transaction_proof_message_certified_transactions_inner.rs b/rust/src/models/cardano_transaction_proof_message_certified_transactions_inner.rs index 4ce0dae6..2273da15 100644 --- a/rust/src/models/cardano_transaction_proof_message_certified_transactions_inner.rs +++ b/rust/src/models/cardano_transaction_proof_message_certified_transactions_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/cardano_transaction_snapshot_list_message_inner.rs b/rust/src/models/cardano_transaction_snapshot_list_message_inner.rs index 518bae13..1187a946 100644 --- a/rust/src/models/cardano_transaction_snapshot_list_message_inner.rs +++ b/rust/src/models/cardano_transaction_snapshot_list_message_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/cardano_transaction_snapshot_message.rs b/rust/src/models/cardano_transaction_snapshot_message.rs index 3f0554c4..f80937b0 100644 --- a/rust/src/models/cardano_transaction_snapshot_message.rs +++ b/rust/src/models/cardano_transaction_snapshot_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/certificate_list_item_message.rs b/rust/src/models/certificate_list_item_message.rs index 48c82e67..67632031 100644 --- a/rust/src/models/certificate_list_item_message.rs +++ b/rust/src/models/certificate_list_item_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/certificate_list_item_message_metadata.rs b/rust/src/models/certificate_list_item_message_metadata.rs index ac88083b..44de368c 100644 --- a/rust/src/models/certificate_list_item_message_metadata.rs +++ b/rust/src/models/certificate_list_item_message_metadata.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/certificate_message.rs b/rust/src/models/certificate_message.rs index 26075b80..a61475c7 100644 --- a/rust/src/models/certificate_message.rs +++ b/rust/src/models/certificate_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/certificate_metadata.rs b/rust/src/models/certificate_metadata.rs index b9266e0f..e9497a9f 100644 --- a/rust/src/models/certificate_metadata.rs +++ b/rust/src/models/certificate_metadata.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/certificate_pending_message.rs b/rust/src/models/certificate_pending_message.rs index 61686d51..1d3fd1fc 100644 --- a/rust/src/models/certificate_pending_message.rs +++ b/rust/src/models/certificate_pending_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/drep.rs b/rust/src/models/drep.rs index 82f75364..ab2adff1 100644 --- a/rust/src/models/drep.rs +++ b/rust/src/models/drep.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/drep_delegators_inner.rs b/rust/src/models/drep_delegators_inner.rs index 1f80d1ce..035364f5 100644 --- a/rust/src/models/drep_delegators_inner.rs +++ b/rust/src/models/drep_delegators_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 94916f9d..03efcf4c 100644 --- a/rust/src/models/drep_metadata.rs +++ b/rust/src/models/drep_metadata.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ @@ -29,12 +29,14 @@ pub struct DrepMetadata { #[serde(rename = "json_metadata", deserialize_with = "Option::deserialize")] pub json_metadata: Option, /// Content of the metadata (raw) - #[serde(rename = "bytes")] - pub bytes: String, + #[serde(rename = "bytes", deserialize_with = "Option::deserialize")] + pub bytes: Option, + #[serde(rename = "error", skip_serializing_if = "Option::is_none")] + pub error: Option>, } impl DrepMetadata { - pub fn new(drep_id: String, hex: String, url: String, hash: String, json_metadata: Option, bytes: String) -> DrepMetadata { + pub fn new(drep_id: String, hex: String, url: String, hash: String, json_metadata: Option, bytes: Option) -> DrepMetadata { DrepMetadata { drep_id, hex, @@ -42,6 +44,7 @@ impl DrepMetadata { hash, json_metadata, bytes, + error: None, } } } diff --git a/rust/src/models/drep_metadata_error.rs b/rust/src/models/drep_metadata_error.rs new file mode 100644 index 00000000..5690ccd7 --- /dev/null +++ b/rust/src/models/drep_metadata_error.rs @@ -0,0 +1,56 @@ +/* + * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
+ * + * The version of the OpenAPI document: 0.1.85 + * Contact: contact@blockfrost.io + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// DrepMetadataError : Present when metadata could not be fetched or validated. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct DrepMetadataError { + /// Stable machine-readable error code. + #[serde(rename = "code")] + pub code: Code, + /// Human-readable description of the error. + #[serde(rename = "message")] + pub message: String, +} + +impl DrepMetadataError { + /// Present when metadata could not be fetched or validated. + pub fn new(code: Code, message: String) -> DrepMetadataError { + DrepMetadataError { + code, + message, + } + } +} +/// Stable machine-readable error code. +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Code { + #[serde(rename = "HASH_MISMATCH")] + HashMismatch, + #[serde(rename = "CONNECTION_ERROR")] + ConnectionError, + #[serde(rename = "HTTP_RESPONSE_ERROR")] + HttpResponseError, + #[serde(rename = "DECODE_ERROR")] + DecodeError, + #[serde(rename = "SIZE_EXCEEDED")] + SizeExceeded, + #[serde(rename = "UNKNOWN_ERROR")] + UnknownError, +} + +impl Default for Code { + fn default() -> Code { + Self::HashMismatch + } +} + diff --git a/rust/src/models/drep_updates_inner.rs b/rust/src/models/drep_updates_inner.rs index a41c986f..45d37acf 100644 --- a/rust/src/models/drep_updates_inner.rs +++ b/rust/src/models/drep_updates_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/drep_votes_inner.rs b/rust/src/models/drep_votes_inner.rs index 069f9dd1..93a66ec2 100644 --- a/rust/src/models/drep_votes_inner.rs +++ b/rust/src/models/drep_votes_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/dreps_inner.rs b/rust/src/models/dreps_inner.rs index 3a631887..74eef0ee 100644 --- a/rust/src/models/dreps_inner.rs +++ b/rust/src/models/dreps_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 4f5462e3..256dbb88 100644 --- a/rust/src/models/epoch_content.rs +++ b/rust/src/models/epoch_content.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 ee9dacd5..b9fa4a66 100644 --- a/rust/src/models/epoch_param_content.rs +++ b/rust/src/models/epoch_param_content.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 34cf5ba3..97bfe5eb 100644 --- a/rust/src/models/epoch_settings_message.rs +++ b/rust/src/models/epoch_settings_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/epoch_stake_content_inner.rs b/rust/src/models/epoch_stake_content_inner.rs index ad8e2814..479c7ec7 100644 --- a/rust/src/models/epoch_stake_content_inner.rs +++ b/rust/src/models/epoch_stake_content_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 46e5c85b..e458daee 100644 --- a/rust/src/models/epoch_stake_pool_content_inner.rs +++ b/rust/src/models/epoch_stake_pool_content_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 ad8b0581..773f541f 100644 --- a/rust/src/models/error.rs +++ b/rust/src/models/error.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 eb63d829..824e44cd 100644 --- a/rust/src/models/genesis_content.rs +++ b/rust/src/models/genesis_content.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 e399326d..fc2747f8 100644 --- a/rust/src/models/ipfs_add_200_response.rs +++ b/rust/src/models/ipfs_add_200_response.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 944ed115..e5ecc873 100644 --- a/rust/src/models/mempool_content_inner.rs +++ b/rust/src/models/mempool_content_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 3b175760..5ae3248c 100644 --- a/rust/src/models/mempool_tx_content.rs +++ b/rust/src/models/mempool_tx_content.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/mempool_tx_content_inputs_inner.rs b/rust/src/models/mempool_tx_content_inputs_inner.rs index dd9f02a5..ad4beb5a 100644 --- a/rust/src/models/mempool_tx_content_inputs_inner.rs +++ b/rust/src/models/mempool_tx_content_inputs_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 c98ea924..d7912d63 100644 --- a/rust/src/models/mempool_tx_content_outputs_inner.rs +++ b/rust/src/models/mempool_tx_content_outputs_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/mempool_tx_content_redeemers_inner.rs b/rust/src/models/mempool_tx_content_redeemers_inner.rs index 06782523..e0c7f2e5 100644 --- a/rust/src/models/mempool_tx_content_redeemers_inner.rs +++ b/rust/src/models/mempool_tx_content_redeemers_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 9be70b99..aef55ec0 100644 --- a/rust/src/models/mempool_tx_content_tx.rs +++ b/rust/src/models/mempool_tx_content_tx.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/metrics_endpoints_inner.rs b/rust/src/models/metrics_endpoints_inner.rs index 9ce07f8c..1ea47481 100644 --- a/rust/src/models/metrics_endpoints_inner.rs +++ b/rust/src/models/metrics_endpoints_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 5825f420..bb15928a 100644 --- a/rust/src/models/metrics_inner.rs +++ b/rust/src/models/metrics_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 ba8e6f64..68c15c4c 100644 --- a/rust/src/models/mithril_stake_distribution_list_message_inner.rs +++ b/rust/src/models/mithril_stake_distribution_list_message_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 c847d417..7cdd1dc1 100644 --- a/rust/src/models/mithril_stake_distribution_message.rs +++ b/rust/src/models/mithril_stake_distribution_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/mod.rs b/rust/src/models/mod.rs index 7fe8363e..5309c754 100644 --- a/rust/src/models/mod.rs +++ b/rust/src/models/mod.rs @@ -108,6 +108,8 @@ 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_metadata_error; +pub use self::drep_metadata_error::DrepMetadataError; pub mod drep_updates_inner; pub use self::drep_updates_inner::DrepUpdatesInner; pub mod drep_votes_inner; @@ -226,8 +228,6 @@ 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 use self::proposal_parameters::ProposalParameters; pub mod proposal_parameters_parameters; diff --git a/rust/src/models/network.rs b/rust/src/models/network.rs index 291d4b8e..90e14ee0 100644 --- a/rust/src/models/network.rs +++ b/rust/src/models/network.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/network_eras_inner.rs b/rust/src/models/network_eras_inner.rs index 40efb056..9f3e714f 100644 --- a/rust/src/models/network_eras_inner.rs +++ b/rust/src/models/network_eras_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/network_eras_inner_end.rs b/rust/src/models/network_eras_inner_end.rs index 04e98bc3..8a312a0f 100644 --- a/rust/src/models/network_eras_inner_end.rs +++ b/rust/src/models/network_eras_inner_end.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/network_eras_inner_parameters.rs b/rust/src/models/network_eras_inner_parameters.rs index 6f257938..efe04ee5 100644 --- a/rust/src/models/network_eras_inner_parameters.rs +++ b/rust/src/models/network_eras_inner_parameters.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/network_eras_inner_start.rs b/rust/src/models/network_eras_inner_start.rs index 034ffb08..215dc422 100644 --- a/rust/src/models/network_eras_inner_start.rs +++ b/rust/src/models/network_eras_inner_start.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/network_stake.rs b/rust/src/models/network_stake.rs index e2349856..a698ce72 100644 --- a/rust/src/models/network_stake.rs +++ b/rust/src/models/network_stake.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 b4a5cc1d..2bd3a2b8 100644 --- a/rust/src/models/network_supply.rs +++ b/rust/src/models/network_supply.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 6b690856..869584b8 100644 --- a/rust/src/models/nutlink_address.rs +++ b/rust/src/models/nutlink_address.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 42cd0ac3..35350046 100644 --- a/rust/src/models/nutlink_address_ticker_inner.rs +++ b/rust/src/models/nutlink_address_ticker_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 d606b26a..0c7e4f2c 100644 --- a/rust/src/models/nutlink_address_tickers_inner.rs +++ b/rust/src/models/nutlink_address_tickers_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 1247f0db..cd2c74ae 100644 --- a/rust/src/models/nutlink_tickers_ticker_inner.rs +++ b/rust/src/models/nutlink_tickers_ticker_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 7cb68c1c..02afb45b 100644 --- a/rust/src/models/pool.rs +++ b/rust/src/models/pool.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/pool_calidus_key.rs b/rust/src/models/pool_calidus_key.rs index dd70bcae..bd455897 100644 --- a/rust/src/models/pool_calidus_key.rs +++ b/rust/src/models/pool_calidus_key.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/pool_delegators_inner.rs b/rust/src/models/pool_delegators_inner.rs index 65b99511..f1ddf126 100644 --- a/rust/src/models/pool_delegators_inner.rs +++ b/rust/src/models/pool_delegators_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 f869bb5c..469918d2 100644 --- a/rust/src/models/pool_history_inner.rs +++ b/rust/src/models/pool_history_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 9c8f3f95..5a24c4bc 100644 --- a/rust/src/models/pool_list_extended_inner.rs +++ b/rust/src/models/pool_list_extended_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/pool_list_extended_inner_metadata.rs b/rust/src/models/pool_list_extended_inner_metadata.rs index 07ac88c9..da895a90 100644 --- a/rust/src/models/pool_list_extended_inner_metadata.rs +++ b/rust/src/models/pool_list_extended_inner_metadata.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ @@ -20,7 +20,7 @@ pub struct PoolListExtendedInnerMetadata { #[serde(rename = "hash", deserialize_with = "Option::deserialize")] pub hash: Option, #[serde(rename = "error", skip_serializing_if = "Option::is_none")] - pub error: Option>, + pub error: Option>, /// Ticker of the stake pool #[serde(rename = "ticker", deserialize_with = "Option::deserialize")] pub ticker: Option, diff --git a/rust/src/models/pool_list_retire_inner.rs b/rust/src/models/pool_list_retire_inner.rs index ff798a3b..30421bb5 100644 --- a/rust/src/models/pool_list_retire_inner.rs +++ b/rust/src/models/pool_list_retire_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 5e03d665..4a497762 100644 --- a/rust/src/models/pool_metadata.rs +++ b/rust/src/models/pool_metadata.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ @@ -26,7 +26,7 @@ pub struct PoolMetadata { #[serde(rename = "hash", deserialize_with = "Option::deserialize")] pub hash: Option, #[serde(rename = "error", skip_serializing_if = "Option::is_none")] - pub error: Option>, + pub error: Option>, /// Ticker of the stake pool #[serde(rename = "ticker", deserialize_with = "Option::deserialize")] pub ticker: Option, diff --git a/rust/src/models/pool_updates_inner.rs b/rust/src/models/pool_updates_inner.rs index 57e5af0e..da896b6b 100644 --- a/rust/src/models/pool_updates_inner.rs +++ b/rust/src/models/pool_updates_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * 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 index d542d13c..13a144c4 100644 --- a/rust/src/models/pool_votes_inner.rs +++ b/rust/src/models/pool_votes_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/proposal.rs b/rust/src/models/proposal.rs index 95f9ad5b..10049fea 100644 --- a/rust/src/models/proposal.rs +++ b/rust/src/models/proposal.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/proposal_metadata.rs b/rust/src/models/proposal_metadata.rs index b00648a8..efe88e64 100644 --- a/rust/src/models/proposal_metadata.rs +++ b/rust/src/models/proposal_metadata.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/proposal_metadata_v2.rs b/rust/src/models/proposal_metadata_v2.rs index d805c7c0..4fcf82f9 100644 --- a/rust/src/models/proposal_metadata_v2.rs +++ b/rust/src/models/proposal_metadata_v2.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ @@ -35,7 +35,7 @@ pub struct ProposalMetadataV2 { #[serde(rename = "bytes", deserialize_with = "Option::deserialize")] pub bytes: Option, #[serde(rename = "error", skip_serializing_if = "Option::is_none")] - pub error: Option>, + pub error: Option>, } impl ProposalMetadataV2 { diff --git a/rust/src/models/proposal_parameters.rs b/rust/src/models/proposal_parameters.rs index 5564bc12..d9d62564 100644 --- a/rust/src/models/proposal_parameters.rs +++ b/rust/src/models/proposal_parameters.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/proposal_parameters_parameters.rs b/rust/src/models/proposal_parameters_parameters.rs index 9102efb1..4f79b76b 100644 --- a/rust/src/models/proposal_parameters_parameters.rs +++ b/rust/src/models/proposal_parameters_parameters.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/proposal_votes_inner.rs b/rust/src/models/proposal_votes_inner.rs index 9300b785..4e48400c 100644 --- a/rust/src/models/proposal_votes_inner.rs +++ b/rust/src/models/proposal_votes_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/proposal_withdrawals_inner.rs b/rust/src/models/proposal_withdrawals_inner.rs index 1cacb462..269c1a04 100644 --- a/rust/src/models/proposal_withdrawals_inner.rs +++ b/rust/src/models/proposal_withdrawals_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/proposals_inner.rs b/rust/src/models/proposals_inner.rs index f95ba16a..e5ea5a98 100644 --- a/rust/src/models/proposals_inner.rs +++ b/rust/src/models/proposals_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/protocol_message.rs b/rust/src/models/protocol_message.rs index 2c58150d..8c096e85 100644 --- a/rust/src/models/protocol_message.rs +++ b/rust/src/models/protocol_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/protocol_message_parts.rs b/rust/src/models/protocol_message_parts.rs index 4bfbf675..2ca5ce9c 100644 --- a/rust/src/models/protocol_message_parts.rs +++ b/rust/src/models/protocol_message_parts.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/protocol_parameters.rs b/rust/src/models/protocol_parameters.rs index a0e91d05..69a57b5f 100644 --- a/rust/src/models/protocol_parameters.rs +++ b/rust/src/models/protocol_parameters.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/register_signer_message.rs b/rust/src/models/register_signer_message.rs index 43d258b7..b0805f43 100644 --- a/rust/src/models/register_signer_message.rs +++ b/rust/src/models/register_signer_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/register_single_signature_message.rs b/rust/src/models/register_single_signature_message.rs index d7b75506..3ad2d164 100644 --- a/rust/src/models/register_single_signature_message.rs +++ b/rust/src/models/register_single_signature_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/script.rs b/rust/src/models/script.rs index 6917c0c4..4977c6ad 100644 --- a/rust/src/models/script.rs +++ b/rust/src/models/script.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/script_cbor.rs b/rust/src/models/script_cbor.rs index d1ba9173..18e25b5b 100644 --- a/rust/src/models/script_cbor.rs +++ b/rust/src/models/script_cbor.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/script_datum.rs b/rust/src/models/script_datum.rs index 562edef0..ecc09d3a 100644 --- a/rust/src/models/script_datum.rs +++ b/rust/src/models/script_datum.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/script_datum_cbor.rs b/rust/src/models/script_datum_cbor.rs index d6e90f3a..ad11f800 100644 --- a/rust/src/models/script_datum_cbor.rs +++ b/rust/src/models/script_datum_cbor.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/script_json.rs b/rust/src/models/script_json.rs index 1e3b302d..a96f73ce 100644 --- a/rust/src/models/script_json.rs +++ b/rust/src/models/script_json.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/script_redeemers_inner.rs b/rust/src/models/script_redeemers_inner.rs index d9d97701..a3047f54 100644 --- a/rust/src/models/script_redeemers_inner.rs +++ b/rust/src/models/script_redeemers_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/scripts_inner.rs b/rust/src/models/scripts_inner.rs index 8be029f0..5eb4f01e 100644 --- a/rust/src/models/scripts_inner.rs +++ b/rust/src/models/scripts_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/signer.rs b/rust/src/models/signer.rs index 4707367e..1d0f0421 100644 --- a/rust/src/models/signer.rs +++ b/rust/src/models/signer.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/signer_registrations_list_item_message.rs b/rust/src/models/signer_registrations_list_item_message.rs index 4a0d1b89..e4f3c312 100644 --- a/rust/src/models/signer_registrations_list_item_message.rs +++ b/rust/src/models/signer_registrations_list_item_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/signer_registrations_message.rs b/rust/src/models/signer_registrations_message.rs index ba827ae3..3f20025b 100644 --- a/rust/src/models/signer_registrations_message.rs +++ b/rust/src/models/signer_registrations_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/signer_ticker_list_item_message.rs b/rust/src/models/signer_ticker_list_item_message.rs index 390b09f7..2032c4b7 100644 --- a/rust/src/models/signer_ticker_list_item_message.rs +++ b/rust/src/models/signer_ticker_list_item_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/signer_with_stake.rs b/rust/src/models/signer_with_stake.rs index eb83a02c..a6f2ffa8 100644 --- a/rust/src/models/signer_with_stake.rs +++ b/rust/src/models/signer_with_stake.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/signers_tickers_message.rs b/rust/src/models/signers_tickers_message.rs index a974db07..e1260619 100644 --- a/rust/src/models/signers_tickers_message.rs +++ b/rust/src/models/signers_tickers_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/snapshot.rs b/rust/src/models/snapshot.rs index 3097c5b7..e872b64f 100644 --- a/rust/src/models/snapshot.rs +++ b/rust/src/models/snapshot.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/snapshot_download_message.rs b/rust/src/models/snapshot_download_message.rs index 32b64699..6b80a34c 100644 --- a/rust/src/models/snapshot_download_message.rs +++ b/rust/src/models/snapshot_download_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/snapshot_message.rs b/rust/src/models/snapshot_message.rs index 5aee269b..ed22a958 100644 --- a/rust/src/models/snapshot_message.rs +++ b/rust/src/models/snapshot_message.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/stake.rs b/rust/src/models/stake.rs index 5a1f2ce7..c82cdd29 100644 --- a/rust/src/models/stake.rs +++ b/rust/src/models/stake.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/stake_distribution_party.rs b/rust/src/models/stake_distribution_party.rs index c8bcb326..aeb36da5 100644 --- a/rust/src/models/stake_distribution_party.rs +++ b/rust/src/models/stake_distribution_party.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content.rs b/rust/src/models/tx_content.rs index d882306d..51d3803c 100644 --- a/rust/src/models/tx_content.rs +++ b/rust/src/models/tx_content.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_cbor.rs b/rust/src/models/tx_content_cbor.rs index f46e2fea..9fea8e28 100644 --- a/rust/src/models/tx_content_cbor.rs +++ b/rust/src/models/tx_content_cbor.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_delegations_inner.rs b/rust/src/models/tx_content_delegations_inner.rs index 1277330f..afd09ac5 100644 --- a/rust/src/models/tx_content_delegations_inner.rs +++ b/rust/src/models/tx_content_delegations_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_metadata_cbor_inner.rs b/rust/src/models/tx_content_metadata_cbor_inner.rs index e66c01e7..5e559fb5 100644 --- a/rust/src/models/tx_content_metadata_cbor_inner.rs +++ b/rust/src/models/tx_content_metadata_cbor_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_metadata_inner.rs b/rust/src/models/tx_content_metadata_inner.rs index 6415e905..c3fb453f 100644 --- a/rust/src/models/tx_content_metadata_inner.rs +++ b/rust/src/models/tx_content_metadata_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_metadata_inner_json_metadata.rs b/rust/src/models/tx_content_metadata_inner_json_metadata.rs index 2b0e48ee..2bd10ace 100644 --- a/rust/src/models/tx_content_metadata_inner_json_metadata.rs +++ b/rust/src/models/tx_content_metadata_inner_json_metadata.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_mirs_inner.rs b/rust/src/models/tx_content_mirs_inner.rs index f1b9b665..5775fb95 100644 --- a/rust/src/models/tx_content_mirs_inner.rs +++ b/rust/src/models/tx_content_mirs_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_output_amount_inner.rs b/rust/src/models/tx_content_output_amount_inner.rs index 03a4e92c..dc9680fd 100644 --- a/rust/src/models/tx_content_output_amount_inner.rs +++ b/rust/src/models/tx_content_output_amount_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_pool_certs_inner.rs b/rust/src/models/tx_content_pool_certs_inner.rs index 8f29d33e..ba06623e 100644 --- a/rust/src/models/tx_content_pool_certs_inner.rs +++ b/rust/src/models/tx_content_pool_certs_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_pool_certs_inner_metadata.rs b/rust/src/models/tx_content_pool_certs_inner_metadata.rs index c4407685..fbbf45b3 100644 --- a/rust/src/models/tx_content_pool_certs_inner_metadata.rs +++ b/rust/src/models/tx_content_pool_certs_inner_metadata.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_pool_certs_inner_relays_inner.rs b/rust/src/models/tx_content_pool_certs_inner_relays_inner.rs index d4b59bf5..e9a90651 100644 --- a/rust/src/models/tx_content_pool_certs_inner_relays_inner.rs +++ b/rust/src/models/tx_content_pool_certs_inner_relays_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_pool_retires_inner.rs b/rust/src/models/tx_content_pool_retires_inner.rs index 1c8c3f63..e8e58e54 100644 --- a/rust/src/models/tx_content_pool_retires_inner.rs +++ b/rust/src/models/tx_content_pool_retires_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_redeemers_inner.rs b/rust/src/models/tx_content_redeemers_inner.rs index f40edd5e..8ca0e470 100644 --- a/rust/src/models/tx_content_redeemers_inner.rs +++ b/rust/src/models/tx_content_redeemers_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_required_signers_inner.rs b/rust/src/models/tx_content_required_signers_inner.rs index 65009b8a..3e292f9a 100644 --- a/rust/src/models/tx_content_required_signers_inner.rs +++ b/rust/src/models/tx_content_required_signers_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_stake_addr_inner.rs b/rust/src/models/tx_content_stake_addr_inner.rs index 2fe70556..6690ce8d 100644 --- a/rust/src/models/tx_content_stake_addr_inner.rs +++ b/rust/src/models/tx_content_stake_addr_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_utxo.rs b/rust/src/models/tx_content_utxo.rs index f52d4a8e..31a664fe 100644 --- a/rust/src/models/tx_content_utxo.rs +++ b/rust/src/models/tx_content_utxo.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_utxo_inputs_inner.rs b/rust/src/models/tx_content_utxo_inputs_inner.rs index 6eb185b4..67210699 100644 --- a/rust/src/models/tx_content_utxo_inputs_inner.rs +++ b/rust/src/models/tx_content_utxo_inputs_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_utxo_outputs_inner.rs b/rust/src/models/tx_content_utxo_outputs_inner.rs index 2859b5c5..d18d7907 100644 --- a/rust/src/models/tx_content_utxo_outputs_inner.rs +++ b/rust/src/models/tx_content_utxo_outputs_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_content_withdrawals_inner.rs b/rust/src/models/tx_content_withdrawals_inner.rs index 15acfe24..b5f4fbc3 100644 --- a/rust/src/models/tx_content_withdrawals_inner.rs +++ b/rust/src/models/tx_content_withdrawals_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_metadata_label_cbor_inner.rs b/rust/src/models/tx_metadata_label_cbor_inner.rs index 4eb5da4c..4ff567e8 100644 --- a/rust/src/models/tx_metadata_label_cbor_inner.rs +++ b/rust/src/models/tx_metadata_label_cbor_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_metadata_label_json_inner.rs b/rust/src/models/tx_metadata_label_json_inner.rs index ac7a249c..ee222993 100644 --- a/rust/src/models/tx_metadata_label_json_inner.rs +++ b/rust/src/models/tx_metadata_label_json_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/tx_metadata_labels_inner.rs b/rust/src/models/tx_metadata_labels_inner.rs index 4fda410c..eb82e846 100644 --- a/rust/src/models/tx_metadata_labels_inner.rs +++ b/rust/src/models/tx_metadata_labels_inner.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/rust/src/models/utils_addresses_xpub.rs b/rust/src/models/utils_addresses_xpub.rs index f6abd29e..ce433a64 100644 --- a/rust/src/models/utils_addresses_xpub.rs +++ b/rust/src/models/utils_addresses_xpub.rs @@ -3,7 +3,7 @@ * * 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.
Programming language SDK
JavaScript blockfrost-js
Haskell blockfrost-haskell
Python blockfrost-python
Rust blockfrost-rust
Golang blockfrost-go
Ruby blockfrost-ruby
Java blockfrost-java
Scala blockfrost-scala
Swift blockfrost-swift
Kotlin blockfrost-kotlin
Elixir blockfrost-elixir
.NET blockfrost-dotnet
Arduino blockfrost-arduino
PHP blockfrost-php
Crystal blockfrost-crystal
* - * The version of the OpenAPI document: 0.1.83 + * The version of the OpenAPI document: 0.1.85 * Contact: contact@blockfrost.io * Generated by: https://openapi-generator.tech */ diff --git a/shell.nix b/shell.nix deleted file mode 100644 index 66e6d0f4..00000000 --- a/shell.nix +++ /dev/null @@ -1,18 +0,0 @@ -with import { }; - -stdenv.mkDerivation { - name = "openapi"; - buildInputs = [ - nodejs_20 - pkgs.openjdk21 - (yarn.override { nodejs = nodejs_20; }) - ]; - shellHook = '' - export PATH="$PATH:$(pwd)/node_modules/.bin" - yarn - echo "Rebuilding docs" - yarn build - yarn run build - echo -e "\nDON'T FORGET TO RUN yarn build after changing files" - ''; -}