gp-core

https://docs.rs/gp-core/7.0.0
Admin
A Rust crate providing shareable Substrate types including cryptographic utilities, bounded...
Tokens:485,412
Snippets:4,397
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### starts_with

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.OpaqueMetadata.html

Returns true if the slice starts with the given prefix slice.

```APIDOC
## starts_with(&self, needle: &[T]) -> bool

### Description
Returns `true` if `needle` is a prefix of the slice.

### Parameters
#### Path Parameters
- `needle` (&[T]) - Required - The slice to check as a prefix.

### Response
#### Success Response (bool)
- `true` - If the slice starts with the `needle`.
- `false` - If the slice does not start with the `needle`.

### Request Example
```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

### Edge Cases
Always returns `true` if `needle` is an empty slice.
```

--------------------------------

### Provided Proof Size

Source: https://docs.rs/gp-core/7.0.0/gp_core/traits/trait.Externalities.html

Provides a default implementation to get the proof size, if available.

```rust
fn proof_size(&self) -> Option<u32> { ... }
```

--------------------------------

### Get Whitelist

Source: https://docs.rs/gp-core/7.0.0/gp_core/traits/trait.Externalities.html

Retrieves the list of tracked storage keys that are whitelisted.

```rust
fn get_whitelist(&self) -> Vec<TrackedStorageKey>;
```

--------------------------------

### Binary Search by Key Example

Source: https://docs.rs/gp-core/7.0.0/gp_core/bounded_vec/struct.BoundedVec.html

Demonstrates binary search on a slice of tuples using a key extraction function. Shows cases where elements are found, not found, and have multiple possible positions.

```rust
let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
         (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),
         (1, 21), (2, 34), (4, 55)];

assert_eq!(s.binary_search_by_key(&13, |&(a, b)| b),  Ok(9));
assert_eq!(s.binary_search_by_key(&4, |&(a, b)| b),   Err(7));
assert_eq!(s.binary_search_by_key(&100, |&(a, b)| b), Err(13));
let r = s.binary_search_by_key(&1, |&(a, b)| b);
assert!(match r { Ok(1..=4) => true, _ => false, });
```

--------------------------------

### Get vector capacity

Source: https://docs.rs/gp-core/7.0.0/gp_core/bounded_vec/struct.BoundedVec.html

Returns the total number of elements the vector can hold without reallocating. Example shows checking capacity after initialization.

```rust
let mut vec: Vec<i32> = Vec::with_capacity(10);
vec.push(42);
assert!(vec.capacity() >= 10);
```

--------------------------------

### OffchainDbExt::new

Source: https://docs.rs/gp-core/7.0.0/gp_core/offchain/struct.OffchainDbExt.html

Creates a new instance of OffchainDbExt, taking an offchain database implementation as input.

```APIDOC
## OffchainDbExt::new

### Description
Create a new instance of `OffchainDbExt`.

### Signature
```rust
pub fn new<O: DbExternalities + 'static>(offchain: O) -> Self
```

### Parameters
* `offchain`: An implementation of `DbExternalities` that will be used for offchain operations.
```

--------------------------------

### Iterate Over Chunks From the End of a Slice

Source: https://docs.rs/gp-core/7.0.0/gp_core/ed25519/struct.Public.html

Use `rchunks` to get an iterator over chunks of a specified size starting from the end of the slice. The last chunk may be smaller than `chunk_size`.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert_eq!(iter.next().unwrap(), &['l']);
assert!(iter.next().is_none())
```

--------------------------------

### Start HTTP Request

Source: https://docs.rs/gp-core/7.0.0/src/gp_core/offchain/mod.rs.html

Initiates an HTTP request with a specified method, URI, and metadata. Returns a unique request ID or an error.

```rust
fn http_request_start(
		&mut self,
		method: &str,
		uri: &str,
		meta: &[u8],
	) -> Result<HttpRequestId, ()>
```

--------------------------------

### Strip prefix from slice

Source: https://docs.rs/gp-core/7.0.0/gp_core/bounded_vec/struct.BoundedSlice.html

Use `strip_prefix` to get a subslice with the prefix removed. Returns `None` if the slice does not start with the specified prefix. An empty prefix returns the original slice.

```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);
```

```rust
let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```

--------------------------------

### Create New TestPersistentOffchainDB

Source: https://docs.rs/gp-core/7.0.0/gp_core/offchain/testing/struct.TestPersistentOffchainDB.html

Creates a new, empty offchain storage database for persistent items. Use this to initialize the test storage.

```rust
pub fn new() -> Self>
```

--------------------------------

### Iterate Over Exact Chunks From the End of a Slice

Source: https://docs.rs/gp-core/7.0.0/gp_core/ed25519/struct.Public.html

Use `rchunks_exact` to get an iterator over chunks of a specified size starting from the end of the slice. Elements not fitting into an exact chunk are available via the `remainder` method. This can be more optimizable than `rchunks`.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks_exact(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &['l'])
```

--------------------------------

### http_request_start

Source: https://docs.rs/gp-core/7.0.0/gp_core/offchain/trait.Externalities.html

Initiates an HTTP request. Meta is a future-reserved field containing additional, parity-scale-codec encoded parameters. Returns the ID of the newly started request.

```APIDOC
## http_request_start

### Description
Initiates a http request given HTTP verb and the URL. Meta is a future-reserved field containing additional, parity-scale-codec encoded parameters. Returns the id of newly started request.
Returns an error if:
  * No new request identifier could be allocated.
  * The method or URI contain invalid characters.

### Method
`http_request_start(&mut self, method: &str, uri: &str, meta: &[u8]) -> Result<HttpRequestId, ()>`
```

--------------------------------

### Get Trait Definition

Source: https://docs.rs/gp-core/7.0.0/gp_core/trait.Get.html

Defines the Get trait with a single required method `get()` that returns a value of type `T`.

```APIDOC
## Trait gp_core::Get

### Description
A trait for querying a single value from a type. It is not required that the value is constant.

### Required Methods
#### fn get() -> T
Return the current value.

### Object Safety
This trait is **not** object safe.

### Implementations on Foreign Types
#### impl<T> Get<T> for ()
where T: Default,
#### fn get() -> T
```

--------------------------------

### Handle HTTP Request Start

Source: https://docs.rs/gp-core/7.0.0/src/gp_core/offchain/testing.rs.html

Initiates an HTTP request simulation by creating a `PendingRequest` and assigning it a unique `RequestId`. This method is called when the runtime attempts to make an outgoing HTTP request.

```rust
state.requests.insert(
			id,
			PendingRequest {
				method: method.into(),
				uri: uri.into(),
				meta: meta.into(),
				..Default::default()
			},
		);
```

--------------------------------

### Implement IsWrappedBy for T

Source: https://docs.rs/gp-core/7.0.0/gp_core/hexdisplay/struct.HexDisplay.html

Provides methods to get references to the inner type from a wrapper type. `from_ref` gets an immutable reference, and `from_mut` gets a mutable reference.

```rust
fn from_ref(outer: &Outer) -> &T

```

```rust
fn from_mut(outer: &mut Outer) -> &mut T

```

--------------------------------

### Implement Get for Unit Type

Source: https://docs.rs/gp-core/7.0.0/gp_core/trait.Get.html

Implements the Get trait for the unit type `()`. This requires that the type `T` implements the `Default` trait, allowing `get()` to return a default value.

```rust
impl<T> Get<T> for ()
where
    T: Default,
{
    // Required method
    fn get() -> T;
}
```

--------------------------------

### TestOffchainExt::http_request_start

Source: https://docs.rs/gp-core/7.0.0/src/gp_core/offchain/testing.rs.html

Initiates an HTTP request with the given method, URI, and metadata. Returns a `RequestId` for the new request.

```APIDOC
## Method: TestOffchainExt::http_request_start

### Description
Starts a new simulated HTTP request and stores it in the `OffchainState`.

### Parameters
- `method`: &str - The HTTP method (e.g., "GET", "POST").
- `uri`: &str - The request URI.
- `meta`: &[u8] - Metadata associated with the request.

### Returns
- `Result<RequestId, ()>` - The ID of the newly created request, or an error if it could not be created.
```

--------------------------------

### Define the Get Trait

Source: https://docs.rs/gp-core/7.0.0/gp_core/trait.Get.html

Defines the Get trait with a single required method `get()` which returns a value of type `T`. This trait is used for querying a single value from a type.

```rust
pub trait Get<T> {
    // Required method
    fn get() -> T;
}
```

--------------------------------

### From Implementation

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.H512.html

Provides a basic `From` implementation.

```APIDOC
## fn from(t: T) -> T

### Description
Returns the argument unchanged. This is a trivial `From` implementation.

### Method
`from`

### Parameters
- `t`: The value to convert.

### Response
- `T`: The original value.
```

--------------------------------

### Get Trait Implementation for ConstU64

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.ConstU64.html

Implements the Get trait for ConstU64 to retrieve the constant value.

```APIDOC
### impl<const T: u64> Get<Option<u64>> for ConstU64<T>

#### fn get() -> Option<u64>
Return the current value.

### impl<const T: u64> Get<u64> for ConstU64<T>

#### fn get() -> u64
Return the current value.
```

--------------------------------

### pub fn new<T: ReadRuntimeVersion + 'static>(inner: T) -> Self

Source: https://docs.rs/gp-core/7.0.0/gp_core/traits/struct.ReadRuntimeVersionExt.html

Creates a new instance of the extension given a version determinator instance.

```APIDOC
## pub fn new<T: ReadRuntimeVersion + 'static>(inner: T) -> Self

### Description
Creates a new instance of the extension given a version determinator instance.

### Parameters
#### Path Parameters
- **inner** (T) - Required - The version determinator instance.
```

--------------------------------

### Get Trait Implementation

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.ConstU32.html

Demonstrates how to retrieve the constant u32 value using the Get trait.

```APIDOC
## impl<const T: u32> Get<Option<u32>> for ConstU32<T>

#### fn get() -> Option<u32>
Return the current value.

## impl<const T: u32> Get<u32> for ConstU32<T>

#### fn get() -> u32
Return the current value.
```

--------------------------------

### starts_with

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.Bytes.html

Checks if a slice begins with a specified prefix. Returns true if the prefix is empty.

```APIDOC
## pub fn starts_with(&self, needle: &[T]) -> bool

### Description
Returns `true` if `needle` is a prefix of the slice.

### Parameters
* `needle`: The slice to check as a prefix.

### Returns
`true` if `needle` is a prefix of the slice, `false` otherwise.

### Examples
```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));

// Always returns `true` if `needle` is an empty slice:
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```
```

--------------------------------

### RuntimeSpawn

Source: https://docs.rs/gp-core/7.0.0/gp_core/traits/index.html

Runtime spawn extension.

```APIDOC
## Trait: RuntimeSpawn

### Description
Runtime spawn extension.

### Methods
(No specific methods documented in the source)
```

--------------------------------

### Get Trait Implementation

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.ConstI32.html

Demonstrates how to retrieve the constant i32 value using the Get trait.

```APIDOC
## Trait Implementations

### impl<const T: i32> Get<Option<i32>> for ConstI32<T>

#### fn get() -> Option<i32>
Return the current value.

### impl<const T: i32> Get<i32> for ConstI32<T>

#### fn get() -> i32
Return the current value.

### impl<const T: i32> TypedGet for ConstI32<T>

#### type Type = i32
The type which is returned.

#### fn get() -> i32
Return the current value.
```

--------------------------------

### Get Trait Implementation for u64

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.ConstU64.html

Implements the Get trait to retrieve the constant value directly as a u64.

```rust
impl<const T: u64> Get<u64> for ConstU64<T>

```

```rust
fn get() -> u64

```

--------------------------------

### Capabilities Creation Methods

Source: https://docs.rs/gp-core/7.0.0/gp_core/offchain/struct.Capabilities.html

Methods for creating instances of Capabilities.

```APIDOC
## Creation Methods

### `empty()`

Returns an empty set of flags.

### `all()`

Returns the set containing all flags.

### `from_bits(bits: u32)`

Convert from underlying bit representation, unless that representation contains bits that do not correspond to a flag.

### `from_bits_truncate(bits: u32)`

Convert from underlying bit representation, dropping any bits that do not correspond to flags.

### `from_bits_unchecked(bits: u32)`

Convert from underlying bit representation, preserving all bits (even those not corresponding to a defined flag).

#### Safety
The caller of the `bitflags!` macro can chose to allow or disallow extra bits for their bitflags type.
The caller of `from_bits_unchecked()` has to ensure that all bits correspond to a defined flag or that extra bits are valid for this bitflags type.
```

--------------------------------

### Get Trait Implementation for Option<u64>

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.ConstU64.html

Implements the Get trait to retrieve the constant value as an Option<u64>.

```rust
impl<const T: u64> Get<Option<u64>> for ConstU64<T>

```

```rust
fn get() -> Option<u64>

```

--------------------------------

### Initialize TestOffchainExt with Persistent Storage

Source: https://docs.rs/gp-core/7.0.0/src/gp_core/offchain/testing.rs.html

Creates a new `TestOffchainExt` instance pre-configured with a specific `TestPersistentOffchainDB`. This allows tests to simulate persistent storage interactions.

```rust
let (ext, state) = TestOffchainExt::with_offchain_db(offchain_db);
```

--------------------------------

### Conversion Implementations (From, Into, TryFrom, TryInto, UncheckedInto)

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.Bytes.html

Details on how types can be converted to and from each other, including fallible and infallible conversions.

```APIDOC
## Conversion Traits

### `From<T> for T`

#### `fn from(t: T) -> T`
Returns the argument unchanged.

### `Into<U> for T`

#### `fn into(self) -> U` where `U: From<T>`
Calls `U::from(self)`. That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

### `TryFrom<U> for T`

#### `type Error = Infallible`
The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`
Performs the conversion.

### `TryInto<U> for T`

#### `type Error = <U as TryFrom<T>>::Error`
The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`
Performs the conversion.

### `UncheckedInto<T> for S`

#### `fn unchecked_into(self) -> T` where `T: UncheckedFrom<S>`
The counterpart to `unchecked_from`.
```

--------------------------------

### Get Trait Implementation for ConstU128 (u128)

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.ConstU128.html

Implements the Get trait to retrieve the constant value directly as a u128.

```rust
impl<const T: u128> Get<u128> for ConstU128<T>
fn get() -> u128
```

--------------------------------

### TestPersistentOffchainDB::new() Constructor

Source: https://docs.rs/gp-core/7.0.0/src/gp_core/offchain/testing.rs.html

Creates a new, empty offchain storage database for persistent items, suitable for testing.

```rust
impl TestPersistentOffchainDB {
	const PREFIX: &'static [u8] = b"\"";

	/// Create a new and empty offchain storage db for persistent items
	pub fn new() -> Self {
		Self { persistent: Arc::new(RwLock::new(InMemOffchainStorage::default())) }
	}

	/// Apply a set of off-chain changes directly to the test backend
	pub fn apply_offchain_changes(
		&mut self,
		changes: impl Iterator<Item = ((Vec<u8>, Vec<u8>), OffchainOverlayedChange)>,
	) {
		let mut me = self.persistent.write();
		for ((_prefix, key), value_operation) in changes {
			match value_operation {
				OffchainOverlayedChange::SetValue(val) =>
					me.set(Self::PREFIX, key.as_slice(), val.as_slice()),
				OffchainOverlayedChange::Remove => me.remove(Self::PREFIX, key.as_slice()),
			}
		}
	}

	/// Retrieve a key from the test backend.
	pub fn get(&self, key: &[u8]) -> Option<Vec<u8>> {
		OffchainStorage::get(self, Self::PREFIX, key)
	}
}

impl OffchainStorage for TestPersistentOffchainDB {
	fn set(&mut self, prefix: &[u8], key: &[u8], value: &[u8]) {
		self.persistent.write().set(prefix, key, value);
	}

	only generate a valid, parseable JSON. Besides scalars, boolean, and null, other values must be double-quoted as valid strings. Do not generate any comments inside the json block. Do not generate any control token (such as 
 and 	) at any places. If a user requests multiple JSON, always return a single parseable JSON array. Do not include any extra text outside of the JSON string. 2. Treat each distinct displayed code block or code panel as a separate candidate unless the source clearly shows that adjacent blocks are two parts of one displayed example or they are the same example in different languages. 3. Use the exact code text from the source for every "code" value. Copy it verbatim, preserving imports, whitespace, punctuation, comments, and line breaks. 4. Never reconstruct, normalize, complete, merge, paraphrase, or "fix" code. Do not infer missing lines from prose, headings, surrounding paragraphs, or nearby examples. 5. If a candidate example is ambiguous, partially rendered, truncated, or spread across prose in a way that requires reconstruction, exclude it. 6. Prefer verbatim code from the source. Do not add lines, imports, or logic that are not present in the original. If you must minimally adjust formatting (e.g., whitespace), do not change the meaning or content. ANALYSIS REQUIREMENTS: 1. **File-level**: Create a concise title, summary, and identify common patterns. 2. **Snippets**: Separate entries for each unique functionality/programming-language combination. These MUST be EXACTLY how they appear in the source. Do not invent code snippets, expand partial snippets, or separate one displayed snippet into multiple unless the source already displays them separately. 3. **Titles**: Start with the core action, include the technology/programming language, and keep under 100 characters. 4. **Descriptions**: use no more than 2 short sentences. Focus on when to use the snippet, required setup/imports, constraints, side effects, non-obvious behavior, etc. - Prefer usage notes and caveats over summaries. Do not explain the code line-by-line, translate it into natural language, or start with phrases like "This code", "Demonstrates", etc. when that only restates the obvious. - If surrounding docs add little context, write the shortest useful usage-oriented note. Ground the description in the snippet's own code and nearest relevant heading/paragraph only; NEVER borrow details from unrelated sections. 5.**Grouping with codeList**: Use "codeList" to group examples that have significant overlap, including close variants such as the same code with different inputs, gateway and direct-path variants, small transport/configuration/boilerplate differences, or cross-language equivalents with the same intent. - Keep examples separate when they serve different purposes, use different APIs, or require different usage notes/caveats. When unsure whether to group, keep them separate. VALIDATION: - No-Code content: If the page does not contain code, return empty array for "codeSnippets" property. - "code" must contain actual programming code (not descriptions) - "code" and "codeList" cannot be empty - Extract ALL code examples from the content - Do not fabricate explanations from other sections just because the wording sounds similar. - The final output must cover ALL examples found in the source; DO NOT return early with a partial subset. - Code snippets must be EXACTLY how they appear in the source. Do not invent code snippets, separate one snippet into multiple, remove imports, or merge content from multiple areas. - When unsure whether something is truly displayed as code, exclude it. ESCAPING EXAMPLES: - Multi-line: "function example() {\n  return true;\n}" - Special chars: "const path = \"C:\\\\Users\\\\file\";\n" Project: /websites/rs_gp-core_7_0_0 Content: Docs.rs * gp-core-7.0.0 * Platform * Feature flags * docs.rs * Rust ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 ``` ``` // This file is part of Substrate. // Copyright (C) Parity Technologies (UK) Ltd. // SPDX-License-Identifier: Apache-2.0 // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //! Utilities for offchain calls testing. //! //! Namely all ExecutionExtensions that allow mocking //! the extra APIs. use crate::{ offchain::{ self, storage::InMemOffchainStorage, HttpError, HttpRequestId as RequestId, HttpRequestStatus as RequestStatus, OffchainOverlayedChange, OffchainStorage, OpaqueNetworkState, StorageKind, Timestamp, TransactionPool, }, OpaquePeerId, }; use std::{ collections::{ BTreeMap, VecDeque }, sync::Arc, }; use parking_lot::RwLock; /// Pending request. #[derive(Debug, Default, PartialEq, Eq)] pub struct PendingRequest { /// HTTP method pub method: String, /// URI pub uri: String, /// Encoded Metadata pub meta: Vec<u8>, /// Request headers pub headers: Vec<(String, String)>, /// Request body pub body: Vec<u8>, /// Has the request been sent already. pub sent: bool, /// Response body pub response: Option<Vec<u8>>, /// Number of bytes already read from the response body. pub read: usize, /// Response headers pub response_headers: Vec<(String, String)>, } /// Sharable "persistent" offchain storage for test. #[derive(Debug, Clone, Default)] pub struct TestPersistentOffchainDB { persistent: Arc<RwLock<InMemOffchainStorage>>, } impl TestPersistentOffchainDB { const PREFIX: &'static [u8] = b"\""; /// Create a new and empty offchain storage db for persistent items pub fn new() -> Self { Self { persistent: Arc::new(RwLock::new(InMemOffchainStorage::default())) } } /// Apply a set of off-chain changes directly to the test backend pub fn apply_offchain_changes( &mut self, changes: impl Iterator<Item = ((Vec<u8>, Vec<u8>), OffchainOverlayedChange)>, ) { let mut me = self.persistent.write(); for ((_prefix, key), value_operation) in changes { match value_operation { OffchainOverlayedChange::SetValue(val) => me.set(Self::PREFIX, key.as_slice(), val.as_slice()), OffchainOverlayedChange::Remove => me.remove(Self::PREFIX, key.as_slice()), } } } /// Retrieve a key from the test backend. pub fn get(&self, key: &[u8]) -> Option<Vec<u8>> { OffchainStorage::get(self, Self::PREFIX, key) } } impl OffchainStorage for TestPersistentOffchainDB { fn set(&mut self, prefix: &[u8], key: &[u8], value: &[u8]) { self.persistent.write().set(prefix, key, value); } fn remove(&mut self, prefix: &[u8], key: &[u8]) { self.persistent.write().remove(prefix, key); } fn get(&self, prefix: &[u8], key: &[u8]) -> Option<Vec<u8>> { self.persistent.read().get(prefix, key) } fn compare_and_set( &mut self, prefix: &[u8], key: &[u8], old_value: Option<&[u8]>, ```, 1. `TestPersistentOffchainDB::new()`: Initializes a new `TestPersistentOffchainDB` with an empty in-memory storage. 2. `TestPersistentOffchainDB::apply_offchain_changes()`: Applies a series of `OffchainOverlayedChange` operations to the storage. 3. `TestPersistentOffchainDB::get()`: Retrieves a value associated with a given key from the storage. 4. `impl OffchainStorage for TestPersistentOffchainDB`: Implements the `OffchainStorage` trait for `TestPersistentOffchainDB`, providing methods for setting, removing, getting, and comparing-and-setting key-value pairs in the offchain storage. This allows the test database to be used wherever an `OffchainStorage` is expected.
```

--------------------------------

### Get Trait Implementation for ConstU128 (Option<u128>)

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.ConstU128.html

Implements the Get trait to retrieve the constant value as an Option<u128>.

```rust
impl<const T: u128> Get<Option<u128>> for ConstU128<T>
fn get() -> Option<u128>
```

--------------------------------

### Create OffchainDbExt Instance

Source: https://docs.rs/gp-core/7.0.0/src/gp_core/offchain/mod.rs.html

Provides a constructor for creating a new instance of OffchainDbExt.

```rust
#[cfg(feature = "std")]
impl OffchainDbExt {
	/// Create a new instance of `OffchainDbExt`.
	pub fn new<O: DbExternalities + 'static>(offchain: O) -> Self {
		Self(Box::new(offchain))
	}
}
```

--------------------------------

### impl<T> Get<T> for GetDefault

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.GetDefault.html

Implementation of the Get trait for GetDefault, allowing retrieval of the default value for any type T that implements the Default trait.

```APIDOC
## Trait Implementations

### impl<T> Get<T> for GetDefault

#### fn get() -> T

##### Description
Return the current value.

##### Returns
T - The default value of type T.
```

--------------------------------

### Implement From<Box<dyn ReadRuntimeVersion>> for ReadRuntimeVersionExt

Source: https://docs.rs/gp-core/7.0.0/gp_core/traits/struct.ReadRuntimeVersionExt.html

Enables conversion from a Box<dyn ReadRuntimeVersion> into a ReadRuntimeVersionExt.

```rust
fn from(inner: Box<dyn ReadRuntimeVersion>) -> Self
```

--------------------------------

### Implement Get for GetDefault

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.GetDefault.html

This implementation allows GetDefault to be used with any type T that implements the Default trait. It provides a `get()` method that returns a default instance of T.

```rust
impl<T> Get<T> for GetDefault
where T: Default,
{
    fn get() -> T {
        T::default()
    }
}
```

--------------------------------

### Create Public Key from Full Data

Source: https://docs.rs/gp-core/7.0.0/gp_core/ecdsa/struct.Public.html

Creates a new Public instance by converting a full public key into its compressed format.

```rust
pub fn from_full(full: &[u8]) -> Result<Self, ()>
```

--------------------------------

### Implementing OffchainStorage Trait: Get Operation

Source: https://docs.rs/gp-core/7.0.0/src/gp_core/offchain/storage.rs.html

Implements the `get` method from the `OffchainStorage` trait. This method retrieves a value associated with a given prefix and key from the in-memory storage.

```rust
fn get(&self, prefix: &[u8], key: &[u8]) -> Option<Vec<u8>> {
	let key: Vec<u8> = prefix.iter().chain(key).cloned().collect();
	self.storage.get(&key).cloned()
}

```

--------------------------------

### Get a mutable pointer to the last element

Source: https://docs.rs/gp-core/7.0.0/gp_core/bounded_vec/struct.BoundedVec.html

Use `last_mut` to get a mutable reference to the last element of a slice, returning `None` if the slice is empty. This allows in-place modification of the final element.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_mut() {
    *last = 10;
}
assert_eq!(x, &[0, 1, 10]);
```

--------------------------------

### twox_64_into

Source: https://docs.rs/gp-core/7.0.0/gp_core/hashing/fn.twox_64_into.html

Performs a XX 64-bit hash and places the result in the `dest` buffer. The `data` slice is the input to be hashed.

```APIDOC
## Function gp_core::hashing::twox_64_into

### Description
Do a XX 64-bit hash and place result in `dest`.

### Signature
```rust
pub fn twox_64_into(data: &[u8], dest: &mut [u8; 8])
```

### Parameters
* `data`: A slice of bytes (`&[u8]`) representing the input data to be hashed.
* `dest`: A mutable reference to a byte array of size 8 (`&mut [u8; 8]`) where the 64-bit hash result will be stored.
```

--------------------------------

### Inserting into a Sorted Vector with partition_point

Source: https://docs.rs/gp-core/7.0.0/gp_core/bounded_vec/struct.BoundedSlice.html

Demonstrates how to use `partition_point` to find the correct insertion index for a new element in a sorted vector, maintaining the sort order.

```rust
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x < num);
// The above is equivalent to `let idx = s.binary_search(&num).unwrap_or_else(|x| x);`
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
```

--------------------------------

### Get a mutable pointer to the first element

Source: https://docs.rs/gp-core/7.0.0/gp_core/bounded_vec/struct.BoundedVec.html

Use `first_mut` to get a mutable reference to the first element of a slice, returning `None` if the slice is empty. This allows in-place modification of the first element.

```rust
let x = &mut [0, 1, 2];

if let Some(first) = x.first_mut() {
    *first = 5;
}
assert_eq!(x, &[5, 1, 2]);
```

--------------------------------

### Initiate HTTP Request

Source: https://docs.rs/gp-core/7.0.0/gp_core/offchain/trait.Externalities.html

Starts an HTTP request with the specified method, URI, and optional metadata. Returns a unique `HttpRequestId` for subsequent operations. Errors can occur if the request identifier cannot be allocated or if the method/URI contains invalid characters.

```rust
fn http_request_start(
    &mut self,
    method: &str,
    uri: &str,
    meta: &[u8]
) -> Result<HttpRequestId, ()>;
```

--------------------------------

### Remove Prefix from Slice

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.OpaqueMetadata.html

Returns a subslice with the prefix removed. If the slice starts with the prefix, returns the subslice after the prefix. If the prefix is empty, returns the original slice. Returns None if the slice does not start with the prefix.

```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```

--------------------------------

### strip_prefix

Source: https://docs.rs/gp-core/7.0.0/gp_core/sr25519/struct.Public.html

Returns a subslice with the prefix removed. If the slice starts with prefix, returns the subslice after the prefix, wrapped in Some. If prefix is empty, simply returns the original slice. If the slice does not start with prefix, returns None.

```APIDOC
## pub fn strip_prefix<P>(&self, prefix: &P) -> Option<&[T]>
where P: SlicePattern<Item = T> + ?Sized, T: PartialEq,

### Description
Returns a subslice with the prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix, wrapped in `Some`. If `prefix` is empty, simply returns the original slice. If the slice does not start with `prefix`, returns `None`.

### Parameters
* `prefix`: A pattern representing the prefix to remove.

### Returns
* `Some(&[T])`: If the slice starts with the `prefix`, returns the remaining subslice.
* `None`: If the slice does not start with the `prefix`.

### Examples
```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```
```

--------------------------------

### Constructor Functions

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.H512.html

Functions for creating new H512 instances, including zero-initialized and byte-repeated hashes.

```APIDOC
### `impl H512`

#### `pub const fn repeat_byte(byte: u8) -> H512`
Returns a new fixed hash where all bits are set to the given byte.

#### `pub const fn zero() -> H512`
Returns a new zero-initialized fixed hash.
```

--------------------------------

### Create TestOffchainExt with a specific database

Source: https://docs.rs/gp-core/7.0.0/gp_core/offchain/testing/struct.TestOffchainExt.html

Initializes a new TestOffchainExt with a provided TestPersistentOffchainDB and returns it along with a reference to the internal state. This allows for pre-configured test states.

```rust
pub fn with_offchain_db( offchain_db: TestPersistentOffchainDB ) -> (Self, Arc<RwLock<OffchainState>>)

```

--------------------------------

### H512::type_id

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.H512.html

Gets the `TypeId` of `self`.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.
```

--------------------------------

### Initiate HTTP request

Source: https://docs.rs/gp-core/7.0.0/gp_core/offchain/testing/struct.TestOffchainExt.html

Starts an HTTP request with the specified method, URI, and metadata. Returns a RequestId for tracking the request. This is part of the Externalities trait.

```rust
fn http_request_start( &mut self, method: &str, uri: &str, meta: &[u8] ) -> Result<RequestId, ()

```

--------------------------------

### as_inner_ref

Source: https://docs.rs/gp-core/7.0.0/gp_core/crypto/trait.Wraps.html

Get a reference to the inner type that is wrapped.

```APIDOC
## fn as_inner_ref(&self) -> &Self::Inner

### Description
Get a reference to the inner type that is wrapped.

### Method
`as_inner_ref`

### Parameters
- `&self`: A reference to the object implementing the `Wraps` trait.

### Returns
- `&Self::Inner`: A reference to the inner type.
```

--------------------------------

### Into Implementation

Source: https://docs.rs/gp-core/7.0.0/gp_core/uint/struct.U256.html

Allows converting a type into another type that can be created from it.

```APIDOC
### impl<T, U> Into<U> for T
where U: From<T>,
§
#### fn into(self) -> U
Calls `U::from(self)`.
That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.
source§
```

--------------------------------

### Get slice length

Source: https://docs.rs/gp-core/7.0.0/gp_core/bounded_vec/struct.BoundedSlice.html

Returns the number of elements in the slice.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### keys

Source: https://docs.rs/gp-core/7.0.0/gp_core/bounded_btree_map/struct.BoundedBTreeMap.html

Gets an iterator over all keys in the map, in sorted order.

```APIDOC
## keys

### Description
Gets an iterator over the keys of the map, in sorted order.

### Method
`&self`

### Returns
`Keys<'_, K, V>` - An iterator yielding references to the keys.

### Examples
```rust
use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(2, "b");
a.insert(1, "a");

let keys: Vec<_> = a.keys().cloned().collect();
assert_eq!(keys, [1, 2]);
```
```

--------------------------------

### TryFrom Implementations for U256

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.U256.html

Provides fallible conversion from U512 to U256.

```APIDOC
## fn try_from(value: &'a U512) -> Result<U256, Error>

### Description
Performs the conversion from a reference to U512 to U256.

### Method
`try_from`

### Parameters
- **value**: `&'a U512` - The U512 value to convert.

### Returns
`Result<U256, Error>` - Ok containing the U256 value on success, or an Error on failure.
```

```APIDOC
## fn try_from(value: U512) -> Result<U256, Error>

### Description
Performs the conversion from U512 to U256.

### Method
`try_from`

### Parameters
- **value**: `U512` - The U512 value to convert.

### Returns
`Result<U256, Error>` - Ok containing the U256 value on success, or an Error on failure.
```

--------------------------------

### iter

Source: https://docs.rs/gp-core/7.0.0/gp_core/bounded_btree_map/struct.BoundedBTreeMap.html

Gets an iterator over all entries in the map, sorted by key.

```APIDOC
## iter

### Description
Gets an iterator over the entries of the map, sorted by key.

### Method
`&self`

### Returns
`Iter<'_, K, V>` - An iterator yielding references to key-value pairs.

### Examples
```rust
use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(3, "c");
map.insert(2, "b");
map.insert(1, "a");

for (key, value) in map.iter() {
    println!(ירת{key}: {value});
}

let (first_key, first_value) = map.iter().next().unwrap();
assert_eq!((*first_key, *first_value), (1, "a"));
```
```

--------------------------------

### Initiate HTTP Request

Source: https://docs.rs/gp-core/7.0.0/gp_core/offchain/struct.LimitedExternalities.html

Implements the `http_request_start` method for `LimitedExternalities` when the inner type `T` implements `Externalities`. This initiates an HTTP request with the specified method and URI, returning a unique `HttpRequestId`.

```rust
fn http_request_start( &mut self, method: &str, uri: &str, meta: &[u8] ) -> Result<HttpRequestId, ()>
```

--------------------------------

### Initialize TestOffchainExt

Source: https://docs.rs/gp-core/7.0.0/src/gp_core/offchain/testing.rs.html

Creates a new `TestOffchainExt` instance and returns it along with a reference to the internal `OffchainState`. This is useful for setting up tests that interact with offchain functionalities.

```rust
let (ext, state) = TestOffchainExt::new();
```

--------------------------------

### from_ref

Source: https://docs.rs/gp-core/7.0.0/gp_core/crypto/struct.SecretUri.html

Gets a reference to the inner value from an outer wrapper.

```APIDOC
## fn from_ref(outer: &Outer) -> &T

### Description
Get a reference to the inner from the outer.

### Method
`IsWrappedBy::from_ref`
```

--------------------------------

### TestOffchainExt::new

Source: https://docs.rs/gp-core/7.0.0/gp_core/offchain/testing/struct.TestOffchainExt.html

Creates a new TestOffchainExt instance and returns a reference to its internal state.

```APIDOC
## TestOffchainExt::new

### Description
Creates new `TestOffchainExt` and a reference to the internal state.

### Signature
```rust
pub fn new() -> (Self, Arc<RwLock<OffchainState>>)
```
```

--------------------------------

### Pointer Accessors

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.H512.html

Functions to get raw pointers to the H512 data.

```APIDOC
### `impl H512`

#### `pub fn as_ptr(&self) -> *const u8`
Returns a constant raw pointer to the value.

#### `pub fn as_mut_ptr(&mut self) -> *mut u8`
Returns a mutable raw pointer to the value.
```

--------------------------------

### join

Source: https://docs.rs/gp-core/7.0.0/gp_core/traits/trait.RuntimeSpawn.html

Joins the result of a previously created runtime instance invocation using its handle.

```APIDOC
## fn join(&self, handle: u64) -> Vec<u8>

### Description
Join the result of previously created runtime instance invocation.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **handle** (u64) - Required - The handle of the spawned task to join.

### Response
#### Success Response (Vec<u8>)
- Returns the result of the invocation as a Vec<u8>.
```

--------------------------------

### Create Public Key from Raw Data

Source: https://docs.rs/gp-core/7.0.0/src/gp_core/ed25519.rs.html

Initializes a Public key from a 32-byte array. Assumes the input data represents a valid public key.

```rust
pub fn from_raw(data: [u8; 32]) -> Self {
		Public(data)
	}
```

--------------------------------

### IsWrappedBy

Source: https://docs.rs/gp-core/7.0.0/gp_core/sr25519/struct.Pair.html

Provides methods to get inner references from a wrapper type.

```APIDOC
## impl<T, Outer> IsWrappedBy<Outer> for T

### fn from_ref(outer: &Outer) -> &T

#### Description
Get a reference to the inner value from the outer wrapper.

#### Returns
A reference to the inner value.
```

```APIDOC
### fn from_mut(outer: &mut Outer) -> &mut T

#### Description
Get a mutable reference to the inner value from the outer wrapper.

#### Returns
A mutable reference to the inner value.
```

--------------------------------

### Into Implementation

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.U256.html

Provides a conversion from T to U if U implements From<T>.

```APIDOC
## impl<T, U> Into<U> for T
where U: From<T>,

### fn into(self) -> U
Calls `U::from(self)`.
That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

```

--------------------------------

### type_id

Source: https://docs.rs/gp-core/7.0.0/gp_core/sr25519/struct.Pair.html

Gets the TypeId of the Pair. This is a utility function for type introspection.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Returns
A `TypeId` representing the type of the Pair.
```

--------------------------------

### Default Trait Implementation

Source: https://docs.rs/gp-core/7.0.0/gp_core/struct.ConstI32.html

Shows how to get the default value for ConstI32.

```APIDOC
### impl<const T: i32> Default for ConstI32<T>

#### fn default() -> ConstI32<T>
Returns the “default value” for a type.
```
Tokens:
Raw