poseidon-client 0.5.2

### Poseidon - god of the Solana sea 😂

`poseidon-client` is a Minimal Solana Client library that aims to be fast to compile and cache friendly. 

Currently, not all RPC methods are implemented. If you are looking for a feature rich Solana RPC library, take a look at Solana Anchor library or the official Solana SDK and Solana-client.

Current feature support include:

- [x] `getLatestBlockhash`

- [x] `createAccountWithSeed`

- [x] `Message`
- [x] `Instruction`
- [x] `Transaction`
- [x] `getMinimumBalanceForRentExemption`
- [x] `sendTransaction` 

#### Usage

First, generate an Ed25519 Public and Private Keypair or import one. Use the `ed25519_dalek` crate to generate or import the `ed25519_dalek::Keypair`

##### Add dependencies

`File: /Cargo.toml`

```toml
[dependencies]
rand = "0.7"
ed25519-dalek = "*" # add latest version
poseidon-client = "*" # add latest version
```

Or simple use `cargo-edit` crate

```sh
$ cargo add rand --vers 0.7

$ cargo add ed25519-dalek

$ cargo add poseidon
```

##### Generate a new Keypair

```rust
use rand::rngs::OsRng;
use ed25519_dalek::Keypair;

let mut csprng = OsRng{};
let keypair: Keypair = Keypair::generate(&mut csprng);
```

##### Or import the `ed25519_dalek::Keypair` from bytes if you already have one

```rust
use ed25519_dalek::Keypair;

// Example of the 64 bytes of both the secret key (32bytes) and
// public key (32bytes) respectively
let bytes = [0u8; 64];
let keypair: Keypair = Keypair::from_bytes(&bytes)?;
```



#### `CAUTION` : NOTE THAT PROTECTING THE SECRET KEY OF THE KEYPAIR IS BEYOND THE SCOPE OF THIS CRATE. TAKE CARE!!!

##### Create the data structure for serializing and deserializing the storage PDA account of the program

```rust
use borsh::{BorshDeserialize, BorshSerialize};

#[derive(Debug, BorshSerialize, BorshDeserialize)]
pub struct PoseidonTestStore {
    username: String,
}
```



##### Get the Minimum rent needed to pay storage costs for 2 years

```rust
use poseidon_client::GetMinimumBalanceForRentExemption;

let two_year_rent =
            GetMinimumBalanceForRentExemption::process::<PoseidonTestStore>().await?;
```

##### Creating a Program Derived Account

```rust
use poseidon_client::{SYSTEM_PROGRAM_ID, PoseidonTestStore, PdaBuilder};

// Decide on the seed to create the PDA account for the program
let seed  = "EXAMPLE_HELLO";

// Instantiate the PDA account builder
let mut pda = PdaBuilder::new();
let pda_public_key = pda
    .add_from(keypair.public.to_bytes())
    .add_base(keypair.public.to_bytes())
    .add_lamports(two_year_rent.result)
    .add_seed(seed)
    .add_space(core::mem::size_of::<PoseidonTestStore>() as u64)
    .add_owner(SYSTEM_PROGRAM_ID)
    .derive_public_key()?;

// Call `build()` to create the `SystemInstruction::CreateAccountWithSeed`
let pda_instruction = pda.build()?;
```

##### Building a Message

```rust
use poseidon_client::MessageBuilder;

let mut message_builder = MessageBuilder::new();
message_builder
    .add_instruction(pda_instruction)
    .add_payer(public_key_bytes)
    .build();

let mut message = Message::new();
message.build(message_builder)?;
```

##### Get Latest Blockhash

```rust
use poseidon_client::GetLatestBlockhash;

let blockhash = GetLatestBlockhash::as_bytes(Commitment::Finalized).await?;
```

##### Create a Transaction

```rust
use ed25519_dalek::Signer;
use poseidon_client::Transaction;

// First update the `recent_blockhash` field of the `Message` with 
// a recent blockhash so that transactions will not fail.
// A Solana `recent_blockhash` only lasts for about `2 minutes` in order to
//prevent replay attacks
message.add_recent_blockhash(blockhash);

// Use the keypair to sign a message
let signature = keypair.sign(&message.to_bytes()?);

// Instantiate a new transaction with the `Message`
let mut transaction = Transaction::new(message);
// Add the signature of the message
transaction.add_signature(signature.to_bytes());
```

##### Send a transaction to a Solana RPC Node

```rust
use poseidon_client::{RpcClient, TxSendOutcome};

let mut rpc = RpcClient::new();
let send_tx_response = rpc.prepare_transaction(&transaction)?.send().await?;
let send_tx_outcome = TxSendOutcome::parse_tx(send_tx_response);
```

##### Get a Transaction using it's hash

```rust
use poseidon_client::GetTransaction;

let base58_signature = "44stjcK4f7RC7KNCorh9gzhQagpYoT9Tq775UFtYbn5gepRocHEeXrtG2JmzgTYKCx83pfBhWHiwLa6sC7f8Ruft";
let tx_resp = GetTransaction::process(sign).await?;
```

### LICENSE

This library is licensed under `MIT` or `Apache-2.0` and all contributions are licensed under the same licenses.

### CODE OF CONDUCT

While making contributions, adhere to the Rust Code of Conduct