wallet_standard_wallets 0.1.12

A collection of solana wallet implementations primarily used for testing.
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

#![cfg(feature = "ssr")]

use anyhow::Result;
use assert2::check;
use solana_sdk::account::Account;
use solana_sdk::commitment_config::CommitmentConfig;
use solana_sdk::hash::Hash;
use solana_sdk::native_token::sol_to_lamports;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::Keypair;
use solana_sdk::signature::Signature;
use solana_sdk::system_instruction::transfer;
use solana_sdk::transaction::VersionedTransaction;
use test_log::test;
use test_utils::SECRET_KEY_WALLET;
use test_utils_solana::ProgramTest;
use test_utils_solana::ProgramTestContext;
use test_utils_solana::TestValidatorRunner;
use test_utils_solana::TestValidatorRunnerProps;
use test_utils_solana::prelude::*;
use wallet_standard::SolanaSignAndSendTransactionProps;
use wallet_standard::SolanaSignTransactionProps;
use wallet_standard_wallets::MemoryWallet;
use wasm_client_solana::LOCALNET;
use wasm_client_solana::SolanaRpcClient;

#[test(tokio::test)]
async fn sign_transaction() -> Result<()> {
	let runner = create_runner().await;
	let keypair = get_wallet_keypair();
	let pubkey = keypair.pubkey();
	let target_pubkey = Pubkey::new_unique();
	let instruction = transfer(&pubkey, &target_pubkey, sol_to_lamports(0.5));
	let blockhash = runner.rpc().get_latest_blockhash().await?;
	let rpc = runner.rpc().clone();
	let transaction =
		VersionedTransaction::new_unsigned_v0(&pubkey, &[instruction], &[], blockhash)?;
	let mut memory_wallet = MemoryWallet::new(rpc, &[keypair]);

	memory_wallet.connect().await?;

	let props = SolanaSignTransactionProps::builder()
		.transaction(transaction)
		.build();
	let signed_transaction = memory_wallet.sign_transaction(props).await?;

	check!(signed_transaction.is_signed());

	Ok(())
}

#[test(tokio::test)]
async fn sign_and_send_transaction() -> Result<()> {
	let runner = create_runner().await;
	let keypair = get_wallet_keypair();
	let pubkey = keypair.pubkey();
	let target_pubkey = Pubkey::new_unique();
	let instruction = transfer(&pubkey, &target_pubkey, sol_to_lamports(0.5));
	let rpc = runner.rpc().clone();
	let blockhash = rpc.get_latest_blockhash().await?;
	let transaction =
		VersionedTransaction::new_unsigned_v0(&pubkey, &[instruction], &[], blockhash)?;
	let mut memory_wallet = MemoryWallet::new(rpc, &[keypair]);

	memory_wallet.connect().await?;

	log::info!("sending transaction: {transaction:#?}");
	let props = SolanaSignAndSendTransactionProps::builder()
		.transaction(transaction)
		.build();
	let signature = memory_wallet.sign_and_send_transaction(props).await?;
	log::info!("transaction successfully sent: {signature}");

	check!(signature != Signature::default());

	Ok(())
}

#[test(tokio::test)]
async fn banks_client_process_transaction() -> Result<()> {
	let keypair = get_wallet_keypair();
	let pubkey = keypair.pubkey();
	let target_pubkey = Pubkey::new_unique();
	let (mut ctx, rpc) = create_program_test().await;
	let mut wallet = MemoryWallet::new(rpc, &[keypair]);
	let instruction = transfer(&pubkey, &target_pubkey, sol_to_lamports(0.5));

	wallet.connect().await?;

	let transaction =
		VersionedTransaction::new_unsigned_v0(&pubkey, &[instruction], &[], Hash::default())?;
	let props = SolanaSignAndSendTransactionProps::builder()
		.transaction(transaction)
		.build();
	let result = ctx
		.banks_client
		.wallet_sign_and_process_transaction(&wallet, props)
		.await?;

	log::info!("{result:#?}");

	Ok(())
}

#[test(tokio::test)]
async fn banks_client_simulate_transaction() -> Result<()> {
	let keypair = get_wallet_keypair();
	let pubkey = keypair.pubkey();
	let target_pubkey = Pubkey::new_unique();
	let (mut ctx, rpc) = create_program_test().await;
	let mut wallet = MemoryWallet::new(rpc, &[keypair]);
	let instruction = transfer(&pubkey, &target_pubkey, sol_to_lamports(0.5));

	wallet.connect().await?;

	let transaction =
		VersionedTransaction::new_unsigned_v0(&pubkey, &[instruction], &[], Hash::default())?;
	let props = SolanaSignAndSendTransactionProps::builder()
		.transaction(transaction)
		.build();
	let result = ctx
		.banks_client
		.wallet_sign_and_simulate_transaction(&wallet, props)
		.await?;

	log::info!("{result:#?}");

	Ok(())
}

async fn create_runner() -> TestValidatorRunner {
	let pubkey = get_wallet_keypair().pubkey();
	TestValidatorRunner::run(
		TestValidatorRunnerProps::builder()
			.pubkeys(vec![pubkey])
			.build(),
	)
	.await
}

async fn create_program_test() -> (ProgramTestContext, SolanaRpcClient) {
	let pubkey = get_wallet_keypair().pubkey();
	let mut program_test = ProgramTest::default();
	let rpc = SolanaRpcClient::new_with_commitment(LOCALNET, CommitmentConfig::finalized());

	program_test.add_account(pubkey, Account {
		lamports: sol_to_lamports(1.0),
		..Account::default()
	});

	let ctx = program_test.start_with_context().await;

	(ctx, rpc)
}

pub fn get_wallet_keypair() -> Keypair {
	Keypair::from_bytes(&SECRET_KEY_WALLET).unwrap()
}