cli

Author: 2501babe

clients/cli/src/cli.rs

@@ -86,6 +86,10 @@ pub enum Command {
 
     /// Display info for one or all single-validator stake pool(s)
     Display(DisplayCli),
+
+    /// Deposit liquid sol into a pool in exchange for pool tokens, less a one percent
+    /// fee.
+    DepositSol(DepositSolCli),
 }
 
 #[derive(Clone, Debug, Parser)]
@@ -305,6 +309,30 @@ pub struct CreateOnRampCli {
     pub vote_account_address: Option<Pubkey>,
 }
 
+#[derive(Clone, Debug, Args)]
+#[clap(group(pool_source_group()))]
+pub struct DepositSolCli {
+    /// Lamports to deposit into pool
+    pub lamports: u64,
+
+    /// The pool to withdraw from
+    #[clap(short, long = "pool", value_parser = |p: &str| parse_address(p, "pool_address"))]
+    pub pool_address: Option<Pubkey>,
+
+    /// The vote account corresponding to the pool to withdraw from
+    #[clap(long = "vote-account", value_parser = |p: &str| parse_address(p, "vote_account_address"))]
+    pub vote_account_address: Option<Pubkey>,
+
+    /// The wallet to deposit lamports from. Defaults to the client
+    /// keypair
+    #[clap(long, id = "DEPOSIT_SOURCE_KEYPAIR", value_parser = SignerSourceParserBuilder::default().allow_all().build())]
+    pub from: Option<SignerSource>,
+
+    /// The token account to mint to. Defaults to the client keypair's
+    /// associated token account
+    #[clap(long = "token-account", value_parser = |p: &str| parse_address(p, "token_account_address"))]
+    pub token_account_address: Option<Pubkey>,
+}
 fn pool_source_group() -> ArgGroup<'static> {
     ArgGroup::new("pool-source")
         .required(true)
@@ -358,3 +386,12 @@ pub fn pool_address_from_args(maybe_pool: Option<Pubkey>, maybe_vote: Option<Pub
         unreachable!()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    // if this test fails, we changed the fee. fix the comment on Command::DepositSol
+    #[test]
+    fn test_deposit_sol_fee() {
+        assert_eq!(spl_single_pool::DEPOSIT_SOL_FEE_BPS, 100);
+    }
+}

clients/cli/src/main.rs

@@ -91,6 +91,9 @@ impl Command {
                 command_withdraw(config, command_config, matches, wallet_manager).await
             }
             Command::Display(command_config) => command_display(config, command_config).await,
+            Command::DepositSol(command_config) => {
+                command_deposit_sol(config, command_config, matches, wallet_manager).await
+            }
         }
     }
 }
@@ -822,6 +825,189 @@ async fn command_create_onramp(config: &Config, command_config: CreateOnRampCli)
     ))
 }
 
+// deposit liquid sol
+async fn command_deposit_sol(
+    config: &Config,
+    command_config: DepositSolCli,
+    matches: &ArgMatches,
+    wallet_manager: &mut Option<Rc<RemoteWalletManager>>,
+) -> CommandResult {
+    let payer = config.fee_payer()?;
+    let owner = config.default_signer()?;
+
+    let deposit_source = command_config
+        .from
+        .and_then(|source| {
+            signer_from_source(matches, &source, "from", wallet_manager)
+                .ok()
+                .map(Arc::from)
+        })
+        .unwrap_or(owner.clone());
+
+    let deposit_amount = command_config.lamports;
+
+    let pool_address = pool_address_from_args(
+        command_config.pool_address,
+        command_config.vote_account_address,
+    );
+
+    let pool_stake_address = find_pool_stake_address(&spl_single_pool::id(), &pool_address);
+    let onramp_address = find_pool_onramp_address(&spl_single_pool::id(), &pool_address);
+    let pool_mint_address = find_pool_mint_address(&spl_single_pool::id(), &pool_address);
+
+    pool_is_initialized(config, pool_address).await?;
+
+    let vote_account_address = get_vote_address_from_pool(config, pool_address).await?;
+
+    if get_initialized_account(config, onramp_address)
+        .await?
+        .is_none()
+    {
+        return Err(format!(
+            "Pool {} onramp {} does not exist",
+            pool_address, onramp_address
+        )
+        .into());
+    }
+
+    let current_epoch = config.rpc_client.get_epoch_info().await?.epoch;
+
+    if let Some((_, stake)) = quarantine::get_stake_info(config, &pool_stake_address).await? {
+        if stake.delegation.activation_epoch >= current_epoch {
+            return Err(format!(
+                "Pool {} stake {} is still activating; must be fully active",
+                pool_address, pool_stake_address
+            )
+            .into());
+        }
+
+        if stake.delegation.deactivation_epoch < u64::MAX {
+            return Err(format!(
+                "Pool {} stake {} is deactivating or deactivated",
+                pool_address, pool_stake_address
+            )
+            .into());
+        }
+    } else {
+        // pool existence already validated and pool exists => stake exists
+        unreachable!();
+    };
+
+    {
+        let deposit_source_balance = config
+            .program_client
+            .get_account(deposit_source.pubkey())
+            .await?
+            .map(|account| account.lamports)
+            .unwrap_or(0);
+
+        if deposit_source_balance < deposit_amount {
+            return Err(format!(
+                "Insufficient lamports in {} for deposit: has {}, needs {}",
+                deposit_source.pubkey(),
+                deposit_source_balance,
+                deposit_amount,
+            )
+            .into());
+        }
+    }
+
+    println_display(
+        config,
+        format!(
+            "Depositing liquid sol from account {} into pool {}\n",
+            deposit_source.pubkey(),
+            pool_address
+        ),
+    );
+
+    let token = Token::new(
+        config.program_client.clone(),
+        &spl_token::id(),
+        &pool_mint_address,
+        None,
+        payer.clone(),
+    );
+
+    let mut instructions = vec![];
+
+    // use token account provided, or get/create the associated account for the client keypair
+    let token_account_address = if let Some(account) = command_config.token_account_address {
+        account
+    } else {
+        let address = token.get_associated_token_address(&owner.pubkey());
+        if get_initialized_account(config, address).await?.is_none() {
+            instructions.push(create_associated_token_account(
+                &payer.pubkey(),
+                &owner.pubkey(),
+                &pool_mint_address,
+                &spl_token::id(),
+            ));
+        }
+        address
+    };
+
+    let previous_token_amount = match token.get_account_info(&token_account_address).await {
+        Ok(account) => account.base.amount,
+        Err(_) => 0,
+    };
+
+    // use escrow account for lamports to avoid exposing wallet signer to program
+    let escrow_deposit_account = Keypair::new();
+
+    instructions.extend(spl_single_pool::instruction::deposit_liquid(
+        &spl_single_pool::id(),
+        &vote_account_address,
+        &deposit_source.pubkey(),
+        &escrow_deposit_account.pubkey(),
+        &token_account_address,
+        deposit_amount,
+    ));
+
+    let mut signers = vec![];
+    for signer in [
+        payer.clone(),
+        deposit_source,
+        Arc::new(escrow_deposit_account),
+    ] {
+        if !signers.contains(&signer) {
+            signers.push(signer);
+        }
+    }
+
+    let transaction = Transaction::new_signed_with_payer(
+        &instructions,
+        Some(&payer.pubkey()),
+        &signers,
+        config.program_client.get_latest_blockhash().await?,
+    );
+
+    let signature = process_transaction(config, transaction).await?;
+
+    let token_amount = if config.dry_run {
+        None
+    } else {
+        Some(
+            token
+                .get_account_info(&token_account_address)
+                .await?
+                .base
+                .amount
+                - previous_token_amount,
+        )
+    };
+
+    Ok(format_output(
+        config,
+        "DepositSol".to_string(),
+        DepositOutput {
+            pool_address,
+            token_amount,
+            signature,
+        },
+    ))
+}
+
 async fn get_initialized_account(
     config: &Config,
     pubkey: Pubkey,

clients/cli/tests/test.rs

@@ -543,3 +543,23 @@ async fn create_onramp(raise_minimum_delegation: bool) {
         .unwrap();
     assert!(status.success());
 }
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+#[serial]
+async fn deposit_sol() {
+    let env = setup(true, true).await;
+
+    wait_for_next_epoch(&env.rpc_client).await;
+
+    let args = vec![
+        "deposit-sol".to_string(),
+        "-C".to_string(),
+        env.config_file_path,
+        "--vote-account".to_string(),
+        env.vote_account.to_string(),
+        "100".to_string(),
+    ];
+
+    let status = Command::new(SVSP_CLI).args(&args).status().unwrap();
+    assert!(status.success());
+}

program/src/lib.rs

@@ -15,6 +15,10 @@ use {solana_native_token::LAMPORTS_PER_SOL, solana_pubkey::Pubkey};
 
 solana_pubkey::declare_id!("SVSPxpvHdN29nkVg9rPapPNDddN5DipNLRUFhyjFThE");
 
+/// Fee charged for the `DepositSol` instruction.
+pub const DEPOSIT_SOL_FEE_BPS: u64 = 100;
+const MAX_BPS: u64 = 10_000;
+
 const POOL_PREFIX: &[u8] = b"pool";
 const POOL_STAKE_PREFIX: &[u8] = b"stake";
 const POOL_ONRAMP_PREFIX: &[u8] = b"onramp";
@@ -27,9 +31,6 @@ const PHANTOM_TOKEN_AMOUNT: u64 = LAMPORTS_PER_SOL;
 const MINT_DECIMALS: u8 = 9;
 const PERPETUAL_NEW_WARMUP_COOLDOWN_RATE_EPOCH: Option<u64> = Some(0);
 
-const DEPOSIT_SOL_FEE_BPS: u64 = 100;
-const MAX_BPS: u64 = 10_000;
-
 const VOTE_STATE_DISCRIMINATOR_END: usize = 4;
 const VOTE_STATE_AUTHORIZED_WITHDRAWER_START: usize = 36;
 const VOTE_STATE_AUTHORIZED_WITHDRAWER_END: usize = 68;