blockworks-foundation
/
solana
mirror of https://github.com/blockworks-foundation/solana.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

deprecates Signature::new in favor of Signature::{try_,}from (#32481)

This commit is contained in:
behzad nouri 2023-07-14 22:51:12 +00:00 committed by GitHub
parent 78230050fb
commit cfb028819a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
19 changed files with 137 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
banking-bench/src/main.rs
View File

@ -134,7 +134,7 @@ fn make_accounts_txs(
hash,
compute_unit_price,
);
let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen::<u8>()).collect();
let sig: [u8; 64] = std::array::from_fn(|_| thread_rng().gen::<u8>());
new.message.account_keys[0] = pubkey::new_rand();
new.message.account_keys[1] = match contention {
WriteLockContention::None => pubkey::new_rand(),
@ -148,7 +148,7 @@ fn make_accounts_txs(
}
WriteLockContention::Full => to_pubkey,
};
new.signatures = vec![Signature::new(&sig[0..64])];
new.signatures = vec![Signature::from(sig)];
new
})
.collect()
@ -220,8 +220,8 @@ impl PacketsPerIteration {
fn refresh_blockhash(&mut self, new_blockhash: Hash) {
for tx in self.transactions.iter_mut() {
tx.message.recent_blockhash = new_blockhash;
let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen::<u8>()).collect();
tx.signatures[0] = Signature::new(&sig[0..64]);
let sig: [u8; 64] = std::array::from_fn(|_| thread_rng().gen::<u8>());
tx.signatures[0] = Signature::from(sig);
}
self.packet_batches = to_packet_batches(&self.transactions, self.packets_per_batch);
}
@ -377,8 +377,8 @@ fn main() {
genesis_config.hash(),
);
// Ignore any pesky duplicate signature errors in the case we are using single-payer
let sig: Vec<u8> = (0..64).map(|_| thread_rng().gen::<u8>()).collect();
fund.signatures = vec![Signature::new(&sig[0..64])];
let sig: [u8; 64] = std::array::from_fn(|_| thread_rng().gen::<u8>());
fund.signatures = vec![Signature::from(sig)];
bank.process_transaction(&fund).unwrap();
});
});

4
bloom/benches/bloom.rs
View File

@ -61,7 +61,7 @@ fn bench_sigs_bloom(bencher: &mut Bencher) {
id = hash(id.as_ref());
sigbytes.extend(id.as_ref());
let sig = Signature::new(&sigbytes);
let sig = Signature::try_from(sigbytes).unwrap();
if sigs.contains(&sig) {
falses += 1;
}
@ -89,7 +89,7 @@ fn bench_sigs_hashmap(bencher: &mut Bencher) {
id = hash(id.as_ref());
sigbytes.extend(id.as_ref());
let sig = Signature::new(&sigbytes);
let sig = Signature::try_from(sigbytes).unwrap();
if sigs.contains(&sig) {
falses += 1;
}

2
cli-output/src/cli_output.rs
View File

@ -3052,7 +3052,7 @@ mod tests {
}
fn try_sign_message(&self, _message: &[u8]) -> Result<Signature, SignerError> {
Ok(Signature::new(&[1u8; 64]))
Ok(Signature::from([1u8; 64]))
}
fn is_interactive(&self) -> bool {

20
cli/src/cli.rs
View File

@ -1898,7 +1898,7 @@ mod tests {
);
// Test Confirm Subcommand
let signature = Signature::new(&[1; 64]);
let signature = Signature::from([1; 64]);
let signature_string = format!("{signature:?}");
let test_confirm =
test_commands
@ -2053,7 +2053,11 @@ mod tests {
};
assert_eq!(process_command(&config).unwrap(), "0.00000005 SOL");
let good_signature = Signature::new(&bs58::decode(SIGNATURE).into_vec().unwrap());
let good_signature = bs58::decode(SIGNATURE)
.into_vec()
.map(Signature::try_from)
.unwrap()
.unwrap();
config.command = CliCommand::Confirm(good_signature);
assert_eq!(
process_command(&config).unwrap(),
@ -2283,13 +2287,21 @@ mod tests {
// sig_not_found case
config.rpc_client = Some(Arc::new(RpcClient::new_mock("sig_not_found".to_string())));
let missing_signature = Signature::new(&bs58::decode("5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpRzrFmBV6UjKdiSZkQUW").into_vec().unwrap());
let missing_signature = bs58::decode("5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpRzrFmBV6UjKdiSZkQUW")
.into_vec()
.map(Signature::try_from)
.unwrap()
.unwrap();
config.command = CliCommand::Confirm(missing_signature);
assert_eq!(process_command(&config).unwrap(), "Not found");
// Tx error case
config.rpc_client = Some(Arc::new(RpcClient::new_mock("account_in_use".to_string())));
let any_signature = Signature::new(&bs58::decode(SIGNATURE).into_vec().unwrap());
let any_signature = bs58::decode(SIGNATURE)
.into_vec()
.map(Signature::try_from)
.unwrap()
.unwrap();
config.command = CliCommand::Confirm(any_signature);
assert_eq!(
process_command(&config).unwrap(),

4
core/benches/banking_stage.rs
View File

@ -132,10 +132,10 @@ fn make_accounts_txs(txes: usize, mint_keypair: &Keypair, hash: Hash) -> Vec<Tra
.into_par_iter()
.map(|_| {
let mut new = dummy.clone();
let sig: Vec<_> = (0..64).map(|_| thread_rng().gen::<u8>()).collect();
let sig: [u8; 64] = std::array::from_fn(|_| thread_rng().gen::<u8>());
new.message.account_keys[0] = pubkey::new_rand();
new.message.account_keys[1] = pubkey::new_rand();
new.signatures = vec![Signature::new(&sig[0..64])];
new.signatures = vec![Signature::from(sig)];
new
})
.collect()

30
core/src/verified_vote_packets.rs
View File

@ -337,7 +337,7 @@ mod tests {
vote_account_key,
vote: VoteTransaction::from(vote.clone()),
packet_batch: PacketBatch::default(),
signature: Signature::new(&[1u8; 64]),
signature: Signature::from([1u8; 64]),
}])
.unwrap();
verified_vote_packets
@ -357,7 +357,7 @@ mod tests {
vote_account_key,
vote: VoteTransaction::from(vote),
packet_batch: PacketBatch::default(),
signature: Signature::new(&[1u8; 64]),
signature: Signature::from([1u8; 64]),
}])
.unwrap();
verified_vote_packets
@ -379,7 +379,7 @@ mod tests {
vote_account_key,
vote: VoteTransaction::from(vote),
packet_batch: PacketBatch::default(),
signature: Signature::new(&[1u8; 64]),
signature: Signature::from([1u8; 64]),
}])
.unwrap();
verified_vote_packets
@ -402,7 +402,7 @@ mod tests {
vote_account_key,
vote: VoteTransaction::from(vote),
packet_batch: PacketBatch::default(),
signature: Signature::new(&[2u8; 64]),
signature: Signature::from([2u8; 64]),
}])
.unwrap();
verified_vote_packets
@ -441,7 +441,7 @@ mod tests {
vote_account_key,
vote: VoteTransaction::from(vote),
packet_batch: PacketBatch::default(),
signature: Signature::new(&[1u8; 64]),
signature: Signature::from([1u8; 64]),
}])
.unwrap();
}
@ -627,7 +627,7 @@ mod tests {
vote_account_key,
vote: VoteTransaction::from(vote),
packet_batch: PacketBatch::default(),
signature: Signature::new(&[1u8; 64]),
signature: Signature::from([1u8; 64]),
}])
.unwrap();
}
@ -650,7 +650,7 @@ mod tests {
vote_account_key,
vote: VoteTransaction::from(third_vote.clone()),
packet_batch: PacketBatch::default(),
signature: Signature::new(&[1u8; 64]),
signature: Signature::from([1u8; 64]),
}])
.unwrap();
@ -670,7 +670,7 @@ mod tests {
vote_account_key,
vote: VoteTransaction::from(vote),
packet_batch: PacketBatch::default(),
signature: Signature::new(&[1u8; 64]),
signature: Signature::from([1u8; 64]),
}])
.unwrap();
}
@ -701,7 +701,7 @@ mod tests {
vote_account_key,
vote: VoteTransaction::from(vote),
packet_batch: PacketBatch::default(),
signature: Signature::new(&[1u8; 64]),
signature: Signature::from([1u8; 64]),
}])
.unwrap();
verified_vote_packets
@ -802,7 +802,7 @@ mod tests {
vote_account_key,
vote,
packet_batch: PacketBatch::default(),
signature: Signature::new(&[1u8; 64]),
signature: Signature::from([1u8; 64]),
}])
.unwrap();
}
@ -837,7 +837,7 @@ mod tests {
vote_account_key,
vote,
packet_batch: PacketBatch::default(),
signature: Signature::new(&[1u8; 64]),
signature: Signature::from([1u8; 64]),
}])
.unwrap();
}
@ -865,7 +865,7 @@ mod tests {
vote_account_key,
vote,
packet_batch: PacketBatch::default(),
signature: Signature::new(&[1u8; 64]),
signature: Signature::from([1u8; 64]),
}])
.unwrap();
@ -894,7 +894,7 @@ mod tests {
vote_account_key,
vote,
packet_batch: PacketBatch::default(),
signature: Signature::new(&[1u8; 64]),
signature: Signature::from([1u8; 64]),
}])
.unwrap();
@ -917,7 +917,7 @@ mod tests {
vote_account_key,
vote,
packet_batch: PacketBatch::default(),
signature: Signature::new(&[1u8; 64]),
signature: Signature::from([1u8; 64]),
}])
.unwrap();
@ -938,7 +938,7 @@ mod tests {
vote_account_key,
vote,
packet_batch: PacketBatch::default(),
signature: Signature::new(&[1u8; 64]),
signature: Signature::from([1u8; 64]),
}])
.unwrap();

56
ledger/src/blockstore.rs
View File

@ -7339,7 +7339,7 @@ pub mod tests {
}
.into();
assert!(transaction_status_cf
.put_protobuf((0, Signature::new(&[2u8; 64]), 9), &status,)
.put_protobuf((0, Signature::from([2u8; 64]), 9), &status,)
.is_ok());
// result found
@ -7359,7 +7359,7 @@ pub mod tests {
} = transaction_status_cf
.get_protobuf_or_bincode::<StoredTransactionStatusMeta>((
0,
Signature::new(&[2u8; 64]),
Signature::from([2u8; 64]),
9,
))
.unwrap()
@ -7396,11 +7396,11 @@ pub mod tests {
assert!(transaction_status_index_cf.get(1).unwrap().is_some());
for _ in 0..5 {
let random_bytes: Vec<u8> = (0..64).map(|_| rand::random::<u8>()).collect();
let random_bytes: [u8; 64] = std::array::from_fn(|_| rand::random::<u8>());
blockstore
.write_transaction_status(
slot0,
Signature::new(&random_bytes),
Signature::from(random_bytes),
vec![&Pubkey::try_from(&random_bytes[..32]).unwrap()],
vec![&Pubkey::try_from(&random_bytes[32..]).unwrap()],
TransactionStatusMeta::default(),
@ -7462,11 +7462,11 @@ pub mod tests {
let slot1 = 20;
for _ in 0..5 {
let random_bytes: Vec<u8> = (0..64).map(|_| rand::random::<u8>()).collect();
let random_bytes: [u8; 64] = std::array::from_fn(|_| rand::random::<u8>());
blockstore
.write_transaction_status(
slot1,
Signature::new(&random_bytes),
Signature::from(random_bytes),
vec![&Pubkey::try_from(&random_bytes[..32]).unwrap()],
vec![&Pubkey::try_from(&random_bytes[32..]).unwrap()],
TransactionStatusMeta::default(),
@ -7613,13 +7613,13 @@ pub mod tests {
}
.into();
let signature1 = Signature::new(&[1u8; 64]);
let signature2 = Signature::new(&[2u8; 64]);
let signature3 = Signature::new(&[3u8; 64]);
let signature4 = Signature::new(&[4u8; 64]);
let signature5 = Signature::new(&[5u8; 64]);
let signature6 = Signature::new(&[6u8; 64]);
let signature7 = Signature::new(&[7u8; 64]);
let signature1 = Signature::from([1u8; 64]);
let signature2 = Signature::from([2u8; 64]);
let signature3 = Signature::from([3u8; 64]);
let signature4 = Signature::from([4u8; 64]);
let signature5 = Signature::from([5u8; 64]);
let signature6 = Signature::from([6u8; 64]);
let signature7 = Signature::from([7u8; 64]);
// Insert slots with fork
// 0 (root)
@ -7807,8 +7807,8 @@ pub mod tests {
}
.into();
let signature1 = Signature::new(&[2u8; 64]);
let signature2 = Signature::new(&[3u8; 64]);
let signature1 = Signature::from([2u8; 64]);
let signature2 = Signature::from([3u8; 64]);
// Insert rooted slots 0..=3 with no fork
let meta0 = SlotMeta::new(0, Some(0));
@ -8179,7 +8179,7 @@ pub mod tests {
let slot0 = 10;
for x in 1..5 {
let signature = Signature::new(&[x; 64]);
let signature = Signature::from([x; 64]);
blockstore
.write_transaction_status(
slot0,
@ -8192,7 +8192,7 @@ pub mod tests {
}
let slot1 = 20;
for x in 5..9 {
let signature = Signature::new(&[x; 64]);
let signature = Signature::from([x; 64]);
blockstore
.write_transaction_status(
slot1,
@ -8210,7 +8210,7 @@ pub mod tests {
.unwrap();
assert_eq!(all0.len(), 8);
for x in 1..9 {
let expected_signature = Signature::new(&[x; 64]);
let expected_signature = Signature::from([x; 64]);
assert_eq!(all0[x as usize - 1], expected_signature);
}
assert_eq!(
@ -8244,7 +8244,7 @@ pub mod tests {
.unwrap();
assert_eq!(all1.len(), 8);
for x in 1..9 {
let expected_signature = Signature::new(&[x; 64]);
let expected_signature = Signature::from([x; 64]);
assert_eq!(all1[x as usize - 1], expected_signature);
}
@ -8284,8 +8284,8 @@ pub mod tests {
// Test sort, regardless of entry order or signature value
for slot in (21..25).rev() {
let random_bytes: Vec<u8> = (0..64).map(|_| rand::random::<u8>()).collect();
let signature = Signature::new(&random_bytes);
let random_bytes: [u8; 64] = std::array::from_fn(|_| rand::random::<u8>());
let signature = Signature::from(random_bytes);
blockstore
.write_transaction_status(
slot,
@ -8314,7 +8314,7 @@ pub mod tests {
let slot1 = 1;
for x in 1..5 {
let signature = Signature::new(&[x; 64]);
let signature = Signature::from([x; 64]);
blockstore
.write_transaction_status(
slot1,
@ -8327,7 +8327,7 @@ pub mod tests {
}
let slot2 = 2;
for x in 5..7 {
let signature = Signature::new(&[x; 64]);
let signature = Signature::from([x; 64]);
blockstore
.write_transaction_status(
slot2,
@ -8339,7 +8339,7 @@ pub mod tests {
.unwrap();
}
for x in 7..9 {
let signature = Signature::new(&[x; 64]);
let signature = Signature::from([x; 64]);
blockstore
.write_transaction_status(
slot2,
@ -8352,7 +8352,7 @@ pub mod tests {
}
let slot3 = 3;
for x in 9..13 {
let signature = Signature::new(&[x; 64]);
let signature = Signature::from([x; 64]);
blockstore
.write_transaction_status(
slot3,
@ -8370,7 +8370,7 @@ pub mod tests {
.unwrap();
for (i, (slot, signature)) in slot1_signatures.iter().enumerate() {
assert_eq!(*slot, slot1);
assert_eq!(*signature, Signature::new(&[i as u8 + 1; 64]));
assert_eq!(*signature, Signature::from([i as u8 + 1; 64]));
}
let slot2_signatures = blockstore
@ -8378,7 +8378,7 @@ pub mod tests {
.unwrap();
for (i, (slot, signature)) in slot2_signatures.iter().enumerate() {
assert_eq!(*slot, slot2);
assert_eq!(*signature, Signature::new(&[i as u8 + 5; 64]));
assert_eq!(*signature, Signature::from([i as u8 + 5; 64]));
}
let slot3_signatures = blockstore
@ -8386,7 +8386,7 @@ pub mod tests {
.unwrap();
for (i, (slot, signature)) in slot3_signatures.iter().enumerate() {
assert_eq!(*slot, slot3);
assert_eq!(*signature, Signature::new(&[i as u8 + 9; 64]));
assert_eq!(*signature, Signature::from([i as u8 + 9; 64]));
}
}

12
ledger/src/blockstore/blockstore_purge.rs
View File

@ -471,11 +471,11 @@ pub mod tests {
let max_slot = 10;
for x in 0..max_slot {
let random_bytes: Vec<u8> = (0..64).map(|_| rand::random::<u8>()).collect();
let random_bytes: [u8; 64] = std::array::from_fn(|_| rand::random::<u8>());
blockstore
.write_transaction_status(
x,
Signature::new(&random_bytes),
Signature::from(random_bytes),
vec![&Pubkey::try_from(&random_bytes[..32]).unwrap()],
vec![&Pubkey::try_from(&random_bytes[32..]).unwrap()],
TransactionStatusMeta::default(),
@ -486,11 +486,11 @@ pub mod tests {
blockstore.run_purge(0, 1, PurgeType::PrimaryIndex).unwrap();
for x in max_slot..2 * max_slot {
let random_bytes: Vec<u8> = (0..64).map(|_| rand::random::<u8>()).collect();
let random_bytes: [u8; 64] = std::array::from_fn(|_| rand::random::<u8>());
blockstore
.write_transaction_status(
x,
Signature::new(&random_bytes),
Signature::from(random_bytes),
vec![&Pubkey::try_from(&random_bytes[..32]).unwrap()],
vec![&Pubkey::try_from(&random_bytes[32..]).unwrap()],
TransactionStatusMeta::default(),
@ -521,11 +521,11 @@ pub mod tests {
let transaction_status_index_cf = &blockstore.transaction_status_index_cf;
let slot = 10;
for _ in 0..5 {
let random_bytes: Vec<u8> = (0..64).map(|_| rand::random::<u8>()).collect();
let random_bytes: [u8; 64] = std::array::from_fn(|_| rand::random::<u8>());
blockstore
.write_transaction_status(
slot,
Signature::new(&random_bytes),
Signature::from(random_bytes),
vec![&Pubkey::try_from(&random_bytes[..32]).unwrap()],
vec![&Pubkey::try_from(&random_bytes[32..]).unwrap()],
TransactionStatusMeta::default(),

6
ledger/src/blockstore_db.rs
View File

@ -693,7 +693,7 @@ impl Column for columns::TransactionStatus {
Self::as_index(0)
} else {
let index = BigEndian::read_u64(&key[0..8]);
let signature = Signature::new(&key[8..72]);
let signature = Signature::try_from(&key[8..72]).unwrap();
let slot = BigEndian::read_u64(&key[72..80]);
(index, signature, slot)
}
@ -734,7 +734,7 @@ impl Column for columns::AddressSignatures {
let index = BigEndian::read_u64(&key[0..8]);
let pubkey = Pubkey::try_from(&key[8..40]).unwrap();
let slot = BigEndian::read_u64(&key[40..48]);
let signature = Signature::new(&key[48..112]);
let signature = Signature::try_from(&key[48..112]).unwrap();
(index, pubkey, slot, signature)
}
@ -764,7 +764,7 @@ impl Column for columns::TransactionMemos {
}
fn index(key: &[u8]) -> Signature {
Signature::new(&key[0..64])
Signature::try_from(&key[..64]).unwrap()
}
fn primary_index(_index: Self::Index) -> u64 {

5
ledger/src/shred.rs
View File

@ -578,7 +578,10 @@ pub mod layout {
}
pub(crate) fn get_signature(shred: &[u8]) -> Option<Signature> {
Some(Signature::new(shred.get(..SIZE_OF_SIGNATURE)?))
shred
.get(..SIZE_OF_SIGNATURE)
.map(Signature::try_from)?
.ok()
}
pub(crate) const fn get_signature_range() -> Range<usize> {

2
ledger/src/shredder.rs
View File

@ -988,7 +988,7 @@ mod tests {
// Also randomize the signatre bytes.
let mut signature = [0u8; 64];
rng.fill(&mut signature[..]);
tx.signatures = vec![Signature::new(&signature)];
tx.signatures = vec![Signature::from(signature)];
tx
})
.take(num_tx)

2
perf/src/sigverify.rs
View File

@ -134,7 +134,7 @@ fn verify_packet(packet: &mut Packet, reject_non_vote: bool) -> bool {
let Some(sig_end) = sig_start.checked_add(size_of::<Signature>()) else {
return false;
};
let Some(signature) = packet.data(sig_start..sig_end).map(Signature::new) else {
let Some(Ok(signature)) = packet.data(sig_start..sig_end).map(Signature::try_from) else {
return false;
};
let Some(pubkey) = packet.data(pubkey_start..pubkey_end) else {

16
remote-wallet/src/ledger.rs
View File

@ -516,12 +516,8 @@ impl RemoteWallet<hidapi::DeviceInfo> for LedgerWallet {
}
}
if result.len() != 64 {
return Err(RemoteWalletError::Protocol(
"Signature packet size mismatch",
));
}
Ok(Signature::new(&result))
Signature::try_from(result)
.map_err(|_| RemoteWalletError::Protocol("Signature packet size mismatch"))
}
fn sign_offchain_message(
@ -552,12 +548,8 @@ impl RemoteWallet<hidapi::DeviceInfo> for LedgerWallet {
}
let result = self.send_apdu(commands::SIGN_OFFCHAIN_MESSAGE, p1, p2, payload)?;
if result.len() != 64 {
return Err(RemoteWalletError::Protocol(
"Signature packet size mismatch",
));
}
Ok(Signature::new(&result))
Signature::try_from(result)
.map_err(|_| RemoteWalletError::Protocol("Signature packet size mismatch"))
}
}

4
rpc-client/src/mock_sender.rs
View File

@ -241,7 +241,7 @@ impl RpcSender for MockSender {
"getTransactionCount" => json![1234],
"getSlot" => json![0],
"getMaxShredInsertSlot" => json![0],
"requestAirdrop" => Value::String(Signature::new(&[8; 64]).to_string()),
"requestAirdrop" => Value::String(Signature::from([8; 64]).to_string()),
"getSnapshotSlot" => Value::Number(Number::from(0)),
"getHighestSnapshotSlot" => json!(RpcSnapshotSlotInfo {
full: 100,
@ -333,7 +333,7 @@ impl RpcSender for MockSender {
}
"sendTransaction" => {
let signature = if self.url == "malicious" {
Signature::new(&[8; 64]).to_string()
Signature::from([8; 64]).to_string()
} else {
let tx_str = params.as_array().unwrap()[0].as_str().unwrap().to_string();
let data = BASE64_STANDARD.decode(tx_str).unwrap();

2
runtime/benches/status_cache.rs
View File

@ -24,7 +24,7 @@ fn bench_status_cache_serialize(bencher: &mut Bencher) {
let mut sigbytes = Vec::from(id.as_ref());
id = hash(id.as_ref());
sigbytes.extend(id.as_ref());
let sig = Signature::new(&sigbytes);
let sig = Signature::try_from(sigbytes).unwrap();
status_cache.insert(&blockhash, sig, 0, Ok(()));
}
}

40
sdk/src/signature.rs
View File

@ -9,7 +9,7 @@ use {
std::{
borrow::{Borrow, Cow},
convert::TryInto,
fmt, mem,
fmt,
str::FromStr,
},
thiserror::Error,
@ -29,13 +29,16 @@ pub struct Signature(GenericArray<u8, U64>);
impl crate::sanitize::Sanitize for Signature {}
impl Signature {
#[deprecated(
since = "1.16.4",
note = "Please use 'Signature::from' or 'Signature::try_from' instead"
)]
pub fn new(signature_slice: &[u8]) -> Self {
Self(GenericArray::clone_from_slice(signature_slice))
}
pub fn new_unique() -> Self {
let random_bytes: Vec<u8> = (0..64).map(|_| rand::random::<u8>()).collect();
Self::new(&random_bytes)
Self::from(std::array::from_fn(|_| rand::random()))
}
pub(self) fn verify_verbose(
@ -93,6 +96,31 @@ impl From<Signature> for [u8; 64] {
}
}
impl From<[u8; SIGNATURE_BYTES]> for Signature {
#[inline]
fn from(signature: [u8; SIGNATURE_BYTES]) -> Self {
Self(GenericArray::from(signature))
}
}
impl<'a> TryFrom<&'a [u8]> for Signature {
type Error = <[u8; SIGNATURE_BYTES] as TryFrom<&'a [u8]>>::Error;
#[inline]
fn try_from(signature: &'a [u8]) -> Result<Self, Self::Error> {
<[u8; SIGNATURE_BYTES]>::try_from(signature).map(Self::from)
}
}
impl TryFrom<Vec<u8>> for Signature {
type Error = <[u8; SIGNATURE_BYTES] as TryFrom<Vec<u8>>>::Error;
#[inline]
fn try_from(signature: Vec<u8>) -> Result<Self, Self::Error> {
<[u8; SIGNATURE_BYTES]>::try_from(signature).map(Self::from)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Error)]
pub enum ParseSignatureError {
#[error("string decoded to wrong size for signature")]
@ -111,11 +139,7 @@ impl FromStr for Signature {
let bytes = bs58::decode(s)
.into_vec()
.map_err(|_| ParseSignatureError::Invalid)?;
if bytes.len() != mem::size_of::<Signature>() {
Err(ParseSignatureError::WrongSize)
} else {
Ok(Signature::new(&bytes))
}
Signature::try_from(bytes).map_err(|_| ParseSignatureError::WrongSize)
}
}

2
sdk/src/signer/keypair.rs
View File

@ -91,7 +91,7 @@ impl Signer for Keypair {
}
fn sign_message(&self, message: &[u8]) -> Signature {
Signature::new(&self.0.sign(message).to_bytes())
Signature::from(self.0.sign(message).to_bytes())
}
fn try_sign_message(&self, message: &[u8]) -> Result<Signature, SignerError> {

4
send-transaction-service/src/send_transaction_service.rs
View File

@ -1068,7 +1068,7 @@ mod test {
info!("Transactions are only retried until max_retries");
transactions.insert(
Signature::new(&[1; 64]),
Signature::from([1; 64]),
TransactionInfo::new(
Signature::default(),
vec![],
@ -1079,7 +1079,7 @@ mod test {
),
);
transactions.insert(
Signature::new(&[2; 64]),
Signature::from([2; 64]),
TransactionInfo::new(
Signature::default(),
vec![],

14
storage-proto/src/convert.rs
View File

@ -242,8 +242,9 @@ impl From<generated::Transaction> for VersionedTransaction {
signatures: value
.signatures
.into_iter()
.map(|x| Signature::new(&x))
.collect(),
.map(Signature::try_from)
.collect::<Result<_, _>>()
.unwrap(),
message: value.message.expect("message is required").into(),
}
}
@ -1158,7 +1159,8 @@ impl TryFrom<tx_by_addr::TransactionByAddrInfo> for TransactionByAddrInfo {
.transpose()?;
Ok(Self {
signature: Signature::new(&transaction_by_addr.signature),
signature: Signature::try_from(transaction_by_addr.signature)
.map_err(|_| "Invalid Signature")?,
err,
index: transaction_by_addr.index,
memo: transaction_by_addr
@ -1219,7 +1221,11 @@ mod test {
#[test]
fn test_transaction_by_addr_encode() {
let info = TransactionByAddrInfo {
signature: Signature::new(&bs58::decode("Nfo6rgemG1KLbk1xuNwfrQTsdxaGfLuWURHNRy9LYnDrubG7LFQZaA5obPNas9LQ6DdorJqxh2LxA3PsnWdkSrL").into_vec().unwrap()),
signature: bs58::decode("Nfo6rgemG1KLbk1xuNwfrQTsdxaGfLuWURHNRy9LYnDrubG7LFQZaA5obPNas9LQ6DdorJqxh2LxA3PsnWdkSrL")
.into_vec()
.map(Signature::try_from)
.unwrap()
.unwrap(),
err: None,
index: 5,
memo: Some("string".to_string()),