Struct Runtime 

pub struct Runtime {
    pub spec_version: u32,
    pub transaction_version: u32,
    pub ss58_format: u16,
    pub is_v15: bool,
    pub metadata_bytes: Vec<u8>,
    pub types: PortableRegistry,
    pub pallets: Vec<PalletInfo>,
    pub extrinsic: ExtrinsicInfo,
    pub apis: Vec<RuntimeApiInfo>,
    pub outer_event_type: Option<u32>,
    /* private fields */
}

One runtime’s complete metadata view.

Fields

spec_version: u32

transaction_version: u32

ss58_format: u16

is_v15: bool

metadata_bytes: Vec<u8>

The raw MetadataVersioned blob this was parsed from (fed to the RFC-0078 digest without re-downloading).

types: PortableRegistry

pallets: Vec<PalletInfo>

extrinsic: ExtrinsicInfo

apis: Vec<RuntimeApiInfo>

outer_event_type: Option<u32>

The outer RuntimeEvent enum type id (drives the flattened event shape).

Implementations

impl Runtime

pub fn decode_batch( &self, type_strings: &[String], datas: &[Vec<u8>], ) -> Result<Vec<Value>, CoreError>

Decode a batch of (type string, SCALE bytes) pairs. Consecutive duplicate type strings (the common case: one storage item’s page) resolve to a spec once.

pub fn decode_map_page( &self, entry: &StorageInfo, raw_keys: &[Vec<u8>], raw_values: &[Vec<u8>], fixed: usize, ) -> Result<Vec<DecodedPair>, CoreError>

Decode one page of a storage map: recover the free key components from each full storage key (fixed leading params were part of the queried prefix) and decode each value.

pub fn decode_map_changes( &self, entry: &StorageInfo, changes: &[(String, Option<String>)], fixed: usize, ) -> Result<Vec<DecodedPair>, CoreError>

Like Runtime::decode_map_page, but takes the raw state_queryStorageAt change tuples (0x-hex key/value strings; None values — keys deleted between the key listing and the value fetch — are skipped), so hex parsing also runs in the parallel section.

impl Runtime

pub fn decode_spec( &self, spec: &TypeSpec, data: &[u8], strict: bool, ) -> Result<Value, CoreError>

Decode data as the given type spec; errors on trailing bytes when strict.

pub fn decode_value( &self, spec: &TypeSpec, cursor: &mut Cursor<'_>, ) -> Result<Value, CoreError>

pub fn decode_id( &self, id: u32, cursor: &mut Cursor<'_>, ) -> Result<Value, CoreError>

Decode one registry type. The special cases (paths with pinned renderings) come before the structural rules.

pub fn decode_call_value( &self, cursor: &mut Cursor<'_>, ) -> Result<Value, CoreError>

The runtime’s outer Call in cyscale’s metadata-aware shape: {call_index, call_function, call_module, call_args: [{name, type, value}], call_hash}.

impl Runtime

pub fn encode_spec( &self, spec: &TypeSpec, value: &Value, ) -> Result<Vec<u8>, CoreError>

pub fn encode_value( &self, spec: &TypeSpec, value: &Value, out: &mut Vec<u8>, ) -> Result<(), CoreError>

pub fn encode_id( &self, id: u32, value: &Value, out: &mut Vec<u8>, ) -> Result<(), CoreError>

pub fn encode_era_value( &self, value: &Value, out: &mut Vec<u8>, ) -> Result<(), CoreError>

Era inputs: "00" (immortal), 0/None-like handled by caller, or {"period": N, "current": M} / {"period": N, "phase": P}.

pub fn coerce_account_id(&self, value: &Value) -> Result<[u8; 32], CoreError>

Coerce the seam’s account-id inputs to raw key bytes: ss58 strings, 0x-hex strings, or raw 32 bytes.

pub fn compose_call( &self, pallet: &str, function: &str, params: &Value, ) -> Result<Vec<u8>, CoreError>

Compose a call: (pallet, function, params) -> raw SCALE call bytes.

Param values may embed pre-composed calls as Value::Bytes (Sudo, batches, proxies); they splice in verbatim.

impl Runtime

pub fn signature_payload_parts( &self, params: &TxParams, ) -> Result<(Vec<u8>, Vec<u8>), CoreError>

The signature payload split at its wire seams: (included_in_extrinsic, included_in_signed_data). Prepending the raw call bytes gives the exact unhashed payload; hardware signers that prove the runtime on-device need the parts separately.

pub fn signature_payload( &self, call_data: &[u8], params: &TxParams, ) -> Result<Vec<u8>, CoreError>

The exact bytes a signer signs for the given raw call. Payloads longer than 256 bytes are blake2b-256 hashed, per the Substrate convention.

pub fn encode_signed_extrinsic( &self, call_data: &[u8], public_key: [u8; 32], signature: &[u8], signature_version: u8, params: &TxParams, ) -> Result<(Vec<u8>, [u8; 32]), CoreError>

Assemble the full signed extrinsic; returns (bytes, hash).

The metadata-hash mode must match what the payload was signed with (the digest itself is implied data and never travels in the extrinsic — set params.metadata_hash accordingly).

pub fn supports_mldsa_profile(&self, profile: u8) -> bool

Detect the explicit ML-DSA registration variant on the original call. Presence of HashedAccounts alone does not imply ML-DSA support.

pub fn supports_mldsa_accounts(&self) -> bool

pub fn decode_extrinsic( &self, data: &[u8], strict: bool, ) -> Result<Value, CoreError>

Decode one raw extrinsic into cyscale’s plain value dict: {extrinsic_hash, extrinsic_length, [address, signature, era, nonce, tip, mode,] call}.

impl Runtime

pub fn storage_key( &self, entry: &StorageInfo, params: &[Value], ) -> Result<Vec<u8>, CoreError>

The full storage key for one item; params may be a partial prefix (for map iteration).

pub fn decode_storage_key_params( &self, entry: &StorageInfo, key: &[u8], fixed: usize, ) -> Result<Vec<Value>, CoreError>

Recover the free map-key components from one full storage key.

fixed is how many leading params were fixed in the queried prefix; the remaining components decode from the key’s trailing bytes (reversible hashers only).

impl Runtime

pub fn type_spec(&self, type_string: &str) -> Result<TypeSpec, CoreError>

Resolve a type string to a spec, preferring structural parses over the registry name map so Vec<u8> and Option<...> always mean the same thing regardless of which names this runtime’s registry produces.

impl Runtime

pub fn parse( metadata_bytes: &[u8], spec_version: u32, transaction_version: u32, ss58_format: u16, ) -> Result<Self, CoreError>

Parse a raw MetadataVersioned blob (magic meta + version byte + V14/V15 payload — what state_getMetadata / Metadata_metadata_at_version return, unwrapped).

pub fn pallet(&self, name: &str) -> Option<&PalletInfo>

pub fn pallet_at(&self, index: u8) -> Option<&PalletInfo>

pub fn storage_entry(&self, pallet: &str, name: &str) -> Option<&StorageInfo>

pub fn constant(&self, pallet: &str, name: &str) -> Option<&ConstantInfo>

pub fn type_id_of(&self, name: &str) -> Option<u32>

pub fn type_name_of(&self, id: u32) -> Option<&str>

pub fn resolve(&self, id: u32) -> Result<&Type<PortableForm>, CoreError>

pub fn type_ident(&self, id: u32) -> String

A short, human-facing identity for a registry type: the last segment of its path (e.g. “TaoBalance”, “NetUid”, “AccountId32”), with Option’s payload kept (Option<Timepoint>). Path-less types render structurally: “u64”, “Vec”, “[u8; 32]”, “(u16, u16)”, “Compact”.

This is what the codegen IR carries per call parameter, so generated builders can surface newtype identity (a TaoBalance argument vs a bare u64) even though the wire encoding is the inner value.

pub fn registry_json(&self) -> Result<String, CoreError>

The portable registry as JSON ({"types": [{"id", "type": {...}}]}).

For registry-walking tooling (the shape-corpus recorder); not a hot path.

pub fn module_error( &self, module_index: u8, error_index: u8, ) -> Result<(String, Vec<String>), CoreError>

{"type": "Module", "name", "docs"} inputs for a dispatch module error.