1use std::collections::HashMap;
2use reqwest::header::HeaderMap;
3use std::option::Option;
4use serde::Deserialize;
5use serde::Serialize;
6use serde_json::value::Value;
7use serde_json::{json, Map};
8use std::error::Error;
9use crate::{ActionType, get_basic_url, get_env_name, get_request_header, NetEnv};
10use crate::marketplace::approve_token;
11
12#[derive(Debug, Serialize, Deserialize)]
13pub struct Response<T> {
14 pub status: Option<String>,
15 pub data: Option<T>,
16 pub code: Option<u32>,
17 pub message: Option<String>,
18 }
20
21#[derive(Debug, Serialize, Deserialize)]
22pub struct TransferSpltoken {
23 pub tx_signature: String
24}
25
26#[derive(Debug, Serialize, Deserialize)]
27pub struct ISolanaToken {
28 pub ata: String,
29 pub mint: String,
30 pub amount: String,
31}
32
33#[derive(Debug, Serialize, Deserialize)]
34pub struct SolanaTokenInfo {
35 pub ata: String,
36 pub mint: String,
37 pub amount: usize,
38 pub decimals: usize,
39}
40
41#[derive(Debug, Serialize, Deserialize)]
42pub struct GetSolanaTokens {
43 pub tokens: Vec<SolanaTokenInfo>,
44 pub sol: usize,
45}
46
47#[derive(Debug, Serialize, Deserialize)]
48pub struct GetTransactions {
49 pub transactions: Vec<TransactionInfo>,
50 pub count: usize,
51}
52
53#[derive(Debug, Serialize, Deserialize)]
54pub struct TransactionInfo {
55
56 #[serde(rename = "blockTime")]
57 pub block_time: usize,
58 pub slot: usize,
59 pub transaction: TransactionDetail,
60}
61
62#[derive(Debug, Serialize, Deserialize)]
63pub struct TransactionDetail {
64 pub signatures: Vec<String>,
65}
66
67pub struct Wallet {
68 api_key: String,
69 net: NetEnv,
70 token: String,
71 secret_key: String,
72}
73
74impl Wallet {
75 pub fn new(api_key: String, env: NetEnv, token:String, secretKey: String) -> Wallet {
76 Wallet{api_key, net: env, token, secret_key: secretKey}
77 }
78
79 pub async fn transfer_spltoken(&self, payload:(&str, &str, &str, &str))-> Result<Option<TransferSpltoken>, Box<dyn Error>>
80 {
81 let mut headers = get_request_header(self.api_key.to_string(), self.token.to_string());
82 let mut approve_headers = get_request_header(self.api_key.to_string(), self.secret_key.to_string());
83
84 let mut data = Map::new();
85 let (to_publickey, amount,token_min, decimals ) = payload;
86 data.insert("to_publickey".to_string(), Value::from(to_publickey));
87 data.insert("amount".to_string(), Value::from(amount));
88 data.insert("token_mint".to_string(), Value::from(token_min));
89 data.insert("decimals".to_string(), Value::from(decimals));
90
91 let action_token = approve_token(
92 ActionType::TRANSFER_SPL_TOKEN,
93 approve_headers.clone(),
94 self.net,
95 data.clone()
96 ).await.unwrap();
97 if action_token.is_none() {
98 println!("auction token is none")
99 }
100 let x_token = action_token.unwrap().authorization_token.to_string();
101 headers.insert("x-authorization-token", x_token.parse().unwrap());
102
103 let url_ = format!("/v1/{}/wallet/transfer-token", get_env_name(self.net));
104 let url:String = get_basic_url(self.net) + &url_;
105
106 let client = reqwest::Client::new();
107 let res = client
108 .post(url)
109 .headers(headers)
110 .json(&data)
111 .send()
112 .await.unwrap();
113 let resp = res.json::<Response<TransferSpltoken>>().await?;
114 Ok(resp.data)
115 }
116
117 pub async fn transfer_sol(&self, payload:(&str, &str))-> Result<Option<TransferSpltoken>, Box<dyn Error>>
118 {
119 let mut headers:HeaderMap = get_request_header(self.api_key.to_string(), self.token.to_string());
120 let mut approve_headers = get_request_header(self.api_key.to_string(), self.secret_key.to_string());
121
122 let mut data = Map::new();
123 let (to_publickey, amount ) = payload;
124 data.insert("to_publickey".to_string(), Value::from(to_publickey));
125 data.insert("amount".to_string(), Value::from(amount));
126
127 let action_token = approve_token(
128 ActionType::TRANSFER_SOL,
129 approve_headers.clone(),
130 self.net,
131 data.clone()
132 ).await.unwrap();
133 if action_token.is_none() {
134 panic!("action is none")
135 }
136
137 let x_token = action_token.unwrap().authorization_token.to_string();
138 headers.insert("x-authorization-token", x_token.parse().unwrap());
139
140 let url_ = format!("/v1/{}/wallet/transfer-sol", get_env_name(self.net));
141 let url:String = get_basic_url(self.net) + &url_;
142 let client = reqwest::Client::new();
143 let res = client
144 .post(url)
145 .headers(headers)
146 .json(&data)
147 .send()
148 .await.unwrap();
149 let resp = res.json::<Response<TransferSpltoken>>().await?;
150 Ok(resp.data)
151 }
152
153 pub async fn get_tokens(&self) -> Result<Option<GetSolanaTokens>, Box<dyn Error>> {
154 let mut headers:HeaderMap = get_request_header(self.api_key.to_string(), self.token.to_string());
155
156 let url_ = format!("/v1/{}/wallet/tokens", get_env_name(self.net));
157 let url:String = get_basic_url(self.net) + &url_;
158
159 let client = reqwest::Client::new();
160 let res = client
161 .get(url)
162 .headers(headers)
163 .send()
164 .await.unwrap();
165
166 let resp = res.json::<Response<GetSolanaTokens>>().await?;
167
168 Ok(resp.data)
169 }
170
171 pub async fn get_transactions(&self) -> Result<Option<GetTransactions>, Box<dyn Error>> {
172 let mut headers:HeaderMap = get_request_header(self.api_key.to_string(), self.token.to_string());
173
174 let url_ = format!("/v1/{}/wallet/transactions", get_env_name(self.net));
175 let url:String = get_basic_url(self.net) + &url_;
176 let client = reqwest::Client::new();
177 let res = client
178 .get(url)
179 .headers(headers)
180 .send()
181 .await.unwrap();
182
183 let resp = res.json::<Response<GetTransactions>>().await?;
184 Ok(resp.data)
185 }
186}