Protocol Setup Guide

A comprehensive guide to setting up and deploying your liquid staking protocol on Solana. Learn about environment setup, smart contract deployment, configuration, and best practices.

Last updated: 2024-03-21
Edit on GitHub

Overview

Setting up a liquid staking protocol requires careful planning and implementation. This guide walks you through the complete setup process, from development environment configuration to production deployment, ensuring your protocol is secure, efficient, and ready for users.

Quick Links

PrerequisitesEnvironment SetupSmart ContractsConfigurationDeploymentVerification

Setup Checklist

  • •Development environment ready
  • •Smart contracts implemented
  • •Security measures in place
  • •Testing completed

Prerequisites

Before starting the setup process, ensure you have all the necessary tools and knowledge.

Development Tools

  • • Rust 1.70 or higher
  • • Solana CLI tools
  • • Node.js 18+
  • • Git

Knowledge Required

  • • Rust programming
  • • Solana architecture
  • • Web3 concepts
  • • Cryptography basics

Resources Needed

  • • Testnet SOL
  • • Development wallet
  • • RPC endpoint
  • • Storage solution

Environment Setup

Set up your development environment with the necessary tools and configurations.

Environment Setup Commands

1# Install Rust and Cargo
2curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
3
4# Install Solana CLI tools
5sh -c "$(curl -sSfL https://release.solana.com/v1.17.0/install)"
6
7# Install Node.js and npm
8curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
9nvm install 18
10nvm use 18
11
12# Clone the repository
13git clone https://github.com/your-org/liquid-staking-protocol.git
14cd liquid-staking-protocol
15
16# Install dependencies
17npm install
18cargo build-bpf

Smart Contracts

Implement the core smart contracts for your liquid staking protocol.

Core Protocol Contract

1use anchor_lang::prelude::*;
2use anchor_spl::token::{self, Token};
3
4#[program]
5pub mod liquid_staking {
6    use super::*;
7
8    pub fn initialize(
9        ctx: Context<Initialize>,
10        params: InitializeParams,
11    ) -> Result<()> {
12        // Initialize protocol settings
13        let protocol = &mut ctx.accounts.protocol;
14        protocol.authority = ctx.accounts.authority.key();
15        protocol.stake_token_mint = ctx.accounts.stake_token_mint.key();
16        protocol.liquid_token_mint = ctx.accounts.liquid_token_mint.key();
17        
18        // Set initial parameters
19        protocol.exchange_rate = params.initial_exchange_rate;
20        protocol.fee_rate = params.fee_rate;
21        protocol.min_stake_amount = params.min_stake_amount;
22        
23        // Initialize stake pool
24        protocol.total_staked = 0;
25        protocol.total_liquid_tokens = 0;
26        
27        // Emit initialization event
28        emit!(ProtocolInitialized {
29            authority: protocol.authority,
30            stake_token_mint: protocol.stake_token_mint,
31            liquid_token_mint: protocol.liquid_token_mint,
32            timestamp: Clock::get()?.unix_timestamp,
33        });
34        
35        Ok(())
36    }
37
38    pub fn stake(
39        ctx: Context<Stake>,
40        amount: u64,
41    ) -> Result<()> {
42        // Implement staking logic
43        // ...
44    }
45
46    pub fn unstake(
47        ctx: Context<Unstake>,
48        amount: u64,
49    ) -> Result<()> {
50        // Implement unstaking logic
51        // ...
52    }
53}

Configuration

Configure your protocol parameters and settings for optimal performance and security.

Protocol Parameters

1export const CONFIG = {
2  // Protocol settings
3  minStakeAmount: new BN(1_000_000_000), // 1 SOL
4  maxStakeAmount: new BN(1_000_000_000_000), // 1000 SOL
5  feeRate: 0.02, // 2%
6  
7  // Timelock settings
8  unstakingDelay: 2 * 24 * 60 * 60, // 2 days
9  
10  // Security settings
11  maxValidatorStake: 100_000_000_000_000,
12  minValidatorStake: 1_000_000_000_000,
13}

Environment Variables

1# Network
2SOLANA_NETWORK=mainnet-beta
3RPC_ENDPOINT=https://api.mainnet-beta.solana.com
4
5# Protocol
6PROTOCOL_AUTHORITY=your_authority_keypair.json
7STAKE_TOKEN_MINT=So11111111111111111111111111111111111111112
8LIQUID_TOKEN_MINT=your_liquid_token_mint
9
10# Security
11MAX_VALIDATOR_COUNT=100
12EMERGENCY_SHUTDOWN_THRESHOLD=0.95

Deployment

Deploy your protocol to the Solana network following security best practices.

Deployment Commands

1# Build the program
2cargo build-bpf
3
4# Deploy to devnet first
5solana program deploy \
6  --program-id your_program_id.json \
7  --keypair deploy_keypair.json \
8  --url https://api.devnet.solana.com \
9  target/deploy/liquid_staking.so
10
11# Verify deployment
12solana program show --programs
13
14# Initialize protocol
15ts-node scripts/initialize.ts
16
17# Verify initialization
18ts-node scripts/verify-deployment.ts

Verification

Verify your protocol deployment and run comprehensive tests.

Test Scenarios

1describe("Liquid Staking Protocol", () => {
2  it("should initialize protocol correctly", async () => {
3    // Test initialization
4  });
5
6  it("should handle staking correctly", async () => {
7    // Test staking
8  });
9
10  it("should handle unstaking correctly", async () => {
11    // Test unstaking
12  });
13
14  it("should calculate rewards correctly", async () => {
15    // Test rewards
16  });
17
18  it("should handle emergency situations", async () => {
19    // Test emergency procedures
20  });
21});
Security Considerations
  • Always deploy to testnet first and thoroughly test
  • Use multisig for protocol authority
  • Implement proper access controls
  • Set up monitoring and alerting
  • Have security audits before mainnet deployment
  • Keep deployment keys secure
  • Document all deployment steps and configurations