https://github.com/furydotbot/rust-sdk
How to USE 👇🏻
https://github.com/furydotbot/rust-sdk
bundler jupiter moonshot pumpfun pumpswap raydium sdk solana solanabot solanabundler solanasdk
Last synced: 11 months ago
JSON representation
How to USE 👇🏻
- Host: GitHub
- URL: https://github.com/furydotbot/rust-sdk
- Owner: furydotbot
- Created: 2025-04-14T14:22:33.000Z (about 1 year ago)
- Default Branch: master
- Last Pushed: 2025-04-18T08:47:15.000Z (about 1 year ago)
- Last Synced: 2025-05-30T01:39:26.717Z (about 1 year ago)
- Topics: bundler, jupiter, moonshot, pumpfun, pumpswap, raydium, sdk, solana, solanabot, solanabundler, solanasdk
- Language: Rust
- Homepage: https://docs.fury.bot/fury-sdk/sdk-for-rust
- Size: 80.1 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# FURY SDK for Rust
A Rust client library for interacting with the FURY API service - a comprehensive toolkit for Solana token operations.
## Features
- **Complete API Coverage** - Access to all FURY API endpoints
- **Type Safety** - Strong typing with Rust's type system
- **Async Support** - Built on Tokio for efficient async operations
- **Error Handling** - Comprehensive error handling with anyhow
- **Validation** - Built-in parameter validation
- **Solana Integration** - Native support for Solana transactions and signatures
## Installation
### Requirements
- Rust 1.70+
- Cargo package manager
### Add to Your Project
Add the following to your `Cargo.toml`:
```toml
[dependencies]
fury-sdk = "0.1.0"
```
## Quick Start
```rust
use anyhow::Result;
use fury_sdk::sdk::FurySDK;
#[tokio::main]
async fn main() -> Result<()> {
let http_client = reqwest::Client::new();
let client = FurySDK::new(http_client);
// Generate a new mint key
let mint_key = client.generate_mint().await?;
println!("Generated mint key: {}", mint_key.pubkey);
Ok(())
}
```
## Usage Examples
### Buy Tokens
```rust
use anyhow::Result;
use anyhow::Result;
use fury_sdk::sdk::{FurySDK, BuyTokenRequest};
#[tokio::main]
async fn main() -> Result<()> {
let http_client = reqwest::Client::new();
let fury = FurySDK::new(http_client);
// Buy tokens
let result = fury.buy_token(&BuyTokenRequest {
wallet_addresses: vec!["FuRytmqsoo4mKQAhNXoB64JD4SsiVqxYkUKC6i1VaBot".to_string()],
token_address: "Bq5nFQ82jBYcFKRzUSximpCmCg5t8L8tVMqsn612pump".to_string(),
sol_amount: 0.001,
protocol: fury::Protocol::Pumpfun,
jito_tip_lamports: Some(sol_to_lamports(0.001)),
amounts: None,
use_rpc: false,
affiliate_address: None,
affiliate_fee: None,
slippage_bps: None,
}).await?;
println!("Transaction data: {:?}", result.transactions);
Ok(())
}
```
### Complete Buy Flow with Transaction Signing
```rust
use anyhow::Result;
use fury_sdk::sdk::{FurySDK, BuyTokenRequest, TransactionSendRequest};
use fury_sdk::utils::sign_transactions;
use solana_sdk::{signature::Keypair, signer::Signer};
#[tokio::main]
async fn main() -> Result<()> {
// Initialize SDK
let http_client = reqwest::Client::new();
let fury = FurySDK::new(http_client);
// Load wallet
let wallet = Keypair::from_base58_string("YOUR_PRIVATE_KEY_HERE");
// Generate buy transaction
let buy_result = fury.buy_token(&fury::BuyTokenRequest {
wallet_addresses: vec![wallet.pubkey().to_string()],
token_address: "Bq5nFQ82jBYcFKRzUSximpCmCg5t8L8tVMqsn612pump".to_string(),
sol_amount: 0.001,
protocol: fury::Protocol::Pumpfun,
jito_tip_lamports: Some(sol_to_lamports(0.001)),
amounts: None,
use_rpc: false,
affiliate_address: None,
affiliate_fee: None,
slippage_bps: None,
}).await?;
let signed_txs = sign_transactions(buy_result.transactions, vec![wallet]);
let send_result = fury
.jito_transaction_send(&TransactionSendRequest {
transactions: signed_txs,
use_rpc: false,
})
.await?
println!("Transaction signatures: {:?}", send_result.results);
Ok(())
}
```
### Create a New Token
```rust
use anyhow::Result;
use fury_sdk::sdk::{FurySDK, TokenCreationConfig, TokenCreation, TokenCreationMetadata, TokensCreateRequest};
#[tokio::main]
async fn main() -> Result<()> {
let http_client = reqwest::Client::new();
let fury = FurySDK::new(http_client);
let result = match client.tokens_create(&TokensCreateRequest {
wallet_addresses: vec!["5tqe3S1zsfAmT7L2Ru5gVJDaq4wUB7AbCpTLPaxaM6eG".to_string()],
mint_pubkey: "Bq5nFQ82jBYcFKRzUSximpCmCg5t8L8tVMqsn612pump".to_string(),
config: TokenCreationConfig {
token_creation: TokenCreation {
metadata: TokenCreationMetadata {
name: "Test Token".to_string(),
symbol: "TEST".to_string(),
description: Some("A test token created with FURY SDK".to_string()),
telegram: None,
twitter: None,
website: None,
file: "https://example.com/logo.png".to_string(),
},
default_sol_amount: 0.001,
},
},
amounts: vec![0.001],
}).await?;
println!("Token creation transactions: {:?}", result);
Ok(())
}
```
### Distribute Tokens to Multiple Wallets
```rust
use anyhow::Result;
use fury_sdk::sdk::{FurySDK, WalletsDistributeRequest, WalletsDistributeRecipient};
#[tokio::main]
async fn main() -> Result<()> {
let http_client = reqwest::Client::new();
let fury = FurySDK::new(http_client);
// Define recipients
let recipients = vec![
WalletsDistributeRecipient { address: "8fwjXcyQrCCkG5k3vHUioVLNbPr72otA59mmR1w6CwpS".to_string(), amount: 0.01 },
WalletsDistributeRecipient { address: "68qzyqvqX3eEGEfwa2ajsDKmEjhmU9XRj1VjcUPJNwpq".to_string(), amount: 0.01 },
];
// Distribute tokens
let result = fury.wallets_distribute(&WalletsDistributeRequest {
sender: wallet.pubkey().to_string(),
recipients,
}).await?;
println!("Distribution transactions: {:?}", result.transactions);
Ok(())
}
```
### Error Handling
The SDK uses a custom `FuryError` enum for error handling:
```rust
pub enum FuryError {
ApiError(ErrorResponse),
RequestError(reqwest::Error),
Other(anyhow::Error),
}
```
Example:
```rust
use fury_sdk::sdk::{FurySDK, WalletsDistributeRequest, WalletsDistributeRecipient};
#[tokio::main]
async fn main() -> Result<()> {
let http_client = reqwest::Client::new();
let fury = FurySDK::new(http_client);
// You can handle specific errors if necessary
let mint = match client.generate_mint().await {
Ok(key) => key,
Err(FuryError::ApiError(error)) => {
println!("Error: {:#?}", error);
return Err(anyhow::anyhow!("API returned error: {:?}", error));
}
Err(FuryError::RequestError(err)) => {
println!("Error: {:#?}", err);
return Err(anyhow::anyhow!("Request error: {:?}", err));
}
Err(FuryError::Other(err)) => {
println!("Other error: {:#?}", err);
return Err(anyhow::anyhow!("Other error: {:?}", err));
}
};
// or handle them in a more generic way (uncomment below to see)
// let mint = match client.generate_mint().await {
// Ok(key) => key,
// Err(err) => {
// println!("Error: {:#?}", err);
// return Err(anyhow::anyhow!("Error occurred: {:?}", err));
// }
// };
println!("Mint: {mint}");
Ok(())
}
```
## Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.