solana_program/pubkey.rs
1//! Safecoin account addresses.
2
3#![allow(clippy::integer_arithmetic)]
4use {
5 crate::{decode_error::DecodeError, hash::hashv, wasm_bindgen},
6 borsh::{BorshDeserialize, BorshSchema, BorshSerialize},
7 bytemuck::{Pod, Zeroable},
8 num_derive::{FromPrimitive, ToPrimitive},
9 std::{
10 convert::{Infallible, TryFrom},
11 fmt, mem,
12 str::FromStr,
13 },
14 thiserror::Error,
15};
16
17/// Number of bytes in a pubkey
18pub const PUBKEY_BYTES: usize = 32;
19/// maximum length of derived `Pubkey` seed
20pub const MAX_SEED_LEN: usize = 32;
21/// Maximum number of seeds
22pub const MAX_SEEDS: usize = 16;
23/// Maximum string length of a base58 encoded pubkey
24const MAX_BASE58_LEN: usize = 44;
25
26const PDA_MARKER: &[u8; 21] = b"ProgramDerivedAddress";
27
28#[derive(Error, Debug, Serialize, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
29pub enum PubkeyError {
30 /// Length of the seed is too long for address generation
31 #[error("Length of the seed is too long for address generation")]
32 MaxSeedLengthExceeded,
33 #[error("Provided seeds do not result in a valid address")]
34 InvalidSeeds,
35 #[error("Provided owner is not allowed")]
36 IllegalOwner,
37}
38impl<T> DecodeError<T> for PubkeyError {
39 fn type_of() -> &'static str {
40 "PubkeyError"
41 }
42}
43impl From<u64> for PubkeyError {
44 fn from(error: u64) -> Self {
45 match error {
46 0 => PubkeyError::MaxSeedLengthExceeded,
47 1 => PubkeyError::InvalidSeeds,
48 _ => panic!("Unsupported PubkeyError"),
49 }
50 }
51}
52
53/// The address of a [Safecoin account][acc].
54///
55/// Some account addresses are [ed25519] public keys, with corresponding secret
56/// keys that are managed off-chain. Often, though, account addresses do not
57/// have corresponding secret keys — as with [_program derived
58/// addresses_][pdas] — or the secret key is not relevant to the operation
59/// of a program, and may have even been disposed of. As running Safecoin programs
60/// can not safely create or manage secret keys, the full [`Keypair`] is not
61/// defined in `safecoin-program` but in `safecoin-sdk`.
62///
63/// [acc]: https://docs.solana.com/developing/programming-model/accounts
64/// [ed25519]: https://ed25519.cr.yp.to/
65/// [pdas]: https://docs.solana.com/developing/programming-model/calling-between-programs#program-derived-addresses
66/// [`Keypair`]: https://docs.rs/safecoin-sdk/latest/solana_sdk/signer/keypair/struct.Keypair.html
67#[wasm_bindgen]
68#[repr(transparent)]
69#[derive(
70 AbiExample,
71 BorshDeserialize,
72 BorshSchema,
73 BorshSerialize,
74 Clone,
75 Copy,
76 Default,
77 Deserialize,
78 Eq,
79 Hash,
80 Ord,
81 PartialEq,
82 PartialOrd,
83 Pod,
84 Serialize,
85 Zeroable,
86)]
87pub struct Pubkey(pub(crate) [u8; 32]);
88
89impl crate::sanitize::Sanitize for Pubkey {}
90
91#[derive(Error, Debug, Serialize, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
92pub enum ParsePubkeyError {
93 #[error("String is the wrong size")]
94 WrongSize,
95 #[error("Invalid Base58 string")]
96 Invalid,
97}
98
99impl From<Infallible> for ParsePubkeyError {
100 fn from(_: Infallible) -> Self {
101 unreachable!("Infallible uninhabited");
102 }
103}
104
105impl<T> DecodeError<T> for ParsePubkeyError {
106 fn type_of() -> &'static str {
107 "ParsePubkeyError"
108 }
109}
110
111impl FromStr for Pubkey {
112 type Err = ParsePubkeyError;
113
114 fn from_str(s: &str) -> Result<Self, Self::Err> {
115 if s.len() > MAX_BASE58_LEN {
116 return Err(ParsePubkeyError::WrongSize);
117 }
118 let pubkey_vec = bs58::decode(s)
119 .into_vec()
120 .map_err(|_| ParsePubkeyError::Invalid)?;
121 if pubkey_vec.len() != mem::size_of::<Pubkey>() {
122 Err(ParsePubkeyError::WrongSize)
123 } else {
124 Pubkey::try_from(pubkey_vec).map_err(|_| ParsePubkeyError::Invalid)
125 }
126 }
127}
128
129impl From<[u8; 32]> for Pubkey {
130 #[inline]
131 fn from(from: [u8; 32]) -> Self {
132 Self(from)
133 }
134}
135
136impl TryFrom<&[u8]> for Pubkey {
137 type Error = std::array::TryFromSliceError;
138
139 #[inline]
140 fn try_from(pubkey: &[u8]) -> Result<Self, Self::Error> {
141 <[u8; 32]>::try_from(pubkey).map(Self::from)
142 }
143}
144
145impl TryFrom<Vec<u8>> for Pubkey {
146 type Error = Vec<u8>;
147
148 #[inline]
149 fn try_from(pubkey: Vec<u8>) -> Result<Self, Self::Error> {
150 <[u8; 32]>::try_from(pubkey).map(Self::from)
151 }
152}
153
154impl TryFrom<&str> for Pubkey {
155 type Error = ParsePubkeyError;
156 fn try_from(s: &str) -> Result<Self, Self::Error> {
157 Pubkey::from_str(s)
158 }
159}
160
161pub fn bytes_are_curve_point<T: AsRef<[u8]>>(_bytes: T) -> bool {
162 #[cfg(not(target_os = "solana"))]
163 {
164 curve25519_dalek::edwards::CompressedEdwardsY::from_slice(_bytes.as_ref())
165 .decompress()
166 .is_some()
167 }
168 #[cfg(target_os = "solana")]
169 unimplemented!();
170}
171
172impl Pubkey {
173 #[deprecated(
174 since = "1.14.14",
175 note = "Please use 'Pubkey::from' or 'Pubkey::try_from' instead"
176 )]
177 pub fn new(pubkey_vec: &[u8]) -> Self {
178 Self::try_from(pubkey_vec).expect("Slice must be the same length as a Pubkey")
179 }
180
181 pub const fn new_from_array(pubkey_array: [u8; 32]) -> Self {
182 Self(pubkey_array)
183 }
184
185 #[deprecated(since = "1.3.9", note = "Please use 'Pubkey::new_unique' instead")]
186 #[cfg(not(target_os = "solana"))]
187 pub fn new_rand() -> Self {
188 // Consider removing Pubkey::new_rand() entirely in the v1.5 or v1.6 timeframe
189 Pubkey::from(rand::random::<[u8; 32]>())
190 }
191
192 /// unique Pubkey for tests and benchmarks.
193 pub fn new_unique() -> Self {
194 use crate::atomic_u64::AtomicU64;
195 static I: AtomicU64 = AtomicU64::new(1);
196
197 let mut b = [0u8; 32];
198 let i = I.fetch_add(1);
199 // use big endian representation to ensure that recent unique pubkeys
200 // are always greater than less recent unique pubkeys
201 b[0..8].copy_from_slice(&i.to_be_bytes());
202 Self::from(b)
203 }
204
205 pub fn create_with_seed(
206 base: &Pubkey,
207 seed: &str,
208 owner: &Pubkey,
209 ) -> Result<Pubkey, PubkeyError> {
210 if seed.len() > MAX_SEED_LEN {
211 return Err(PubkeyError::MaxSeedLengthExceeded);
212 }
213
214 let owner = owner.as_ref();
215 if owner.len() >= PDA_MARKER.len() {
216 let slice = &owner[owner.len() - PDA_MARKER.len()..];
217 if slice == PDA_MARKER {
218 return Err(PubkeyError::IllegalOwner);
219 }
220 }
221 let hash = hashv(&[base.as_ref(), seed.as_ref(), owner]);
222 Ok(Pubkey::from(hash.to_bytes()))
223 }
224
225 /// Find a valid [program derived address][pda] and its corresponding bump seed.
226 ///
227 /// [pda]: https://docs.solana.com/developing/programming-model/calling-between-programs#program-derived-addresses
228 ///
229 /// Program derived addresses (PDAs) are account keys that only the program,
230 /// `program_id`, has the authority to sign. The address is of the same form
231 /// as a Safecoin `Pubkey`, except they are ensured to not be on the ed25519
232 /// curve and thus have no associated private key. When performing
233 /// cross-program invocations the program can "sign" for the key by calling
234 /// [`invoke_signed`] and passing the same seeds used to generate the
235 /// address, along with the calculated _bump seed_, which this function
236 /// returns as the second tuple element. The runtime will verify that the
237 /// program associated with this address is the caller and thus authorized
238 /// to be the signer.
239 ///
240 /// [`invoke_signed`]: crate::program::invoke_signed
241 ///
242 /// The `seeds` are application-specific, and must be carefully selected to
243 /// uniquely derive accounts per application requirements. It is common to
244 /// use static strings and other pubkeys as seeds.
245 ///
246 /// Because the program address must not lie on the ed25519 curve, there may
247 /// be seed and program id combinations that are invalid. For this reason,
248 /// an extra seed (the bump seed) is calculated that results in a
249 /// point off the curve. The bump seed must be passed as an additional seed
250 /// when calling `invoke_signed`.
251 ///
252 /// The processes of finding a valid program address is by trial and error,
253 /// and even though it is deterministic given a set of inputs it can take a
254 /// variable amount of time to succeed across different inputs. This means
255 /// that when called from an on-chain program it may incur a variable amount
256 /// of the program's compute budget. Programs that are meant to be very
257 /// performant may not want to use this function because it could take a
258 /// considerable amount of time. Programs that are already at risk
259 /// of exceeding their compute budget should call this with care since
260 /// there is a chance that the program's budget may be occasionally
261 /// and unpredictably exceeded.
262 ///
263 /// As all account addresses accessed by an on-chain Safecoin program must be
264 /// explicitly passed to the program, it is typical for the PDAs to be
265 /// derived in off-chain client programs, avoiding the compute cost of
266 /// generating the address on-chain. The address may or may not then be
267 /// verified by re-deriving it on-chain, depending on the requirements of
268 /// the program. This verification may be performed without the overhead of
269 /// re-searching for the bump key by using the [`create_program_address`]
270 /// function.
271 ///
272 /// [`create_program_address`]: Pubkey::create_program_address
273 ///
274 /// **Warning**: Because of the way the seeds are hashed there is a potential
275 /// for program address collisions for the same program id. The seeds are
276 /// hashed sequentially which means that seeds {"abcdef"}, {"abc", "def"},
277 /// and {"ab", "cd", "ef"} will all result in the same program address given
278 /// the same program id. Since the chance of collision is local to a given
279 /// program id, the developer of that program must take care to choose seeds
280 /// that do not collide with each other. For seed schemes that are susceptible
281 /// to this type of hash collision, a common remedy is to insert separators
282 /// between seeds, e.g. transforming {"abc", "def"} into {"abc", "-", "def"}.
283 ///
284 /// # Panics
285 ///
286 /// Panics in the statistically improbable event that a bump seed could not be
287 /// found. Use [`try_find_program_address`] to handle this case.
288 ///
289 /// [`try_find_program_address`]: Pubkey::try_find_program_address
290 ///
291 /// Panics if any of the following are true:
292 ///
293 /// - the number of provided seeds is greater than, _or equal to_, [`MAX_SEEDS`],
294 /// - any individual seed's length is greater than [`MAX_SEED_LEN`].
295 ///
296 /// # Examples
297 ///
298 /// This example illustrates a simple case of creating a "vault" account
299 /// which is derived from the payer account, but owned by an on-chain
300 /// program. The program derived address is derived in an off-chain client
301 /// program, which invokes an on-chain Safecoin program that uses the address
302 /// to create a new account owned and controlled by the program itself.
303 ///
304 /// By convention, the on-chain program will be compiled for use in two
305 /// different contexts: both on-chain, to interpret a custom program
306 /// instruction as a Safecoin transaction; and off-chain, as a library, so
307 /// that clients can share the instruction data structure, constructors, and
308 /// other common code.
309 ///
310 /// First the on-chain Safecoin program:
311 ///
312 /// ```
313 /// # use borsh::{BorshSerialize, BorshDeserialize};
314 /// # use solana_program::{
315 /// # pubkey::Pubkey,
316 /// # entrypoint::ProgramResult,
317 /// # program::invoke_signed,
318 /// # system_instruction,
319 /// # account_info::{
320 /// # AccountInfo,
321 /// # next_account_info,
322 /// # },
323 /// # };
324 /// // The custom instruction processed by our program. It includes the
325 /// // PDA's bump seed, which is derived by the client program. This
326 /// // definition is also imported into the off-chain client program.
327 /// // The computed address of the PDA will be passed to this program via
328 /// // the `accounts` vector of the `Instruction` type.
329 /// #[derive(BorshSerialize, BorshDeserialize, Debug)]
330 /// pub struct InstructionData {
331 /// pub vault_bump_seed: u8,
332 /// pub lamports: u64,
333 /// }
334 ///
335 /// // The size in bytes of a vault account. The client program needs
336 /// // this information to calculate the quantity of lamports necessary
337 /// // to pay for the account's rent.
338 /// pub static VAULT_ACCOUNT_SIZE: u64 = 1024;
339 ///
340 /// // The entrypoint of the on-chain program, as provided to the
341 /// // `entrypoint!` macro.
342 /// fn process_instruction(
343 /// program_id: &Pubkey,
344 /// accounts: &[AccountInfo],
345 /// instruction_data: &[u8],
346 /// ) -> ProgramResult {
347 /// let account_info_iter = &mut accounts.iter();
348 /// let payer = next_account_info(account_info_iter)?;
349 /// // The vault PDA, derived from the payer's address
350 /// let vault = next_account_info(account_info_iter)?;
351 ///
352 /// let mut instruction_data = instruction_data;
353 /// let instr = InstructionData::deserialize(&mut instruction_data)?;
354 /// let vault_bump_seed = instr.vault_bump_seed;
355 /// let lamports = instr.lamports;
356 /// let vault_size = VAULT_ACCOUNT_SIZE;
357 ///
358 /// // Invoke the system program to create an account while virtually
359 /// // signing with the vault PDA, which is owned by this caller program.
360 /// invoke_signed(
361 /// &system_instruction::create_account(
362 /// &payer.key,
363 /// &vault.key,
364 /// lamports,
365 /// vault_size,
366 /// &program_id,
367 /// ),
368 /// &[
369 /// payer.clone(),
370 /// vault.clone(),
371 /// ],
372 /// // A slice of seed slices, each seed slice being the set
373 /// // of seeds used to generate one of the PDAs required by the
374 /// // callee program, the final seed being a single-element slice
375 /// // containing the `u8` bump seed.
376 /// &[
377 /// &[
378 /// b"vault",
379 /// payer.key.as_ref(),
380 /// &[vault_bump_seed],
381 /// ],
382 /// ]
383 /// )?;
384 ///
385 /// Ok(())
386 /// }
387 /// ```
388 ///
389 /// The client program:
390 ///
391 /// ```
392 /// # use borsh::{BorshSerialize, BorshDeserialize};
393 /// # use solana_program::example_mocks::{solana_sdk, safecoin_client};
394 /// # use solana_program::{
395 /// # pubkey::Pubkey,
396 /// # instruction::Instruction,
397 /// # hash::Hash,
398 /// # instruction::AccountMeta,
399 /// # system_program,
400 /// # };
401 /// # use solana_sdk::{
402 /// # signature::Keypair,
403 /// # signature::{Signer, Signature},
404 /// # transaction::Transaction,
405 /// # };
406 /// # use safecoin_client::rpc_client::RpcClient;
407 /// # use std::convert::TryFrom;
408 /// # use anyhow::Result;
409 /// #
410 /// # #[derive(BorshSerialize, BorshDeserialize, Debug)]
411 /// # struct InstructionData {
412 /// # pub vault_bump_seed: u8,
413 /// # pub lamports: u64,
414 /// # }
415 /// #
416 /// # pub static VAULT_ACCOUNT_SIZE: u64 = 1024;
417 /// #
418 /// fn create_vault_account(
419 /// client: &RpcClient,
420 /// program_id: Pubkey,
421 /// payer: &Keypair,
422 /// ) -> Result<()> {
423 /// // Derive the PDA from the payer account, a string representing the unique
424 /// // purpose of the account ("vault"), and the address of our on-chain program.
425 /// let (vault_pubkey, vault_bump_seed) = Pubkey::find_program_address(
426 /// &[b"vault", payer.pubkey().as_ref()],
427 /// &program_id
428 /// );
429 ///
430 /// // Get the amount of lamports needed to pay for the vault's rent
431 /// let vault_account_size = usize::try_from(VAULT_ACCOUNT_SIZE)?;
432 /// let lamports = client.get_minimum_balance_for_rent_exemption(vault_account_size)?;
433 ///
434 /// // The on-chain program's instruction data, imported from that program's crate.
435 /// let instr_data = InstructionData {
436 /// vault_bump_seed,
437 /// lamports,
438 /// };
439 ///
440 /// // The accounts required by both our on-chain program and the system program's
441 /// // `create_account` instruction, including the vault's address.
442 /// let accounts = vec![
443 /// AccountMeta::new(payer.pubkey(), true),
444 /// AccountMeta::new(vault_pubkey, false),
445 /// AccountMeta::new(system_program::ID, false),
446 /// ];
447 ///
448 /// // Create the instruction by serializing our instruction data via borsh
449 /// let instruction = Instruction::new_with_borsh(
450 /// program_id,
451 /// &instr_data,
452 /// accounts,
453 /// );
454 ///
455 /// let blockhash = client.get_latest_blockhash()?;
456 ///
457 /// let transaction = Transaction::new_signed_with_payer(
458 /// &[instruction],
459 /// Some(&payer.pubkey()),
460 /// &[payer],
461 /// blockhash,
462 /// );
463 ///
464 /// client.send_and_confirm_transaction(&transaction)?;
465 ///
466 /// Ok(())
467 /// }
468 /// # let program_id = Pubkey::new_unique();
469 /// # let payer = Keypair::new();
470 /// # let client = RpcClient::new(String::new());
471 /// #
472 /// # create_vault_account(&client, program_id, &payer)?;
473 /// #
474 /// # Ok::<(), anyhow::Error>(())
475 /// ```
476 pub fn find_program_address(seeds: &[&[u8]], program_id: &Pubkey) -> (Pubkey, u8) {
477 Self::try_find_program_address(seeds, program_id)
478 .unwrap_or_else(|| panic!("Unable to find a viable program address bump seed"))
479 }
480
481 /// Find a valid [program derived address][pda] and its corresponding bump seed.
482 ///
483 /// [pda]: https://docs.solana.com/developing/programming-model/calling-between-programs#program-derived-addresses
484 ///
485 /// The only difference between this method and [`find_program_address`]
486 /// is that this one returns `None` in the statistically improbable event
487 /// that a bump seed cannot be found; or if any of `find_program_address`'s
488 /// preconditions are violated.
489 ///
490 /// See the documentation for [`find_program_address`] for a full description.
491 ///
492 /// [`find_program_address`]: Pubkey::find_program_address
493 #[allow(clippy::same_item_push)]
494 pub fn try_find_program_address(seeds: &[&[u8]], program_id: &Pubkey) -> Option<(Pubkey, u8)> {
495 // Perform the calculation inline, calling this from within a program is
496 // not supported
497 #[cfg(not(target_os = "solana"))]
498 {
499 let mut bump_seed = [std::u8::MAX];
500 for _ in 0..std::u8::MAX {
501 {
502 let mut seeds_with_bump = seeds.to_vec();
503 seeds_with_bump.push(&bump_seed);
504 match Self::create_program_address(&seeds_with_bump, program_id) {
505 Ok(address) => return Some((address, bump_seed[0])),
506 Err(PubkeyError::InvalidSeeds) => (),
507 _ => break,
508 }
509 }
510 bump_seed[0] -= 1;
511 }
512 None
513 }
514 // Call via a system call to perform the calculation
515 #[cfg(target_os = "solana")]
516 {
517 let mut bytes = [0; 32];
518 let mut bump_seed = std::u8::MAX;
519 let result = unsafe {
520 crate::syscalls::sol_try_find_program_address(
521 seeds as *const _ as *const u8,
522 seeds.len() as u64,
523 program_id as *const _ as *const u8,
524 &mut bytes as *mut _ as *mut u8,
525 &mut bump_seed as *mut _ as *mut u8,
526 )
527 };
528 match result {
529 crate::entrypoint::SUCCESS => Some((Pubkey::from(bytes), bump_seed)),
530 _ => None,
531 }
532 }
533 }
534
535 /// Create a valid [program derived address][pda] without searching for a bump seed.
536 ///
537 /// [pda]: https://docs.solana.com/developing/programming-model/calling-between-programs#program-derived-addresses
538 ///
539 /// Because this function does not create a bump seed, it may unpredictably
540 /// return an error for any given set of seeds and is not generally suitable
541 /// for creating program derived addresses.
542 ///
543 /// However, it can be used for efficiently verifying that a set of seeds plus
544 /// bump seed generated by [`find_program_address`] derives a particular
545 /// address as expected. See the example for details.
546 ///
547 /// See the documentation for [`find_program_address`] for a full description
548 /// of program derived addresses and bump seeds.
549 ///
550 /// [`find_program_address`]: Pubkey::find_program_address
551 ///
552 /// # Examples
553 ///
554 /// Creating a program derived address involves iteratively searching for a
555 /// bump seed for which the derived [`Pubkey`] does not lie on the ed25519
556 /// curve. This search process is generally performed off-chain, with the
557 /// [`find_program_address`] function, after which the client passes the
558 /// bump seed to the program as instruction data.
559 ///
560 /// Depending on the application requirements, a program may wish to verify
561 /// that the set of seeds, plus the bump seed, do correctly generate an
562 /// expected address.
563 ///
564 /// The verification is performed by appending to the other seeds one
565 /// additional seed slice that contains the single `u8` bump seed, calling
566 /// `create_program_address`, checking that the return value is `Ok`, and
567 /// that the returned `Pubkey` has the expected value.
568 ///
569 /// ```
570 /// # use solana_program::pubkey::Pubkey;
571 /// # let program_id = Pubkey::new_unique();
572 /// let (expected_pda, bump_seed) = Pubkey::find_program_address(&[b"vault"], &program_id);
573 /// let actual_pda = Pubkey::create_program_address(&[b"vault", &[bump_seed]], &program_id)?;
574 /// assert_eq!(expected_pda, actual_pda);
575 /// # Ok::<(), anyhow::Error>(())
576 /// ```
577 pub fn create_program_address(
578 seeds: &[&[u8]],
579 program_id: &Pubkey,
580 ) -> Result<Pubkey, PubkeyError> {
581 if seeds.len() > MAX_SEEDS {
582 return Err(PubkeyError::MaxSeedLengthExceeded);
583 }
584 for seed in seeds.iter() {
585 if seed.len() > MAX_SEED_LEN {
586 return Err(PubkeyError::MaxSeedLengthExceeded);
587 }
588 }
589
590 // Perform the calculation inline, calling this from within a program is
591 // not supported
592 #[cfg(not(target_os = "solana"))]
593 {
594 let mut hasher = crate::hash::Hasher::default();
595 for seed in seeds.iter() {
596 hasher.hash(seed);
597 }
598 hasher.hashv(&[program_id.as_ref(), PDA_MARKER]);
599 let hash = hasher.result();
600
601 if bytes_are_curve_point(hash) {
602 return Err(PubkeyError::InvalidSeeds);
603 }
604
605 Ok(Pubkey::from(hash.to_bytes()))
606 }
607 // Call via a system call to perform the calculation
608 #[cfg(target_os = "solana")]
609 {
610 let mut bytes = [0; 32];
611 let result = unsafe {
612 crate::syscalls::sol_create_program_address(
613 seeds as *const _ as *const u8,
614 seeds.len() as u64,
615 program_id as *const _ as *const u8,
616 &mut bytes as *mut _ as *mut u8,
617 )
618 };
619 match result {
620 crate::entrypoint::SUCCESS => Ok(Pubkey::from(bytes)),
621 _ => Err(result.into()),
622 }
623 }
624 }
625
626 pub fn to_bytes(self) -> [u8; 32] {
627 self.0
628 }
629
630 pub fn is_on_curve(&self) -> bool {
631 bytes_are_curve_point(self)
632 }
633
634 /// Log a `Pubkey` from a program
635 pub fn log(&self) {
636 #[cfg(target_os = "solana")]
637 unsafe {
638 crate::syscalls::sol_log_pubkey(self.as_ref() as *const _ as *const u8)
639 };
640
641 #[cfg(not(target_os = "solana"))]
642 crate::program_stubs::sol_log(&self.to_string());
643 }
644}
645
646impl AsRef<[u8]> for Pubkey {
647 fn as_ref(&self) -> &[u8] {
648 &self.0[..]
649 }
650}
651
652impl AsMut<[u8]> for Pubkey {
653 fn as_mut(&mut self) -> &mut [u8] {
654 &mut self.0[..]
655 }
656}
657
658impl fmt::Debug for Pubkey {
659 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
660 write!(f, "{}", bs58::encode(self.0).into_string())
661 }
662}
663
664impl fmt::Display for Pubkey {
665 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
666 write!(f, "{}", bs58::encode(self.0).into_string())
667 }
668}
669
670#[cfg(test)]
671mod tests {
672 use {super::*, std::str::from_utf8};
673
674 #[test]
675 fn test_new_unique() {
676 assert!(Pubkey::new_unique() != Pubkey::new_unique());
677 }
678
679 #[test]
680 fn pubkey_fromstr() {
681 let pubkey = Pubkey::new_unique();
682 let mut pubkey_base58_str = bs58::encode(pubkey.0).into_string();
683
684 assert_eq!(pubkey_base58_str.parse::<Pubkey>(), Ok(pubkey));
685
686 pubkey_base58_str.push_str(&bs58::encode(pubkey.0).into_string());
687 assert_eq!(
688 pubkey_base58_str.parse::<Pubkey>(),
689 Err(ParsePubkeyError::WrongSize)
690 );
691
692 pubkey_base58_str.truncate(pubkey_base58_str.len() / 2);
693 assert_eq!(pubkey_base58_str.parse::<Pubkey>(), Ok(pubkey));
694
695 pubkey_base58_str.truncate(pubkey_base58_str.len() / 2);
696 assert_eq!(
697 pubkey_base58_str.parse::<Pubkey>(),
698 Err(ParsePubkeyError::WrongSize)
699 );
700
701 let mut pubkey_base58_str = bs58::encode(pubkey.0).into_string();
702 assert_eq!(pubkey_base58_str.parse::<Pubkey>(), Ok(pubkey));
703
704 // throw some non-base58 stuff in there
705 pubkey_base58_str.replace_range(..1, "I");
706 assert_eq!(
707 pubkey_base58_str.parse::<Pubkey>(),
708 Err(ParsePubkeyError::Invalid)
709 );
710
711 // too long input string
712 // longest valid encoding
713 let mut too_long = bs58::encode(&[255u8; PUBKEY_BYTES]).into_string();
714 // and one to grow on
715 too_long.push('1');
716 assert_eq!(too_long.parse::<Pubkey>(), Err(ParsePubkeyError::WrongSize));
717 }
718
719 #[test]
720 fn test_create_with_seed() {
721 assert!(
722 Pubkey::create_with_seed(&Pubkey::new_unique(), "☉", &Pubkey::new_unique()).is_ok()
723 );
724 assert_eq!(
725 Pubkey::create_with_seed(
726 &Pubkey::new_unique(),
727 from_utf8(&[127; MAX_SEED_LEN + 1]).unwrap(),
728 &Pubkey::new_unique()
729 ),
730 Err(PubkeyError::MaxSeedLengthExceeded)
731 );
732 assert!(Pubkey::create_with_seed(
733 &Pubkey::new_unique(),
734 "\
735 \u{10FFFF}\u{10FFFF}\u{10FFFF}\u{10FFFF}\u{10FFFF}\u{10FFFF}\u{10FFFF}\u{10FFFF}\
736 ",
737 &Pubkey::new_unique()
738 )
739 .is_ok());
740 // utf-8 abuse ;)
741 assert_eq!(
742 Pubkey::create_with_seed(
743 &Pubkey::new_unique(),
744 "\
745 x\u{10FFFF}\u{10FFFF}\u{10FFFF}\u{10FFFF}\u{10FFFF}\u{10FFFF}\u{10FFFF}\u{10FFFF}\
746 ",
747 &Pubkey::new_unique()
748 ),
749 Err(PubkeyError::MaxSeedLengthExceeded)
750 );
751
752 assert!(Pubkey::create_with_seed(
753 &Pubkey::new_unique(),
754 std::str::from_utf8(&[0; MAX_SEED_LEN]).unwrap(),
755 &Pubkey::new_unique(),
756 )
757 .is_ok());
758
759 assert!(
760 Pubkey::create_with_seed(&Pubkey::new_unique(), "", &Pubkey::new_unique(),).is_ok()
761 );
762
763 assert_eq!(
764 Pubkey::create_with_seed(
765 &Pubkey::default(),
766 "limber chicken: 4/45",
767 &Pubkey::default(),
768 ),
769 Ok("9h1HyLCW5dZnBVap8C5egQ9Z6pHyjsh5MNy83iPqqRuq"
770 .parse()
771 .unwrap())
772 );
773 }
774
775 #[test]
776 fn test_create_program_address() {
777 let exceeded_seed = &[127; MAX_SEED_LEN + 1];
778 let max_seed = &[0; MAX_SEED_LEN];
779 let exceeded_seeds: &[&[u8]] = &[
780 &[1],
781 &[2],
782 &[3],
783 &[4],
784 &[5],
785 &[6],
786 &[7],
787 &[8],
788 &[9],
789 &[10],
790 &[11],
791 &[12],
792 &[13],
793 &[14],
794 &[15],
795 &[16],
796 &[17],
797 ];
798 let max_seeds: &[&[u8]] = &[
799 &[1],
800 &[2],
801 &[3],
802 &[4],
803 &[5],
804 &[6],
805 &[7],
806 &[8],
807 &[9],
808 &[10],
809 &[11],
810 &[12],
811 &[13],
812 &[14],
813 &[15],
814 &[16],
815 ];
816 let program_id = Pubkey::from_str("BPFLoaderUpgradeab1e11111111111111111111111").unwrap();
817 let public_key = Pubkey::from_str("SeedPubey1111111111111111111111111111111111").unwrap();
818
819 assert_eq!(
820 Pubkey::create_program_address(&[exceeded_seed], &program_id),
821 Err(PubkeyError::MaxSeedLengthExceeded)
822 );
823 assert_eq!(
824 Pubkey::create_program_address(&[b"short_seed", exceeded_seed], &program_id),
825 Err(PubkeyError::MaxSeedLengthExceeded)
826 );
827 assert!(Pubkey::create_program_address(&[max_seed], &program_id).is_ok());
828 assert_eq!(
829 Pubkey::create_program_address(exceeded_seeds, &program_id),
830 Err(PubkeyError::MaxSeedLengthExceeded)
831 );
832 assert!(Pubkey::create_program_address(max_seeds, &program_id).is_ok());
833 assert_eq!(
834 Pubkey::create_program_address(&[b"", &[1]], &program_id),
835 Ok("BwqrghZA2htAcqq8dzP1WDAhTXYTYWj7CHxF5j7TDBAe"
836 .parse()
837 .unwrap())
838 );
839 assert_eq!(
840 Pubkey::create_program_address(&["☉".as_ref(), &[0]], &program_id),
841 Ok("13yWmRpaTR4r5nAktwLqMpRNr28tnVUZw26rTvPSSB19"
842 .parse()
843 .unwrap())
844 );
845 assert_eq!(
846 Pubkey::create_program_address(&[b"Talking", b"Squirrels"], &program_id),
847 Ok("2fnQrngrQT4SeLcdToJAD96phoEjNL2man2kfRLCASVk"
848 .parse()
849 .unwrap())
850 );
851 assert_eq!(
852 Pubkey::create_program_address(&[public_key.as_ref(), &[1]], &program_id),
853 Ok("976ymqVnfE32QFe6NfGDctSvVa36LWnvYxhU6G2232YL"
854 .parse()
855 .unwrap())
856 );
857 assert_ne!(
858 Pubkey::create_program_address(&[b"Talking", b"Squirrels"], &program_id).unwrap(),
859 Pubkey::create_program_address(&[b"Talking"], &program_id).unwrap(),
860 );
861 }
862
863 #[test]
864 fn test_pubkey_off_curve() {
865 // try a bunch of random input, all successful generated program
866 // addresses must land off the curve and be unique
867 let mut addresses = vec![];
868 for _ in 0..1_000 {
869 let program_id = Pubkey::new_unique();
870 let bytes1 = rand::random::<[u8; 10]>();
871 let bytes2 = rand::random::<[u8; 32]>();
872 if let Ok(program_address) =
873 Pubkey::create_program_address(&[&bytes1, &bytes2], &program_id)
874 {
875 let is_on_curve = curve25519_dalek::edwards::CompressedEdwardsY::from_slice(
876 &program_address.to_bytes(),
877 )
878 .decompress()
879 .is_some();
880 assert!(!is_on_curve);
881 assert!(!addresses.contains(&program_address));
882 addresses.push(program_address);
883 }
884 }
885 }
886
887 #[test]
888 fn test_find_program_address() {
889 for _ in 0..1_000 {
890 let program_id = Pubkey::new_unique();
891 let (address, bump_seed) =
892 Pubkey::find_program_address(&[b"Lil'", b"Bits"], &program_id);
893 assert_eq!(
894 address,
895 Pubkey::create_program_address(&[b"Lil'", b"Bits", &[bump_seed]], &program_id)
896 .unwrap()
897 );
898 }
899 }
900
901 fn pubkey_from_seed_by_marker(marker: &[u8]) -> Result<Pubkey, PubkeyError> {
902 let key = Pubkey::new_unique();
903 let owner = Pubkey::default();
904
905 let mut to_fake = owner.to_bytes().to_vec();
906 to_fake.extend_from_slice(marker);
907
908 let seed = &String::from_utf8(to_fake[..to_fake.len() - 32].to_vec()).expect("not utf8");
909 let base = &Pubkey::try_from_slice(&to_fake[to_fake.len() - 32..]).unwrap();
910
911 Pubkey::create_with_seed(&key, seed, base)
912 }
913
914 #[test]
915 fn test_create_with_seed_rejects_illegal_owner() {
916 assert_eq!(
917 pubkey_from_seed_by_marker(PDA_MARKER),
918 Err(PubkeyError::IllegalOwner)
919 );
920 assert!(pubkey_from_seed_by_marker(&PDA_MARKER[1..]).is_ok());
921 }
922}