#[derive(Encode, Decode)]

	/// Incorrect value of R or S

	BadRS,

	/// Incorrect value of V

	BadV,

	/// Invalid signature

	BadSignature,

#[derive(PassByCodec, Encode, Decode)]

	/// All keys to remove were removed, return number of iterations performed during the

	AllRemoved(u32),

	/// Not all key to remove were removed, return number of iterations performed during the

	SomeRemaining(u32),

			Some(..) => Self::SomeRemaining(r.loops),

#[runtime_interface]

	/// Clear the storage of each key-value pair where the key starts with the given `prefix`.

	fn clear_prefix(&mut self, prefix: &[u8]) {

		let _ = Externalities::clear_prefix(*self, prefix, None, None);

	}

	/// Partially clear the storage of each key-value pair where the key starts with the given

	fn clear_prefix(

		&mut self,

		maybe_prefix: &[u8],

		maybe_limit: Option<u32>,

		maybe_cursor: Option<Vec<u8>>, //< TODO Make work or just Option<Vec<u8>>?

	) -> MultiRemovalResults {

		Externalities::clear_prefix(

			*self,

			maybe_prefix,

			maybe_limit,

			maybe_cursor.as_ref().map(|x| &x[..]),

		)

		.into()

	}

	/// "Commit" all existing operations and compute the resulting storage root.

	fn root(&mut self) -> Vec<u8> {

		self.storage_root(StateVersion::V0)

	}

	/// Always returns `None`. This function exists for compatibility reasons.

	fn changes_root(&mut self, _parent_hash: &[u8]) -> Option<Vec<u8>> {

		None

	}

#[runtime_interface]

	/// Get a default child storage value for a given key.

	///

	/// Parameter `storage_key` is the unprefixed location of the root of the child trie in the

	/// parent trie. Result is `None` if the value for `key` in the child storage can not be found.

	fn get(&mut self, storage_key: &[u8], key: &[u8]) -> Option<Vec<u8>> {

		let child_info = ChildInfo::new_default(storage_key);

		self.child_storage(&child_info, key).map(|s| s.to_vec())

	}

	/// Allocation efficient variant of `get`.

	///

	/// Get `key` from child storage, placing the value into `value_out` and return the number

	/// of bytes that the entry in storage has beyond the offset or `None` if the storage entry

	/// doesn't exist at all.

	/// If `value_out` length is smaller than the returned length, only `value_out` length bytes

	/// are copied into `value_out`.

	fn read(

		&mut self,

		storage_key: &[u8],

		key: &[u8],

		value_out: &mut [u8],

		value_offset: u32,

	) -> Option<u32> {

		let child_info = ChildInfo::new_default(storage_key);

		self.child_storage(&child_info, key).map(|value| {

			let value_offset = value_offset as usize;

			let data = &value[value_offset.min(value.len())..];

			let written = std::cmp::min(data.len(), value_out.len());

			value_out[..written].copy_from_slice(&data[..written]);

			data.len() as u32

		})

	}

	/// Set a child storage value.

	///

	/// Set `key` to `value` in the child storage denoted by `storage_key`.

	fn set(&mut self, storage_key: &[u8], key: &[u8], value: &[u8]) {

		let child_info = ChildInfo::new_default(storage_key);

		self.set_child_storage(&child_info, key.to_vec(), value.to_vec());

	}

	/// Clear a child storage key.

	///

	/// For the default child storage at `storage_key`, clear value at `key`.

	fn clear(&mut self, storage_key: &[u8], key: &[u8]) {

		let child_info = ChildInfo::new_default(storage_key);

		self.clear_child_storage(&child_info, key);

	}

	/// Clear an entire child storage.

	fn storage_kill(&mut self, storage_key: &[u8]) {

		let child_info = ChildInfo::new_default(storage_key);

		let _ = self.kill_child_storage(&child_info, None, None);

	}

	/// Clear a child storage key.

	fn storage_kill(&mut self, storage_key: &[u8], limit: Option<u32>) -> bool {

		let child_info = ChildInfo::new_default(storage_key);

		let r = self.kill_child_storage(&child_info, limit, None);

		r.maybe_cursor.is_none()

	}

	/// Clear a child storage key.

	///

	/// See `Storage` module `clear_prefix` documentation for `limit` usage.

	#[version(3)]

	fn storage_kill(&mut self, storage_key: &[u8], limit: Option<u32>) -> KillStorageResult {

		let child_info = ChildInfo::new_default(storage_key);

		self.kill_child_storage(&child_info, limit, None).into()

	}

	/// Clear a child storage key.

	fn storage_kill(

		&mut self,

		storage_key: &[u8],

		maybe_limit: Option<u32>,

		maybe_cursor: Option<Vec<u8>>,

	) -> MultiRemovalResults {

		let child_info = ChildInfo::new_default(storage_key);

		self.kill_child_storage(&child_info, maybe_limit, maybe_cursor.as_ref().map(|x| &x[..]))

			.into()

	}

	/// Check a child storage key.

	///

	/// Check whether the given `key` exists in default child defined at `storage_key`.

	fn exists(&mut self, storage_key: &[u8], key: &[u8]) -> bool {

		let child_info = ChildInfo::new_default(storage_key);

		self.exists_child_storage(&child_info, key)

	}

	/// Clear child default key by prefix.

	fn clear_prefix(&mut self, storage_key: &[u8], prefix: &[u8]) {

		let child_info = ChildInfo::new_default(storage_key);

		let _ = self.clear_child_prefix(&child_info, prefix, None, None);

	}

	/// Clear the child storage of each key-value pair where the key starts with the given `prefix`.

	///

	/// See `Storage` module `clear_prefix` documentation for `limit` usage.

	#[version(2)]

	fn clear_prefix(

		&mut self,

		storage_key: &[u8],

		prefix: &[u8],

		limit: Option<u32>,

	) -> KillStorageResult {

		let child_info = ChildInfo::new_default(storage_key);

		self.clear_child_prefix(&child_info, prefix, limit, None).into()

	}

	/// Clear the child storage of each key-value pair where the key starts with the given `prefix`.

	fn clear_prefix(

		&mut self,

		storage_key: &[u8],

		prefix: &[u8],

		maybe_limit: Option<u32>,

		maybe_cursor: Option<Vec<u8>>,

	) -> MultiRemovalResults {

		let child_info = ChildInfo::new_default(storage_key);

		self.clear_child_prefix(

			&child_info,

			prefix,

			maybe_limit,

			maybe_cursor.as_ref().map(|x| &x[..]),

		)

		.into()

	}

	/// Default child root calculation.

	fn root(&mut self, storage_key: &[u8]) -> Vec<u8> {

		let child_info = ChildInfo::new_default(storage_key);

		self.child_storage_root(&child_info, StateVersion::V0)

	}

	/// Default child root calculation.

	///

	/// "Commit" all existing operations and compute the resulting child storage root.

	/// The hashing algorithm is defined by the `Block`.

	///

	/// Returns a `Vec<u8>` that holds the SCALE encoded hash.

	#[version(2)]

	fn root(&mut self, storage_key: &[u8], version: StateVersion) -> Vec<u8> {

		let child_info = ChildInfo::new_default(storage_key);

		self.child_storage_root(&child_info, version)

	}

	/// Child storage key iteration.

	///

	/// Get the next key in storage after the given one in lexicographic order in child storage.

	fn next_key(&mut self, storage_key: &[u8], key: &[u8]) -> Option<Vec<u8>> {

		let child_info = ChildInfo::new_default(storage_key);

		self.next_child_storage_key(&child_info, key)

	}

#[runtime_interface]

	/// A trie root formed from the iterated items.

	fn blake2_256_root(input: Vec<(Vec<u8>, Vec<u8>)>) -> H256 {

		LayoutV0::<sp_core::Blake2Hasher>::trie_root(input)

	}

	/// A trie root formed from the iterated items.

	#[version(2)]

	fn blake2_256_root(input: Vec<(Vec<u8>, Vec<u8>)>, version: StateVersion) -> H256 {

		match version {

			StateVersion::V0 => LayoutV0::<sp_core::Blake2Hasher>::trie_root(input),

			StateVersion::V1 => LayoutV1::<sp_core::Blake2Hasher>::trie_root(input),

		}

	}

	/// A trie root formed from the enumerated items.

	fn blake2_256_ordered_root(input: Vec<Vec<u8>>) -> H256 {

		LayoutV0::<sp_core::Blake2Hasher>::ordered_trie_root(input)

	}

	/// A trie root formed from the iterated items.

	fn keccak_256_root(input: Vec<(Vec<u8>, Vec<u8>)>) -> H256 {

		LayoutV0::<sp_core::KeccakHasher>::trie_root(input)

	}

	/// A trie root formed from the iterated items.

	#[version(2)]

	fn keccak_256_root(input: Vec<(Vec<u8>, Vec<u8>)>, version: StateVersion) -> H256 {

		match version {

			StateVersion::V0 => LayoutV0::<sp_core::KeccakHasher>::trie_root(input),

			StateVersion::V1 => LayoutV1::<sp_core::KeccakHasher>::trie_root(input),

		}

	}

	/// A trie root formed from the enumerated items.

	fn keccak_256_ordered_root(input: Vec<Vec<u8>>) -> H256 {

		LayoutV0::<sp_core::KeccakHasher>::ordered_trie_root(input)

	}

	/// A trie root formed from the enumerated items.

	#[version(2)]

	fn keccak_256_ordered_root(input: Vec<Vec<u8>>, version: StateVersion) -> H256 {

		match version {

			StateVersion::V0 => LayoutV0::<sp_core::KeccakHasher>::ordered_trie_root(input),

			StateVersion::V1 => LayoutV1::<sp_core::KeccakHasher>::ordered_trie_root(input),

		}

	}

	/// Verify trie proof

	fn blake2_256_verify_proof(root: H256, proof: &[Vec<u8>], key: &[u8], value: &[u8]) -> bool {

		sp_trie::verify_trie_proof::<LayoutV0<sp_core::Blake2Hasher>, _, _, _>(

			&root,

			proof,

			&[(key, Some(value))],

		)

		.is_ok()

	}

	/// Verify trie proof

	#[version(2)]

	fn blake2_256_verify_proof(

		root: H256,

		proof: &[Vec<u8>],

		key: &[u8],

		value: &[u8],

		version: StateVersion,

	) -> bool {

		match version {

			StateVersion::V0 => sp_trie::verify_trie_proof::<

				LayoutV0<sp_core::Blake2Hasher>,

				_,

				_,

				_,

			>(&root, proof, &[(key, Some(value))])

			.is_ok(),

			StateVersion::V1 => sp_trie::verify_trie_proof::<

				LayoutV1<sp_core::Blake2Hasher>,

				_,

				_,

				_,

			>(&root, proof, &[(key, Some(value))])

			.is_ok(),

		}

	}

	/// Verify trie proof

	fn keccak_256_verify_proof(root: H256, proof: &[Vec<u8>], key: &[u8], value: &[u8]) -> bool {

		sp_trie::verify_trie_proof::<LayoutV0<sp_core::KeccakHasher>, _, _, _>(

			&root,

			proof,

			&[(key, Some(value))],

		)

		.is_ok()

	}

	/// Verify trie proof

	#[version(2)]

	fn keccak_256_verify_proof(

		root: H256,

		proof: &[Vec<u8>],

		key: &[u8],

		value: &[u8],

		version: StateVersion,

	) -> bool {

		match version {

			StateVersion::V0 => sp_trie::verify_trie_proof::<

				LayoutV0<sp_core::KeccakHasher>,

				_,

				_,

				_,

			>(&root, proof, &[(key, Some(value))])

			.is_ok(),

			StateVersion::V1 => sp_trie::verify_trie_proof::<

				LayoutV1<sp_core::KeccakHasher>,

				_,

				_,

				_,

			>(&root, proof, &[(key, Some(value))])

			.is_ok(),

		}

	}

#[runtime_interface]

	/// Print a number.

	fn print_num(val: u64) {

		log::debug!(target: "runtime", "{}", val);

	}

	/// Print any valid `utf8` buffer.

	fn print_utf8(utf8: &[u8]) {

		if let Ok(data) = std::str::from_utf8(utf8) {

			log::debug!(target: "runtime", "{}", data)

		}

	}

	/// Print any `u8` slice as hex.

	fn print_hex(data: &[u8]) {

		log::debug!(target: "runtime", "{}", HexDisplay::from(&data));

	}

	/// Extract the runtime version of the given wasm blob by calling `Core_version`.

	///

	/// Returns `None` if calling the function failed for any reason or `Some(Vec<u8>)` where

	/// the `Vec<u8>` holds the SCALE encoded runtime version.

	///

	/// # Performance

	///

	/// This function may be very expensive to call depending on the wasm binary. It may be

	/// relatively cheap if the wasm binary contains version information. In that case,

	/// uncompression of the wasm blob is the dominating factor.

	///

	/// If the wasm binary does not have the version information attached, then a legacy mechanism

	/// may be involved. This means that a runtime call will be performed to query the version.

	///

	/// Calling into the runtime may be incredible expensive and should be approached with care.

	fn runtime_version(&mut self, wasm: &[u8]) -> Option<Vec<u8>> {

		use sp_core::traits::ReadRuntimeVersionExt;

		let mut ext = sp_state_machine::BasicExternalities::default();

		match self

			.extension::<ReadRuntimeVersionExt>()

			.expect("No `ReadRuntimeVersionExt` associated for the current context!")

			.read_runtime_version(wasm, &mut ext)

		{

			Ok(v) => Some(v),

			Err(err) => {

				log::debug!(

					target: LOG_TARGET,

					"cannot read version from the given runtime: {}",

					err,

				);

				None

			},

		}

	}

	fn default() -> Self {

		Self

	}

#[runtime_interface]

	/// Returns all `ed25519` public keys for the given key id from the keystore.

	fn ed25519_public_keys(&mut self, id: KeyTypeId) -> Vec<ed25519::Public> {

		self.extension::<KeystoreExt>()

			.expect("No `keystore` associated for the current context!")

			.ed25519_public_keys(id)

	}

	/// Generate an `ed22519` key for the given key type using an optional `seed` and

	/// store it in the keystore.

	///

	/// The `seed` needs to be a valid utf8.

	///

	/// Returns the public key.

	fn ed25519_generate(&mut self, id: KeyTypeId, seed: Option<Vec<u8>>) -> ed25519::Public {

		let seed = seed.as_ref().map(|s| std::str::from_utf8(s).expect("Seed is valid utf8!"));

		self.extension::<KeystoreExt>()

			.expect("No `keystore` associated for the current context!")

			.ed25519_generate_new(id, seed)

			.expect("`ed25519_generate` failed")

	}

	/// Sign the given `msg` with the `ed25519` key that corresponds to the given public key and

	/// key type in the keystore.

	///

	/// Returns the signature.

	fn ed25519_sign(

		&mut self,

		id: KeyTypeId,

		pub_key: &ed25519::Public,

		msg: &[u8],

	) -> Option<ed25519::Signature> {

		self.extension::<KeystoreExt>()

			.expect("No `keystore` associated for the current context!")

			.ed25519_sign(id, pub_key, msg)

			.ok()

			.flatten()

	}

			public_key.verify(msg, &sig).is_ok()

	/// Register a `ed25519` signature for batch verification.

	fn ed25519_batch_verify(

		&mut self,

		sig: &ed25519::Signature,

		msg: &[u8],

		pub_key: &ed25519::Public,

	) -> bool {

		let res = ed25519_verify(sig, msg, pub_key);

		if let Some(ext) = self.extension::<VerificationExtDeprecated>() {

			ext.0 &= res;

		}

		res

	}

	/// Verify `sr25519` signature.

	///

	/// Returns `true` when the verification was successful.

	#[version(2)]

	fn sr25519_verify(sig: &sr25519::Signature, msg: &[u8], pub_key: &sr25519::Public) -> bool {

		sr25519::Pair::verify(sig, msg, pub_key)

	}

	/// Register a `sr25519` signature for batch verification.

	fn sr25519_batch_verify(

		&mut self,

		sig: &sr25519::Signature,

		msg: &[u8],

		pub_key: &sr25519::Public,

	) -> bool {

		let res = sr25519_verify(sig, msg, pub_key);

		if let Some(ext) = self.extension::<VerificationExtDeprecated>() {

			ext.0 &= res;

		}

		res

	}

	/// Start verification extension.

	fn start_batch_verify(&mut self) {

		self.register_extension(VerificationExtDeprecated(true))

			.expect("Failed to register required extension: `VerificationExt`");

	}

	/// Finish batch-verification of signatures.

	fn finish_batch_verify(&mut self) -> bool {

		let result = self

			.extension::<VerificationExtDeprecated>()

			.expect("`finish_batch_verify` should only be called after `start_batch_verify`")

			.0;

		self.deregister_extension::<VerificationExtDeprecated>()

			.expect("No verification extension in current context!");

		result

	}

	/// Returns all `sr25519` public keys for the given key id from the keystore.

	fn sr25519_public_keys(&mut self, id: KeyTypeId) -> Vec<sr25519::Public> {

		self.extension::<KeystoreExt>()

			.expect("No `keystore` associated for the current context!")

			.sr25519_public_keys(id)

	}

	/// Generate an `sr22519` key for the given key type using an optional seed and

	/// store it in the keystore.

	///

	/// The `seed` needs to be a valid utf8.

	///

	/// Returns the public key.

	fn sr25519_generate(&mut self, id: KeyTypeId, seed: Option<Vec<u8>>) -> sr25519::Public {

		let seed = seed.as_ref().map(|s| std::str::from_utf8(s).expect("Seed is valid utf8!"));

		self.extension::<KeystoreExt>()

			.expect("No `keystore` associated for the current context!")

			.sr25519_generate_new(id, seed)

			.expect("`sr25519_generate` failed")

	}

	/// Sign the given `msg` with the `sr25519` key that corresponds to the given public key and

	/// key type in the keystore.

	///

	/// Returns the signature.

	fn sr25519_sign(

		&mut self,

		id: KeyTypeId,

		pub_key: &sr25519::Public,

		msg: &[u8],

	) -> Option<sr25519::Signature> {

		self.extension::<KeystoreExt>()

			.expect("No `keystore` associated for the current context!")

			.sr25519_sign(id, pub_key, msg)

			.ok()

			.flatten()

	}

	/// Verify an `sr25519` signature.

	fn sr25519_verify(sig: &sr25519::Signature, msg: &[u8], pubkey: &sr25519::Public) -> bool {

		sr25519::Pair::verify_deprecated(sig, msg, pubkey)

	}

	/// Returns all `ecdsa` public keys for the given key id from the keystore.

	fn ecdsa_public_keys(&mut self, id: KeyTypeId) -> Vec<ecdsa::Public> {

		self.extension::<KeystoreExt>()

			.expect("No `keystore` associated for the current context!")

			.ecdsa_public_keys(id)

	}

	/// Generate an `ecdsa` key for the given key type using an optional `seed` and

	/// store it in the keystore.

	///

	/// The `seed` needs to be a valid utf8.

	///

	/// Returns the public key.

	fn ecdsa_generate(&mut self, id: KeyTypeId, seed: Option<Vec<u8>>) -> ecdsa::Public {

		let seed = seed.as_ref().map(|s| std::str::from_utf8(s).expect("Seed is valid utf8!"));

		self.extension::<KeystoreExt>()

			.expect("No `keystore` associated for the current context!")

			.ecdsa_generate_new(id, seed)

			.expect("`ecdsa_generate` failed")

	}

	/// Sign the given `msg` with the `ecdsa` key that corresponds to the given public key and

	/// key type in the keystore.

	///

	/// Returns the signature.

	fn ecdsa_sign(

		&mut self,

		id: KeyTypeId,

		pub_key: &ecdsa::Public,

		msg: &[u8],

	) -> Option<ecdsa::Signature> {

		self.extension::<KeystoreExt>()

			.expect("No `keystore` associated for the current context!")

			.ecdsa_sign(id, pub_key, msg)

			.ok()

			.flatten()

	}

	/// Sign the given a pre-hashed `msg` with the `ecdsa` key that corresponds to the given public

	/// key and key type in the keystore.

	///

	/// Returns the signature.

	fn ecdsa_sign_prehashed(

		&mut self,

		id: KeyTypeId,

		pub_key: &ecdsa::Public,

		msg: &[u8; 32],

	) -> Option<ecdsa::Signature> {

		self.extension::<KeystoreExt>()

			.expect("No `keystore` associated for the current context!")

			.ecdsa_sign_prehashed(id, pub_key, msg)

			.ok()

			.flatten()

	}

	/// Verify `ecdsa` signature.

	fn ecdsa_verify(sig: &ecdsa::Signature, msg: &[u8], pub_key: &ecdsa::Public) -> bool {

		#[allow(deprecated)]

		ecdsa::Pair::verify_deprecated(sig, msg, pub_key)

	}

	/// Verify `ecdsa` signature.

	///

	/// Returns `true` when the verification was successful.

	#[version(2)]

	fn ecdsa_verify(sig: &ecdsa::Signature, msg: &[u8], pub_key: &ecdsa::Public) -> bool {

		ecdsa::Pair::verify(sig, msg, pub_key)

	}

	/// Verify `ecdsa` signature with pre-hashed `msg`.

	///

	/// Returns `true` when the verification was successful.

	fn ecdsa_verify_prehashed(

		sig: &ecdsa::Signature,

		msg: &[u8; 32],

		pub_key: &ecdsa::Public,

	) -> bool {

		ecdsa::Pair::verify_prehashed(sig, msg, pub_key)

	}

	/// Register a `ecdsa` signature for batch verification.

	fn ecdsa_batch_verify(

		&mut self,

		sig: &ecdsa::Signature,

		msg: &[u8],

		pub_key: &ecdsa::Public,

	) -> bool {

		let res = ecdsa_verify(sig, msg, pub_key);

		if let Some(ext) = self.extension::<VerificationExtDeprecated>() {

			ext.0 &= res;

		}

		res

	}

	/// Verify and recover a SECP256k1 ECDSA signature.

	fn secp256k1_ecdsa_recover(

		sig: &[u8; 65],

		msg: &[u8; 32],

	) -> Result<[u8; 64], EcdsaVerifyError> {

		let rid = libsecp256k1::RecoveryId::parse(

			if sig[64] > 26 { sig[64] - 27 } else { sig[64] } as u8,

		.map_err(|_| EcdsaVerifyError::BadV)?;

		let sig = libsecp256k1::Signature::parse_overflowing_slice(&sig[..64])

			.map_err(|_| EcdsaVerifyError::BadRS)?;

		let msg = libsecp256k1::Message::parse(msg);

		let pubkey =

			libsecp256k1::recover(&msg, &sig, &rid).map_err(|_| EcdsaVerifyError::BadSignature)?;

		let mut res = [0u8; 64];

		res.copy_from_slice(&pubkey.serialize()[1..65]);

		Ok(res)

	}

	/// Verify and recover a SECP256k1 ECDSA signature.

	///

	/// - `sig` is passed in RSV format. V should be either `0/1` or `27/28`.

	/// - `msg` is the blake2-256 hash of the message.

	///

	/// Returns `Err` if the signature is bad, otherwise the 64-byte pubkey

	/// (doesn't include the 0x04 prefix).

	#[version(2)]

	fn secp256k1_ecdsa_recover(

		sig: &[u8; 65],

		msg: &[u8; 32],

	) -> Result<[u8; 64], EcdsaVerifyError> {

		let rid = RecoveryId::from_i32(if sig[64] > 26 { sig[64] - 27 } else { sig[64] } as i32)

			.map_err(|_| EcdsaVerifyError::BadV)?;

		let sig = RecoverableSignature::from_compact(&sig[..64], rid)

			.map_err(|_| EcdsaVerifyError::BadRS)?;

		let msg = Message::from_digest_slice(msg).expect("Message is 32 bytes; qed");

		let pubkey = SECP256K1

			.recover_ecdsa(&msg, &sig)

			.map_err(|_| EcdsaVerifyError::BadSignature)?;

		let mut res = [0u8; 64];

		res.copy_from_slice(&pubkey.serialize_uncompressed()[1..]);

		Ok(res)

	}

	/// Verify and recover a SECP256k1 ECDSA signature.

	fn secp256k1_ecdsa_recover_compressed(

		sig: &[u8; 65],

		msg: &[u8; 32],

	) -> Result<[u8; 33], EcdsaVerifyError> {

		let rid = libsecp256k1::RecoveryId::parse(

			if sig[64] > 26 { sig[64] - 27 } else { sig[64] } as u8,

		.map_err(|_| EcdsaVerifyError::BadV)?;

		let sig = libsecp256k1::Signature::parse_overflowing_slice(&sig[0..64])

			.map_err(|_| EcdsaVerifyError::BadRS)?;

		let msg = libsecp256k1::Message::parse(msg);

		let pubkey =

			libsecp256k1::recover(&msg, &sig, &rid).map_err(|_| EcdsaVerifyError::BadSignature)?;

		Ok(pubkey.serialize_compressed())

	}

	/// Verify and recover a SECP256k1 ECDSA signature.

	///

	/// - `sig` is passed in RSV format. V should be either `0/1` or `27/28`.

	/// - `msg` is the blake2-256 hash of the message.

	///

	/// Returns `Err` if the signature is bad, otherwise the 33-byte compressed pubkey.

	#[version(2)]

	fn secp256k1_ecdsa_recover_compressed(

		sig: &[u8; 65],

		msg: &[u8; 32],

	) -> Result<[u8; 33], EcdsaVerifyError> {

		let rid = RecoveryId::from_i32(if sig[64] > 26 { sig[64] - 27 } else { sig[64] } as i32)

			.map_err(|_| EcdsaVerifyError::BadV)?;

		let sig = RecoverableSignature::from_compact(&sig[..64], rid)

			.map_err(|_| EcdsaVerifyError::BadRS)?;

		let msg = Message::from_digest_slice(msg).expect("Message is 32 bytes; qed");

		let pubkey = SECP256K1

			.recover_ecdsa(&msg, &sig)

			.map_err(|_| EcdsaVerifyError::BadSignature)?;

		Ok(pubkey.serialize())

	}

#[runtime_interface]

	/// Conduct a 512-bit Keccak hash.

	fn keccak_512(data: &[u8]) -> [u8; 64] {

		sp_crypto_hashing::keccak_512(data)

	}

	/// Conduct a 256-bit Sha2 hash.

	fn sha2_256(data: &[u8]) -> [u8; 32] {

		sp_crypto_hashing::sha2_256(data)

	}

	/// Conduct four XX hashes to give a 256-bit result.

	fn twox_256(data: &[u8]) -> [u8; 32] {

		sp_crypto_hashing::twox_256(data)

	}

#[runtime_interface]

	/// Add transaction index. Returns indexed content hash.

	fn index(&mut self, extrinsic: u32, size: u32, context_hash: [u8; 32]) {

		self.storage_index_transaction(extrinsic, &context_hash, size);

	}

	/// Conduct a 512-bit Keccak hash.

	fn renew(&mut self, extrinsic: u32, context_hash: [u8; 32]) {

		self.storage_renew_transaction_index(extrinsic, &context_hash);

	}

#[runtime_interface]

	/// Remove a key and its associated value from the Offchain DB.

	fn clear(&mut self, key: &[u8]) {

		self.set_offchain_storage(key, None);

	}