tuktuk-cli 0.2.14

A cli for tuktuk
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use clap::{Args, Subcommand};
use serde::Serialize;
use solana_sdk::{pubkey::Pubkey, signer::Signer};
use tuktuk_program::types::InitializeTuktukConfigArgsV0;
use tuktuk_sdk::prelude::*;

use crate::{
    client::send_instructions,
    cmd::Opts,
    result::Result,
    serde::{print_json, serde_pubkey},
};

#[derive(Debug, Args)]
pub struct TuktukConfigCmd {
    #[command(subcommand)]
    pub cmd: Cmd,
}

#[derive(Debug, Subcommand)]
pub enum Cmd {
    Create {
        #[arg(long)]
        authority: Option<Pubkey>,
        #[arg(long, help = "Minimum deposit in bones to create a task queue")]
        min_deposit: u64,
    },
}

impl TuktukConfigCmd {
    pub async fn run(&self, opts: Opts) -> Result {
        match &self.cmd {
            Cmd::Create {
                authority,
                min_deposit,
            } => {
                let client = opts.client().await?;
                let tuktuk_config_key = tuktuk::config_key();

                let mut combined_ixs = Vec::new();

                let extra_signers = Vec::new();

                // Combine existing instructions with mint instructions if created
                combined_ixs.push(tuktuk::create_config(
                    client.payer.pubkey(),
                    *authority,
                    InitializeTuktukConfigArgsV0 {
                        min_deposit: *min_deposit,
                    },
                )?);

                send_instructions(
                    client.rpc_client.clone(),
                    &client.payer,
                    client.opts.ws_url().as_str(),
                    &combined_ixs,
                    &extra_signers,
                )
                .await?;

                let tuktuk_config: tuktuk_program::TuktukConfigV0 = client
                    .as_ref()
                    .anchor_account(&tuktuk_config_key)
                    .await?
                    .ok_or_else(|| anyhow::anyhow!("Tuktuk config account not found"))?;

                print_json(&TuktukConfig {
                    pubkey: tuktuk_config_key,
                    authority: tuktuk_config.authority,
                    bump_seed: tuktuk_config.bump_seed,
                })?;
            }
        }
        Ok(())
    }
}

#[derive(Serialize)]
pub struct TuktukConfig {
    #[serde(with = "serde_pubkey")]
    pub pubkey: Pubkey,
    #[serde(with = "serde_pubkey")]
    pub authority: Pubkey,
    pub bump_seed: u8,
}