1  // Copyright (c) 2019-2025 Alpha-Delta Network Inc.
  2  // This file is part of the deltavm library.
  3  
  4  // Licensed under the Apache License, Version 2.0 (the "License");
  5  // you may not use this file except in compliance with the License.
  6  // You may obtain a copy of the License at:
  7  
  8  // http://www.apache.org/licenses/LICENSE-2.0
  9  
 10  // Unless required by applicable law or agreed to in writing, software
 11  // distributed under the License is distributed on an "AS IS" BASIS,
 12  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  // See the License for the specific language governing permissions and
 14  // limitations under the License.
 15  
 16  #[macro_use]
 17  extern crate criterion;
 18  
 19  use deltavm_console_algorithms::{ECDSASignature, Keccak256, Keccak384, Keccak512};
 20  use deltavm_console_types::prelude::*;
 21  use deltavm_utilities::{TestRng, Uniform};
 22  
 23  use k256::ecdsa::{SigningKey, VerifyingKey};
 24  
 25  use criterion::Criterion;
 26  
 27  fn ecdsa_keccak256(c: &mut Criterion) {
 28      let rng = &mut TestRng::default();
 29      let hasher = Keccak256::default();
 30  
 31      // Sample a random signing key.
 32      let signing_key = SigningKey::random(rng);
 33      let vk = VerifyingKey::from(&signing_key);
 34  
 35      // Sample a random message.
 36      let message: Vec<u8> = (0..256).map(|_| u8::rand(rng)).collect::<Vec<_>>();
 37      let message_bits = message.to_bits_le();
 38  
 39      // Sign the message.
 40      let signature = ECDSASignature::sign(&signing_key, &hasher, &message_bits).unwrap();
 41  
 42      c.bench_function(&format!("ECDSA (Keccak256) verify - input size {}", message.len()), |b| {
 43          b.iter(|| signature.verify(&vk, &hasher, &message_bits).unwrap())
 44      });
 45      let eth_address = ECDSASignature::ethereum_address_from_public_key(&vk).unwrap();
 46      c.bench_function(&format!("ECDSA (Keccak256) ETH verify - input size {}", message.len()), |b| {
 47          b.iter(|| signature.verify_ethereum(&eth_address, &hasher, &message_bits).unwrap())
 48      });
 49  }
 50  
 51  fn ecdsa_keccak384(c: &mut Criterion) {
 52      let rng = &mut TestRng::default();
 53      let hasher = Keccak384::default();
 54  
 55      // Sample a random signing key.
 56      let signing_key = SigningKey::random(rng);
 57      let vk = VerifyingKey::from(&signing_key);
 58  
 59      // Sample a random message.
 60      let message: Vec<u8> = (0..256).map(|_| u8::rand(rng)).collect::<Vec<_>>();
 61      let message_bits = message.to_bits_le();
 62  
 63      // Sign the message.
 64      let signature = ECDSASignature::sign(&signing_key, &hasher, &message_bits).unwrap();
 65  
 66      c.bench_function(&format!("ECDSA (Keccak384) verify - input size {}", message.len()), |b| {
 67          b.iter(|| signature.verify(&vk, &hasher, &message_bits).unwrap())
 68      });
 69      let eth_address = ECDSASignature::ethereum_address_from_public_key(&vk).unwrap();
 70      c.bench_function(&format!("ECDSA (Keccak384) ETH verify - input size {}", message.len()), |b| {
 71          b.iter(|| signature.verify_ethereum(&eth_address, &hasher, &message_bits).unwrap())
 72      });
 73  }
 74  
 75  fn ecdsa_keccak512(c: &mut Criterion) {
 76      let rng = &mut TestRng::default();
 77      let hasher = Keccak512::default();
 78  
 79      // Sample a random signing key.
 80      let signing_key = SigningKey::random(rng);
 81      let vk = VerifyingKey::from(&signing_key);
 82  
 83      // Sample a random message.
 84      let message: Vec<u8> = (0..256).map(|_| u8::rand(rng)).collect::<Vec<_>>();
 85      let message_bits = message.to_bits_le();
 86  
 87      // Sign the message.
 88      let signature = ECDSASignature::sign(&signing_key, &hasher, &message_bits).unwrap();
 89  
 90      c.bench_function(&format!("ECDSA (Keccak512) verify - input size {}", message.len()), |b| {
 91          b.iter(|| signature.verify(&vk, &hasher, &message_bits).unwrap())
 92      });
 93      let eth_address = ECDSASignature::ethereum_address_from_public_key(&vk).unwrap();
 94      c.bench_function(&format!("ECDSA (Keccak512) ETH verify - input size {}", message.len()), |b| {
 95          b.iter(|| signature.verify_ethereum(&eth_address, &hasher, &message_bits).unwrap())
 96      });
 97  }
 98  
 99  criterion_group! {
100      name = keccak;
101      config = Criterion::default().sample_size(1000);
102      targets = ecdsa_keccak256, ecdsa_keccak384, ecdsa_keccak512
103  }
104  
105  criterion_main!(keccak);