adding some gateway functions

Author: haider-rs

Diff for: gmp/solana/contract/src/errors.rs

@@ -0,0 +1,13 @@
+use anchor_lang::prelude::*;
+
+#[error_code]
+pub enum GatewayError {
+	#[msg("The gateway is not initialized.")]
+	NotInitialized,
+	#[msg("The gateway is already initialized")]
+	AlreadyInitialized,
+	#[msg("Unauthorized: The provided authority is not the gateway admin.")]
+	Unauthorized,
+	#[msg("Too much shards to register")]
+	ShardsLengthExceedLimit,
+}

Diff for: gmp/solana/contract/src/lib.rs

@@ -1,24 +1,79 @@
 use anchor_lang::prelude::*;
 
+mod errors;
+mod state;
+
+use errors::*;
+use state::*;
+
 declare_id!("11111111111111111111111111111111");
 
 #[program]
-mod hello_anchor {
+mod gateway {
 	use super::*;
+	// Admin executable
+	pub fn initialize(ctx: Context<Initialize>, admin: Pubkey) -> Result<()> {
+		let state = &mut ctx.accounts.gateway_state;
+		if !state.is_initialized {
+			state.admin = admin;
+			state.is_initialized = true;
+		}
+		Ok(())
+	}
 
-	pub fn initialize(_ctx: Context<Initialize>) -> Result<()> {
+	// Admin executable
+	pub fn set_admin(ctx: Context<SetAdmin>, new_admin: Pubkey) -> Result<()> {
+		let state = &mut ctx.accounts.gateway_state;
+		require_keys_eq!(ctx.accounts.signer.key(), state.admin, GatewayError::Unauthorized);
+		require!(state.is_initialized, GatewayError::AlreadyInitialized);
+		state.admin = new_admin;
 		Ok(())
 	}
-}
 
-#[derive(Accounts)]
-pub struct Initialize<'info> {
-	#[account(mut)]
-	pub signer: Signer<'info>,
-	pub system_program: Program<'info, System>,
-}
+	// only executed by admin
+	pub fn set_shards(ctx: Context<SetShards>, shards: Vec<Shard>) -> Result<()> {
+		require!(shards.len() < MAX_SHARDS_LEN, GatewayError::ShardsLengthExceedLimit);
+		let state = &mut ctx.accounts.gateway_state;
+		require_keys_eq!(ctx.accounts.signer.key(), state.admin, GatewayError::Unauthorized);
+		state.shards.clear();
+		for shard in shards.into_iter() {
+			let seed_x = shard.x_coord;
+			let seed_y = [shard.y_parity];
+
+			let (nonce_pda, _bump) =
+				Pubkey::find_program_address(&[b"shard_nonce", &seed_x, &seed_y], ctx.program_id);
+
+			let mut shard_nonce = 0u64;
+			let mut found = false;
+			for acc in ctx.remaining_accounts.iter() {
+				if acc.key() == nonce_pda {
+					let shard_nonce_acc =
+						ShardNonce::try_deserialize(&mut acc.data.borrow().as_ref())?;
+					shard_nonce = shard_nonce_acc.nonce;
+					found = true;
+					break;
+				}
+			}
+			if !found {
+				shard_nonce = 0;
+			}
+			state.shards.push(ShardAcc {
+				shard: shard.clone(),
+				nonce: shard_nonce,
+			});
+		}
 
-#[account]
-pub struct NewAccount {
-	data: u64,
+		Ok(())
+	}
+
+	// excuted by user
+	pub fn submit_message(ctx: Context<Initialize>, msg: GmpMessage) -> Result<()> {
+		msg!("gmp executed: {:?}", msg);
+		Ok(())
+	}
+
+	// excuted by chronicles
+	pub fn execute_batch(ctx: Context<Initialize>) -> Result<()> {
+		Ok(())
+	}
 }

Diff for: gmp/solana/contract/src/state.rs

@@ -0,0 +1,93 @@
+use anchor_lang::prelude::*;
+use borsh::{BorshDeserialize, BorshSerialize};
+
+type GmpID = [u8; 32];
+type NetworkId = u16;
+type Address = [u8; 32];
+
+pub const MAX_SHARDS_LEN: usize = 50;
+
+#[derive(Accounts)]
+pub struct Initialize<'info> {
+	#[account(
+        init,
+        payer = signer,
+        // first 8 bytes is type discriminator: <https://www.anchor-lang.com/docs/basics/program-structure#account-discriminator>
+        space = 8 + 32 + 1,
+        // look into the security issues of seeds
+        seeds = [b"gateway_state"],
+        bump
+    )]
+	pub gateway_state: Account<'info, GatewayState>,
+	#[account(mut)]
+	pub signer: Signer<'info>,
+
+	pub system_program: Program<'info, System>,
+}
+
+#[derive(Accounts)]
+pub struct SetAdmin<'info> {
+	#[account(mut)]
+	pub gateway_state: Account<'info, GatewayState>,
+	#[account(mut)]
+	pub signer: Signer<'info>,
+}
+
+#[derive(Accounts)]
+pub struct SetShards<'info> {
+	#[account(mut)]
+	pub gateway_state: Account<'info, GatewayState>,
+	#[account(mut)]
+	pub signer: Signer<'info>,
+}
+
+#[account]
+#[derive(Default)]
+pub struct GatewayState {
+	pub admin: Pubkey,
+	pub is_initialized: bool,
+	pub shards: Vec<ShardAcc>,
+}
+
+#[account]
+pub struct GmpInfo {
+	pub msg: [u8; 32],
+	pub y_parity: u8,
+	pub nonce: u64,
+}
+
+#[account]
+pub struct ShardAcc {
+	pub shard: Shard,
+	pub nonce: u64,
+}
+
+#[account]
+pub struct ShardNonce {
+	pub nonce: u64,
+}
+
+#[derive(Clone, BorshSerialize, BorshDeserialize)]
+pub struct Shard {
+	pub x_coord: [u8; 32],
+	pub y_parity: u8,
+}
+
+#[derive(Clone, Copy, BorshSerialize, BorshDeserialize, PartialEq)]
+pub enum GmpStatus {
+	Pending,
+	Executed,
+	Failed,
+}
+
+#[derive(Clone, Debug, BorshSerialize, BorshDeserialize)]
+pub struct GmpMessage {
+	pub src_network: NetworkId,
+	pub dest_network: NetworkId,
+	pub src: Address,
+	pub dest: Address,
+	pub nonce: u64,
+	pub gas_limit: u128,
+	pub gas_cost: u128,
+	pub bytes: Vec<u8>,
+}