WIP Relayer for Solana

Cargo.toml

@@ -39,6 +39,7 @@ members = [
     "hyperspace/primitives",
     "hyperspace/parachain",
     "hyperspace/cosmos",
+    "hyperspace/solana",
     "hyperspace/testsuite",
     "hyperspace/metrics",
 
@@ -53,6 +54,10 @@ members = [
 [patch."https://github.com/paritytech/jsonrpsee"]
 jsonrpsee = { version = "0.16.3" }
 
+[patch.crates-io]
+aes-gcm-siv = { git = "https://github.com/dhruvja/AEADs", branch = "main-aes-gcm-siv-v0.10.3" }
+curve25519-dalek = { git = "https://github.com/dhruvja/curve25519-dalek", branch = "master" }
+
 [patch."https://github.com/paritytech/substrate"]
 sc-executor = { git = "https://github.com/paritytech//substrate.git", branch = "polkadot-v0.9.43" }
 sc-executor-common = { git = "https://github.com/paritytech//substrate.git", branch = "polkadot-v0.9.43" }

hyperspace/solana/Cargo.toml

@@ -0,0 +1,79 @@
+[package]
+name = "hyperspace-solana"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+primitives = { path = "../primitives", package = "hyperspace-primitives" }
+
+# crates.io
+anyhow = "1.0.65"
+futures = "0.3.21"
+async-trait = "0.1.53"
+log = "0.4.17"
+hex = "0.4.3"
+tokio = { version = "1.32.0", features = ["macros", "sync"] }
+rs_merkle = "1.2.0"
+codec = { package = "parity-scale-codec", version = "3.0.0", features = ["derive"] }
+serde_json = "1.0.74"
+derive_more = { version = "0.99", features = ["from"]  }
+serde = {version="1.0.137", features = ["derive"]}
+tokio-stream = { version = "0.1.14", features = ["sync"]}
+thiserror = "1.0.31"
+itertools = "0.10.3"
+prost = { version = "0.11" }
+k256 = { version = "0.11.6", features = ["ecdsa-core", "ecdsa", "sha256"] }
+tonic = { version = "0.8", features = ["tls", "tls-roots"] }
+bech32 = "0.9.1"
+bip32 = "0.4.0"
+ed25519-zebra = { version = "3.1.0" }
+tiny-bip39 = "1.0.0"
+sha2 = "0.10.6"
+ripemd = "0.1.3"
+digest = "0.10.6"
+quick_cache = "0.3.0"
+rand = "0.8.5"
+anchor-client = "0.28.0"
+anchor-lang = "0.28.0"
+borsh = { version = "0.10.3", default-features = false }
+
+# composable
+ibc = { path = "../../ibc/modules", features = [] }
+ibc-proto = { path = "../../ibc/proto" }
+ibc-primitives = { path = "../../contracts/pallet-ibc/primitives" }
+ics07-tendermint = { path = "../../light-clients/ics07-tendermint" }
+ics08-wasm = { path = "../../light-clients/ics08-wasm" }
+ibc-rpc = { path = "../../contracts/pallet-ibc/rpc" }
+pallet-ibc = { path = "../../contracts/pallet-ibc" }
+
+# Trie
+lib = { git = "https://github.com/ComposableFi/emulated-light-client.git" }
+memory = { git = "https://github.com/ComposableFi/emulated-light-client.git" }
+sealable-trie = { git = "https://github.com/ComposableFi/emulated-light-client.git", features = ["borsh"] }
+stdx = { git = "https://github.com/ComposableFi/emulated-light-client.git" }
+
+tracing = "0.1.36"
+
+# tendermint
+tendermint = { git = "https://github.com/informalsystems/tendermint-rs", rev = "e81f7bf23d63ffbcd242381d1ce5e35da3515ff1", default-features = false, features = [
+    "secp256k1",
+] }
+tendermint-proto = { git = "https://github.com/informalsystems/tendermint-rs", rev = "e81f7bf23d63ffbcd242381d1ce5e35da3515ff1", default-features = false }
+tendermint-rpc = { git = "https://github.com/informalsystems/tendermint-rs", rev = "e81f7bf23d63ffbcd242381d1ce5e35da3515ff1", default-features = false, features = [
+    "http-client",
+    "websocket-client",
+] }
+tendermint-light-client = { git = "https://github.com/informalsystems/tendermint-rs", rev = "e81f7bf23d63ffbcd242381d1ce5e35da3515ff1", default-features = false, features = [
+    "rpc-client",
+    "secp256k1",
+    "unstable",
+#    "testing"
+] }
+tendermint-light-client-verifier = { git = "https://github.com/informalsystems/tendermint-rs", rev = "e81f7bf23d63ffbcd242381d1ce5e35da3515ff1", default-features = false }
+
+[features]
+testing = [
+    "primitives/testing"
+]

hyperspace/solana/src/accounts.rs

@@ -0,0 +1,40 @@
+use anchor_client::anchor_lang::prelude::*;
+
+/// Accounts required for calling the deliver method on smart contract
+pub struct LocalDeliver {
+	/// Signer
+	pub sender: AccountMeta,
+	/// Storage Account for all the IBC data
+	pub storage: AccountMeta,
+	/// Sealable trie which stores the proof
+	pub trie: AccountMeta,
+	/// System Program (`11111111111111111111111111111111`) used to create the above 2 accounts if
+	/// not already created
+	pub system_program: AccountMeta,
+}
+
+impl LocalDeliver {
+	pub fn new(
+		sender_key: Pubkey,
+		storage_key: Pubkey,
+		trie_key: Pubkey,
+		system_program_key: Pubkey,
+	) -> Self {
+		let sender = AccountMeta::new(sender_key, true);
+		let storage = AccountMeta::new(storage_key, false);
+		let trie = AccountMeta::new(trie_key, false);
+		let system_program = AccountMeta::new_readonly(system_program_key, false);
+		Self { sender, storage, trie, system_program }
+	}
+}
+
+impl ToAccountMetas for LocalDeliver {
+	fn to_account_metas(&self, _is_signer: Option<bool>) -> Vec<AccountMeta> {
+		let mut accounts = Vec::new();
+		accounts.push(self.sender.clone());
+		accounts.push(self.storage.clone());
+		accounts.push(self.trie.clone());
+		accounts.push(self.system_program.clone());
+		accounts
+	}
+}

hyperspace/solana/src/error.rs

@@ -0,0 +1,34 @@
+use ibc::timestamp::ParseTimestampError;
+use prost::DecodeError;
+
+/// Error definitions for the cosmos client in accordance with the parachain's Error type.
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+	/// An error from the rpc interface
+	#[error("Rpc client error: {0}")]
+	RpcError(String),
+	/// Custom error
+	#[error("{0}")]
+	Custom(String),
+	/// Decode error
+	#[error("Decode error: {0}")]
+	DecodeError(#[from] DecodeError),
+	/// Encode error
+	#[error("Encode error: {0}")]
+	EncodeError(#[from] prost::EncodeError),
+	/// Parse timestamp error
+	#[error("Parse timestamp error: {0}")]
+	ParseTimestampError(#[from] ParseTimestampError),
+	/// Transfer error
+	#[error("IBC transfer error: {0}")]
+	TransferError(#[from] ibc::applications::transfer::error::Error),
+	/// Tendermint error
+	#[error("Tendermint error: {0}")]
+	TendermintError(#[from] tendermint::Error),
+}
+
+impl From<String> for Error {
+	fn from(error: String) -> Self {
+		Self::Custom(error)
+	}
+}

hyperspace/solana/src/ibc_storage.rs

@@ -0,0 +1,109 @@
+use alloc::collections::BTreeMap;
+use anchor_lang::prelude::*;
+use borsh::{BorshDeserialize, BorshSerialize};
+use ibc::core::ics04_channel::packet::Sequence;
+
+pub type InnerHeight = (u64, u64);
+pub type HostHeight = InnerHeight;
+pub type SolanaTimestamp = u64;
+pub type InnerClientId = String;
+pub type InnerConnectionId = String;
+pub type InnerPortId = String;
+pub type InnerChannelId = String;
+pub type InnerSequence = u64;
+pub type InnerIbcEvent = Vec<u8>;
+pub type InnerClient = String; // Serialized
+pub type InnerConnectionEnd = String; // Serialized
+pub type InnerChannelEnd = String; // Serialized
+pub type InnerConsensusState = String; // Serialized
+
+/// A triple of send, receive and acknowledge sequences.
+#[derive(Clone, Debug, Default, PartialEq, Eq, BorshSerialize, BorshDeserialize)]
+pub struct InnerSequenceTriple {
+	sequences: [u64; 3],
+	mask: u8,
+}
+
+#[derive(Clone, Copy)]
+pub enum SequenceTripleIdx {
+	Send = 0,
+	Recv = 1,
+	Ack = 2,
+}
+
+impl InnerSequenceTriple {
+	/// Returns sequence at given index or `None` if it wasn’t set yet.
+	pub fn get(&self, idx: SequenceTripleIdx) -> Option<Sequence> {
+		if self.mask & (1 << (idx as u32)) == 1 {
+			Some(Sequence::from(self.sequences[idx as usize]))
+		} else {
+			None
+		}
+	}
+
+	/// Sets sequence at given index.
+	pub fn set(&mut self, idx: SequenceTripleIdx, seq: Sequence) {
+		self.sequences[idx as usize] = u64::from(seq);
+		self.mask |= 1 << (idx as u32)
+	}
+
+	/// Encodes the object as a `CryptoHash` so it can be stored in the trie
+	/// directly.
+	pub fn to_hash(&self) -> lib::hash::CryptoHash {
+		let mut hash = lib::hash::CryptoHash::default();
+		let (first, tail) = stdx::split_array_mut::<8, 24, 32>(&mut hash.0);
+		let (second, tail) = stdx::split_array_mut::<8, 16, 24>(tail);
+		let (third, tail) = stdx::split_array_mut::<8, 8, 16>(tail);
+		*first = self.sequences[0].to_be_bytes();
+		*second = self.sequences[1].to_be_bytes();
+		*third = self.sequences[2].to_be_bytes();
+		tail[0] = self.mask;
+		hash
+	}
+}
+
+// #[derive(Debug, AnchorSerialize, AnchorDeserialize)]
+#[account]
+/// All the structs from IBC are stored as String since they dont implement AnchorSerialize and
+/// AnchorDeserialize
+pub struct PrivateStorage {
+	pub height: InnerHeight,
+	pub clients: BTreeMap<InnerClientId, InnerClient>,
+	/// The client ids of the clients.
+	pub client_id_set: Vec<InnerClientId>,
+	pub client_counter: u64,
+	pub client_processed_times: BTreeMap<InnerClientId, BTreeMap<InnerHeight, SolanaTimestamp>>,
+	pub client_processed_heights: BTreeMap<InnerClientId, BTreeMap<InnerHeight, HostHeight>>,
+	pub consensus_states: BTreeMap<(InnerClientId, InnerHeight), InnerConsensusState>,
+	/// This collection contains the heights corresponding to all consensus states of
+	/// all clients stored in the contract.
+	pub client_consensus_state_height_sets: BTreeMap<InnerClientId, Vec<InnerHeight>>,
+	/// The connection ids of the connections.
+	pub connection_id_set: Vec<InnerConnectionId>,
+	pub connection_counter: u64,
+	pub connections: BTreeMap<InnerConnectionId, InnerConnectionEnd>,
+	pub channel_ends: BTreeMap<(InnerPortId, InnerChannelId), InnerChannelEnd>,
+	// Contains the client id corresponding to the connectionId
+	pub connection_to_client: BTreeMap<InnerConnectionId, InnerClientId>,
+	/// The port and channel id tuples of the channels.
+	pub port_channel_id_set: Vec<(InnerPortId, InnerChannelId)>,
+	pub channel_counter: u64,
+
+	/// Next send, receive and ack sequence for given (port, channel).
+	///
+	/// We’re storing all three sequences in a single object to reduce amount of
+	/// different maps we need to maintain.  This saves us on the amount of
+	/// trie nodes we need to maintain.
+	pub next_sequence: BTreeMap<(InnerPortId, InnerChannelId), InnerSequenceTriple>,
+
+	/// The sequence numbers of the packet commitments.
+	pub packet_commitment_sequence_sets:
+		BTreeMap<(InnerPortId, InnerChannelId), Vec<InnerSequence>>,
+	/// The sequence numbers of the packet receipts.
+	pub packet_receipt_sequence_sets: BTreeMap<(InnerPortId, InnerChannelId), Vec<InnerSequence>>,
+	/// The sequence numbers of the packet acknowledgements.
+	pub packet_acknowledgement_sequence_sets:
+		BTreeMap<(InnerPortId, InnerChannelId), Vec<InnerSequence>>,
+	/// The history of IBC events.
+	pub ibc_events_history: BTreeMap<InnerHeight, Vec<InnerIbcEvent>>,
+}

hyperspace/solana/src/instructions.rs

@@ -0,0 +1,19 @@
+use anchor_client::{anchor_lang, anchor_lang::prelude::*};
+
+#[derive(Debug, Clone, PartialEq, AnchorSerialize, AnchorDeserialize)]
+/// Arguments to the instruction
+pub struct Deliver {
+	pub messages: Vec<AnyCheck>,
+}
+
+/// 8 byte unique identifier for Deliver Type
+impl anchor_lang::Discriminator for Deliver {
+	const DISCRIMINATOR: [u8; 8] = [250, 131, 222, 57, 211, 229, 209, 147];
+}
+impl anchor_lang::InstructionData for Deliver {}
+
+#[derive(Debug, Clone, AnchorSerialize, AnchorDeserialize, PartialEq)]
+pub struct AnyCheck {
+	pub type_url: String,
+	pub value: Vec<u8>,
+}