Skip to main content

foundry_cheatcodes/
crypto.rs

1//! Implementations of [`Crypto`](spec::Group::Crypto) Cheatcodes.
2
3use crate::{Cheatcode, CheatcodesCore, Error, Result, Vm::*};
4use alloy_primitives::{Address, B256, U256, keccak256};
5use alloy_signer::{Signer, SignerSync};
6use alloy_signer_local::{
7    MnemonicBuilder, PrivateKeySigner,
8    coins_bip39::{
9        ChineseSimplified, ChineseTraditional, Czech, English, French, Italian, Japanese, Korean,
10        Portuguese, Spanish, Wordlist,
11    },
12};
13use alloy_sol_types::SolValue;
14use foundry_common::{
15    tempo::configurable_account::{self, p256_public_key, quorum, sign_p256_low_s},
16    wallet::{derive_private_key, derive_private_key_with_language},
17};
18use k256::{
19    AffinePoint, EncodedPoint, FieldBytes, FieldElement, ProjectivePoint, Scalar,
20    ecdsa::{SigningKey, hazmat},
21    elliptic_curve::{
22        bigint::{ArrayEncoding, U256 as K256U256},
23        group::Group,
24        ops::Reduce,
25        sec1::{FromEncodedPoint, ToEncodedPoint},
26    },
27};
28
29use p256::ecdsa::SigningKey as P256SigningKey;
30
31use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
32use ed25519_consensus::{
33    Signature as Ed25519Signature, SigningKey as Ed25519SigningKey,
34    VerificationKey as Ed25519VerificationKey,
35};
36use sha2::{Digest, Sha256};
37use std::collections::BTreeMap;
38use tempo_primitives::transaction::{
39    ConfigurableAccountConfig as TempoAccountConfig, ConfigurableAccountOwner as TempoAccountOwner,
40    ConfigurableAccountSignature, KeychainSignature, MAX_CONFIGURABLE_ACCOUNT_SIGNATURES,
41    PrimitiveSignature, TempoSignature, configurable_account_digest,
42    tt_signature::{WebAuthnSignature, derive_p256_address},
43};
44
45/// The BIP32 default derivation path prefix.
46const DEFAULT_DERIVATION_PATH_PREFIX: &str = "m/44'/60'/0'/0/";
47const PRIVATE_KEY_SIGNER_CACHE_LIMIT: usize = 64;
48
49impl Cheatcode for createWallet_0Call {
50    fn apply_context(&self, state: &mut CheatcodesCore) -> Result {
51        let Self { walletLabel } = self;
52        create_wallet(&keccak256(walletLabel).into(), Some(walletLabel), state)
53    }
54}
55
56impl Cheatcode for createWallet_1Call {
57    fn apply_context(&self, state: &mut CheatcodesCore) -> Result {
58        let Self { privateKey } = self;
59        create_wallet(privateKey, None, state)
60    }
61}
62
63impl Cheatcode for createWallet_2Call {
64    fn apply_context(&self, state: &mut CheatcodesCore) -> Result {
65        let Self { privateKey, walletLabel } = self;
66        create_wallet(privateKey, Some(walletLabel), state)
67    }
68}
69
70impl Cheatcode for sign_0Call {
71    fn apply_context_free(&self) -> Result {
72        let Self { wallet, digest } = self;
73        let sig = sign(&wallet.privateKey, digest)?;
74        Ok(encode_full_sig(sig))
75    }
76}
77
78impl Cheatcode for signWithNonceUnsafeCall {
79    fn apply_context_free(&self) -> Result {
80        let pk: U256 = self.privateKey;
81        let digest: B256 = self.digest;
82        let nonce: U256 = self.nonce;
83        let sig: alloy_primitives::Signature = sign_with_nonce(&pk, &digest, &nonce)?;
84        Ok(encode_full_sig(sig))
85    }
86}
87
88impl Cheatcode for signKeychainCall {
89    fn apply_context(&self, state: &mut CheatcodesCore) -> Result {
90        let Self { privateKey, account, digest } = self;
91        sign_keychain(state, privateKey, account, digest)
92    }
93}
94
95impl Cheatcode for signKeychainAdminCall {
96    fn apply_context(&self, state: &mut CheatcodesCore) -> Result {
97        let Self { privateKey, account, digest } = self;
98        sign_keychain(state, privateKey, account, digest)
99    }
100}
101
102impl Cheatcode for deriveConfigurableAccountCall {
103    fn apply_context_free(&self) -> Result {
104        let Self { config } = self;
105        Ok(tempo_account_config(config).derive_account().map_err(Error::display)?.abi_encode())
106    }
107}
108
109impl Cheatcode for configurableAccountDigestCall {
110    fn apply_context_free(&self) -> Result {
111        let Self { account, configVersion, digest } = self;
112        Ok(configurable_account_digest(*digest, *account, *configVersion).abi_encode())
113    }
114}
115
116impl Cheatcode for encodeConfigurableAccountSignatureCall {
117    fn apply_context_free(&self) -> Result {
118        let Self { account, config, ownerSignatures } = self;
119        let approvals = ownerSignatures
120            .iter()
121            .enumerate()
122            .map(|(index, signature)| {
123                PrimitiveSignature::from_bytes(signature)
124                    .map_err(|err| fmt_err!("invalid owner signature at index {index}: {err}"))
125            })
126            .collect::<Result<Vec<_>>>()?;
127        let signature = ConfigurableAccountSignature::try_new(
128            *account,
129            tempo_account_config(config),
130            approvals,
131        )
132        .map_err(Error::display)?;
133        Ok(TempoSignature::ConfigurableAccount(signature).to_bytes().abi_encode())
134    }
135}
136
137impl Cheatcode for signConfigurableAccount_0Call {
138    fn apply_context_free(&self) -> Result {
139        let Self { privateKeys, account, config, digest } = self;
140        let keys = privateKeys
141            .iter()
142            .map(|&key| OwnerKey { keyType: OwnerKeyType::Secp256k1, privateKey: key })
143            .collect::<Vec<_>>();
144        let signature = sign_configurable_account(&keys, *account, config, *digest)?;
145        Ok(TempoSignature::ConfigurableAccount(signature).to_bytes().abi_encode())
146    }
147}
148
149impl Cheatcode for signConfigurableAccount_1Call {
150    fn apply_context_free(&self) -> Result {
151        let Self { ownerKeys, account, config, digest } = self;
152        let signature = sign_configurable_account(ownerKeys, *account, config, *digest)?;
153        Ok(TempoSignature::ConfigurableAccount(signature).to_bytes().abi_encode())
154    }
155}
156
157impl Cheatcode for signKeychainConfigurableAccountCall {
158    fn apply_context_free(&self) -> Result {
159        let Self { ownerKeys, configurableAccount, config, account, digest } = self;
160        // A configurable access key's owners approve the keychain V2 hash (TIP-1111).
161        let signing_hash = KeychainSignature::signing_hash(*digest, *account);
162        let inner =
163            sign_configurable_account(ownerKeys, *configurableAccount, config, signing_hash)?;
164        let signature = TempoSignature::Keychain(KeychainSignature::new(*account, inner));
165        Ok(signature.to_bytes().abi_encode())
166    }
167}
168
169impl Cheatcode for signCompact_0Call {
170    fn apply_context_free(&self) -> Result {
171        let Self { wallet, digest } = self;
172        let sig = sign(&wallet.privateKey, digest)?;
173        Ok(encode_compact_sig(sig))
174    }
175}
176
177impl Cheatcode for deriveKey_0Call {
178    fn apply_context_free(&self) -> Result {
179        let Self { mnemonic, index } = self;
180        derive_key::<English>(mnemonic, DEFAULT_DERIVATION_PATH_PREFIX, *index)
181    }
182}
183
184impl Cheatcode for deriveKey_1Call {
185    fn apply_context_free(&self) -> Result {
186        let Self { mnemonic, derivationPath, index } = self;
187        derive_key::<English>(mnemonic, derivationPath, *index)
188    }
189}
190
191impl Cheatcode for deriveKey_2Call {
192    fn apply_context_free(&self) -> Result {
193        let Self { mnemonic, index, language } = self;
194        derive_key_str(mnemonic, DEFAULT_DERIVATION_PATH_PREFIX, *index, language)
195    }
196}
197
198impl Cheatcode for deriveKey_3Call {
199    fn apply_context_free(&self) -> Result {
200        let Self { mnemonic, derivationPath, index, language } = self;
201        derive_key_str(mnemonic, derivationPath, *index, language)
202    }
203}
204
205impl Cheatcode for rememberKeyCall {
206    fn apply_context(&self, state: &mut CheatcodesCore) -> Result {
207        let Self { privateKey } = self;
208        let wallet = with_private_key_signer(state, privateKey, |wallet| Ok(wallet.clone()))?;
209        let address = inject_wallet(state, wallet);
210        Ok(address.abi_encode())
211    }
212}
213
214impl Cheatcode for rememberKeys_0Call {
215    fn apply_context(&self, state: &mut CheatcodesCore) -> Result {
216        let Self { mnemonic, derivationPath, count } = self;
217        let wallets = derive_wallets::<English>(mnemonic, derivationPath, *count)?;
218        let mut addresses = Vec::<Address>::with_capacity(wallets.len());
219        for wallet in wallets {
220            let addr = inject_wallet(state, wallet);
221            addresses.push(addr);
222        }
223
224        Ok(addresses.abi_encode())
225    }
226}
227
228impl Cheatcode for rememberKeys_1Call {
229    fn apply_context(&self, state: &mut CheatcodesCore) -> Result {
230        let Self { mnemonic, derivationPath, language, count } = self;
231        let wallets = derive_wallets_str(mnemonic, derivationPath, language, *count)?;
232        let mut addresses = Vec::<Address>::with_capacity(wallets.len());
233        for wallet in wallets {
234            let addr = inject_wallet(state, wallet);
235            addresses.push(addr);
236        }
237
238        Ok(addresses.abi_encode())
239    }
240}
241
242fn inject_wallet(state: &mut CheatcodesCore, wallet: PrivateKeySigner) -> Address {
243    let address = wallet.address();
244    state.wallets().add_local_signer(wallet);
245    address
246}
247
248impl Cheatcode for sign_1Call {
249    fn apply_context(&self, state: &mut CheatcodesCore) -> Result {
250        let Self { privateKey, digest } = self;
251        let sig = sign_cached(state, privateKey, digest)?;
252        Ok(encode_full_sig(sig))
253    }
254}
255
256impl Cheatcode for signCompact_1Call {
257    fn apply_context(&self, state: &mut CheatcodesCore) -> Result {
258        let Self { privateKey, digest } = self;
259        let sig = sign_cached(state, privateKey, digest)?;
260        Ok(encode_compact_sig(sig))
261    }
262}
263
264impl Cheatcode for sign_2Call {
265    fn apply_context(&self, state: &mut CheatcodesCore) -> Result {
266        let Self { digest } = self;
267        let sig = sign_with_wallet(state, None, digest)?;
268        Ok(encode_full_sig(sig))
269    }
270}
271
272impl Cheatcode for signCompact_2Call {
273    fn apply_context(&self, state: &mut CheatcodesCore) -> Result {
274        let Self { digest } = self;
275        let sig = sign_with_wallet(state, None, digest)?;
276        Ok(encode_compact_sig(sig))
277    }
278}
279
280impl Cheatcode for sign_3Call {
281    fn apply_context(&self, state: &mut CheatcodesCore) -> Result {
282        let Self { signer, digest } = self;
283        let sig = sign_with_wallet(state, Some(*signer), digest)?;
284        Ok(encode_full_sig(sig))
285    }
286}
287
288impl Cheatcode for signCompact_3Call {
289    fn apply_context(&self, state: &mut CheatcodesCore) -> Result {
290        let Self { signer, digest } = self;
291        let sig = sign_with_wallet(state, Some(*signer), digest)?;
292        Ok(encode_compact_sig(sig))
293    }
294}
295
296impl Cheatcode for signP256Call {
297    fn apply_context_free(&self) -> Result {
298        let Self { privateKey, digest } = self;
299        sign_p256(privateKey, digest)
300    }
301}
302
303impl Cheatcode for publicKeyP256Call {
304    fn apply_context_free(&self) -> Result {
305        let Self { privateKey } = self;
306        let pub_key =
307            parse_private_key_p256(privateKey)?.verifying_key().as_affine().to_encoded_point(false);
308        let pub_key_x = U256::from_be_bytes((*pub_key.x().unwrap()).into());
309        let pub_key_y = U256::from_be_bytes((*pub_key.y().unwrap()).into());
310
311        Ok((pub_key_x, pub_key_y).abi_encode())
312    }
313}
314
315impl Cheatcode for ecAffineToProjectiveCall {
316    fn apply_context_free(&self) -> Result {
317        let Self { pointX, pointY } = self;
318        let point = parse_affine_point(pointX, pointY, "point")?;
319        encode_projective_point(ProjectivePoint::from(point))
320    }
321}
322
323impl Cheatcode for ecProjectiveToAffineCall {
324    fn apply_context_free(&self) -> Result {
325        let Self { pointX, pointY, pointZ } = self;
326        let point = parse_projective_point(pointX, pointY, pointZ, "point")?;
327        encode_affine_point(point)
328    }
329}
330
331impl Cheatcode for ecAddAffineCall {
332    fn apply_context_free(&self) -> Result {
333        let Self { pointX1, pointY1, pointX2, pointY2 } = self;
334        let lhs = parse_affine_point(pointX1, pointY1, "first point")?;
335        let rhs = parse_affine_point(pointX2, pointY2, "second point")?;
336        encode_affine_point(ProjectivePoint::from(lhs) + rhs)
337    }
338}
339
340impl Cheatcode for ecAddProjectiveCall {
341    fn apply_context_free(&self) -> Result {
342        let Self { pointX1, pointY1, pointZ1, pointX2, pointY2, pointZ2 } = self;
343        let lhs = parse_projective_point(pointX1, pointY1, pointZ1, "first point")?;
344        let rhs = parse_projective_point(pointX2, pointY2, pointZ2, "second point")?;
345        encode_projective_point(lhs + rhs)
346    }
347}
348
349impl Cheatcode for ecMulAffineCall {
350    fn apply_context_free(&self) -> Result {
351        let Self { pointX, pointY, scalar } = self;
352        let point = parse_affine_point(pointX, pointY, "point")?;
353        let scalar = reduce_ec_scalar(scalar);
354        encode_affine_point(ProjectivePoint::from(point) * scalar)
355    }
356}
357
358impl Cheatcode for ecMulProjectiveCall {
359    fn apply_context_free(&self) -> Result {
360        let Self { pointX, pointY, pointZ, scalar } = self;
361        let point = parse_projective_point(pointX, pointY, pointZ, "point")?;
362        let scalar = reduce_ec_scalar(scalar);
363        encode_projective_point(point * scalar)
364    }
365}
366
367impl Cheatcode for createEd25519KeyCall {
368    fn apply_context_free(&self) -> Result {
369        let Self { salt } = self;
370        create_ed25519_key(salt)
371    }
372}
373
374impl Cheatcode for publicKeyEd25519Call {
375    fn apply_context_free(&self) -> Result {
376        let Self { privateKey } = self;
377        public_key_ed25519(privateKey)
378    }
379}
380
381impl Cheatcode for signEd25519Call {
382    fn apply_context_free(&self) -> Result {
383        let Self { namespace, message, privateKey } = self;
384        sign_ed25519(namespace, message, privateKey)
385    }
386}
387
388impl Cheatcode for verifyEd25519Call {
389    fn apply_context_free(&self) -> Result {
390        let Self { signature, namespace, message, publicKey } = self;
391        verify_ed25519(signature, namespace, message, publicKey)
392    }
393}
394
395/// Using a given private key, return its public ETH address, its public key affine x and y
396/// coordinates, and its private key (see the 'Wallet' struct)
397///
398/// If 'label' is set to 'Some()', assign that label to the associated ETH address in state
399fn create_wallet(private_key: &U256, label: Option<&str>, state: &mut CheatcodesCore) -> Result {
400    let (addr, pub_key_x, pub_key_y) = with_private_key_signer(state, private_key, |wallet| {
401        let addr = wallet.address();
402        let pub_key = wallet.credential().verifying_key().as_affine().to_encoded_point(false);
403        let pub_key_x = U256::from_be_bytes((*pub_key.x().unwrap()).into());
404        let pub_key_y = U256::from_be_bytes((*pub_key.y().unwrap()).into());
405        Ok((addr, pub_key_x, pub_key_y))
406    })?;
407
408    if let Some(label) = label {
409        state.labels.insert(addr, label.into());
410    }
411
412    Ok(Wallet { addr, publicKeyX: pub_key_x, publicKeyY: pub_key_y, privateKey: *private_key }
413        .abi_encode())
414}
415
416fn encode_full_sig(sig: alloy_primitives::Signature) -> Vec<u8> {
417    // Retrieve v, r and s from signature.
418    let v = U256::from(sig.v_byte());
419    let r = B256::from(sig.r());
420    let s = B256::from(sig.s());
421    (v, r, s).abi_encode()
422}
423
424fn encode_compact_sig(sig: alloy_primitives::Signature) -> Vec<u8> {
425    // Implement EIP-2098 compact signature.
426    let r = B256::from(sig.r());
427    let mut vs = sig.s();
428    vs.set_bit(255, sig.v());
429    (r, vs).abi_encode()
430}
431
432fn sign(private_key: &U256, digest: &B256) -> Result<alloy_primitives::Signature> {
433    // The `ecrecover` precompile does not use EIP-155. No chain ID is needed.
434    let wallet = parse_wallet(private_key)?;
435    let sig = wallet.sign_hash_sync(digest)?;
436    debug_assert_eq!(sig.recover_address_from_prehash(digest)?, wallet.address());
437    Ok(sig)
438}
439
440fn sign_cached(
441    state: &mut CheatcodesCore,
442    private_key: &U256,
443    digest: &B256,
444) -> Result<alloy_primitives::Signature> {
445    with_private_key_signer(state, private_key, |wallet| {
446        let sig = wallet.sign_hash_sync(digest)?;
447        debug_assert_eq!(sig.recover_address_from_prehash(digest)?, wallet.address());
448        Ok(sig)
449    })
450}
451
452fn sign_keychain(
453    state: &mut CheatcodesCore,
454    private_key: &U256,
455    account: &Address,
456    digest: &B256,
457) -> Result {
458    let signing_hash = KeychainSignature::signing_hash(*digest, *account);
459    let inner = sign_cached(state, private_key, &signing_hash)?;
460    let signature = TempoSignature::Keychain(KeychainSignature::new(
461        *account,
462        PrimitiveSignature::Secp256k1(inner),
463    ));
464    Ok(signature.to_bytes().abi_encode())
465}
466
467/// Converts a cheatcode configurable account config to Tempo's.
468fn tempo_account_config(config: &ConfigurableAccountConfig) -> TempoAccountConfig {
469    TempoAccountConfig {
470        salt: config.salt,
471        version: config.version,
472        threshold: config.threshold,
473        owners: config
474            .owners
475            .iter()
476            .map(|owner| TempoAccountOwner { owner: owner.owner, weight: owner.weight })
477            .collect(),
478    }
479}
480
481/// Signs `inner` as the configurable account `account` with the fewest of `keys` that form a
482/// quorum the node accepts: at most 8 approvals, sorted by owner, the last of which reaches the
483/// threshold.
484fn sign_configurable_account(
485    keys: &[OwnerKey],
486    account: Address,
487    config: &ConfigurableAccountConfig,
488    inner: B256,
489) -> Result<ConfigurableAccountSignature> {
490    let config = tempo_account_config(config);
491    // Owner lookups below assume a valid, sorted owner list.
492    config.validate_for_account(account).map_err(Error::display)?;
493    // An unchanged account still has its initial config, which must derive its address.
494    if config.version == 0 {
495        let derived = config.derive_account().map_err(Error::display)?;
496        ensure!(
497            derived == account,
498            "configurable account config with version 0 derives {derived}, not {account}"
499        );
500    }
501    let mut by_owner = BTreeMap::new();
502    for key in keys {
503        let owner = owner_key_address(key)?;
504        ensure!(
505            config.owner_weight(owner).is_some(),
506            "{owner} is not an owner of configurable account {account}"
507        );
508        by_owner.entry(owner).or_insert(key);
509    }
510
511    let owners = config
512        .owners
513        .iter()
514        .filter(|owner| by_owner.contains_key(&owner.owner))
515        .cloned()
516        .collect::<Vec<_>>();
517    let selected = quorum(&owners, config.threshold, false);
518    if selected.is_empty() {
519        let threshold = u16::from(config.threshold);
520        let weight = owners.iter().map(|owner| u16::from(owner.weight)).sum::<u16>();
521        ensure!(
522            weight < threshold,
523            "no {MAX_CONFIGURABLE_ACCOUNT_SIGNATURES} of the owner keys reach the threshold \
524             {threshold} of configurable account {account}"
525        );
526        bail!(
527            "owner keys reach weight {weight}, but configurable account {account} requires \
528             {threshold}"
529        );
530    }
531
532    let digest = configurable_account_digest(inner, account, config.version);
533    let approvals = selected
534        .iter()
535        .map(|owner| sign_owner_approval(by_owner[owner], &digest))
536        .collect::<Result<Vec<_>>>()?;
537    ConfigurableAccountSignature::try_new(account, config, approvals).map_err(Error::display)
538}
539
540/// Returns the owner address of `key`.
541fn owner_key_address(key: &OwnerKey) -> Result<Address> {
542    match key.keyType {
543        OwnerKeyType::Secp256k1 => Ok(parse_wallet(&key.privateKey)?.address()),
544        OwnerKeyType::P256 | OwnerKeyType::WebAuthn => {
545            let (x, y) = p256_public_key(&parse_private_key_p256(&key.privateKey)?);
546            Ok(derive_p256_address(&x, &y))
547        }
548        _ => bail!("invalid owner key type"),
549    }
550}
551
552/// Signs `digest` with an owner key as a Tempo primitive signature.
553fn sign_owner_approval(key: &OwnerKey, digest: &B256) -> Result<PrimitiveSignature> {
554    match key.keyType {
555        OwnerKeyType::Secp256k1 => {
556            Ok(PrimitiveSignature::Secp256k1(sign(&key.privateKey, digest)?))
557        }
558        OwnerKeyType::P256 => {
559            Ok(configurable_account::sign_p256(&parse_private_key_p256(&key.privateKey)?, digest)?)
560        }
561        OwnerKeyType::WebAuthn => {
562            let signing_key = parse_private_key_p256(&key.privateKey)?;
563            // An assertion for the RP ID `localhost` with the user present and verified flags.
564            let mut webauthn_data = Sha256::digest(b"localhost").to_vec();
565            webauthn_data.extend_from_slice(&[0x05, 0, 0, 0, 0]);
566            let client_data = format!(
567                r#"{{"type":"webauthn.get","challenge":"{}","origin":"http://localhost","crossOrigin":false}}"#,
568                URL_SAFE_NO_PAD.encode(digest)
569            );
570            let message = Sha256::new()
571                .chain_update(&webauthn_data)
572                .chain_update(Sha256::digest(&client_data));
573            let (r, s) = sign_p256_low_s(&signing_key, &message.finalize())?;
574            let (pub_key_x, pub_key_y) = p256_public_key(&signing_key);
575            webauthn_data.extend_from_slice(client_data.as_bytes());
576            Ok(PrimitiveSignature::WebAuthn(WebAuthnSignature {
577                r,
578                s,
579                pub_key_x,
580                pub_key_y,
581                webauthn_data: webauthn_data.into(),
582            }))
583        }
584        _ => bail!("invalid owner key type"),
585    }
586}
587
588/// Signs `digest` on secp256k1 using a user-supplied ephemeral nonce `k` (no RFC6979).
589/// - `private_key` and `nonce` must be in (0, n)
590/// - `digest` is a 32-byte prehash.
591///
592/// # Warning
593///
594/// Use [`sign_with_nonce`] with extreme caution!
595/// Reusing the same nonce (`k`) with the same private key in ECDSA will leak the private key.
596/// Always generate `nonce` with a cryptographically secure RNG, and never reuse it across
597/// signatures.
598fn sign_with_nonce(
599    private_key: &U256,
600    digest: &B256,
601    nonce: &U256,
602) -> Result<alloy_primitives::Signature> {
603    let d_scalar: Scalar =
604        <Scalar as k256::elliptic_curve::PrimeField>::from_repr(private_key.to_be_bytes().into())
605            .into_option()
606            .ok_or_else(|| fmt_err!("invalid private key scalar"))?;
607    if bool::from(d_scalar.is_zero()) {
608        return Err(fmt_err!("private key cannot be 0"));
609    }
610
611    let k_scalar: Scalar =
612        <Scalar as k256::elliptic_curve::PrimeField>::from_repr(nonce.to_be_bytes().into())
613            .into_option()
614            .ok_or_else(|| fmt_err!("invalid nonce scalar"))?;
615    if bool::from(k_scalar.is_zero()) {
616        return Err(fmt_err!("nonce cannot be 0"));
617    }
618
619    let mut z = [0u8; 32];
620    z.copy_from_slice(digest.as_slice());
621    let z_fb: FieldBytes = FieldBytes::from(z);
622
623    // Hazmat signing using the scalar `d` (SignPrimitive is implemented for `Scalar`)
624    // Note: returns (Signature, Option<RecoveryId>)
625    let (sig_raw, recid_opt) =
626        <Scalar as hazmat::SignPrimitive<k256::Secp256k1>>::try_sign_prehashed(
627            &d_scalar, k_scalar, &z_fb,
628        )
629        .map_err(|e| fmt_err!("sign_prehashed failed: {e}"))?;
630
631    // Enforce low-s; if mirrored, parity flips (we’ll account for it below if we use recid)
632    let (sig_low, flipped) =
633        if let Some(norm) = sig_raw.normalize_s() { (norm, true) } else { (sig_raw, false) };
634
635    let r_u256 = U256::from_be_bytes(sig_low.r().to_bytes().into());
636    let s_u256 = U256::from_be_bytes(sig_low.s().to_bytes().into());
637
638    // Determine v parity in {0,1}
639    let v_parity = if let Some(id) = recid_opt {
640        let mut v = id.to_byte() & 1;
641        if flipped {
642            v ^= 1;
643        }
644        v
645    } else {
646        // Fallback: choose parity by recovery to expected address
647        let expected_addr = {
648            let sk: SigningKey = parse_private_key(private_key)?;
649            alloy_signer::utils::secret_key_to_address(&sk)
650        };
651        // Try v = 0
652        let cand0 = alloy_primitives::Signature::new(r_u256, s_u256, false);
653        if cand0.recover_address_from_prehash(digest).ok() == Some(expected_addr) {
654            return Ok(cand0);
655        }
656        // Try v = 1
657        let cand1 = alloy_primitives::Signature::new(r_u256, s_u256, true);
658        if cand1.recover_address_from_prehash(digest).ok() == Some(expected_addr) {
659            return Ok(cand1);
660        }
661        return Err(fmt_err!("failed to determine recovery id for signature"));
662    };
663
664    let y_parity = v_parity != 0;
665    Ok(alloy_primitives::Signature::new(r_u256, s_u256, y_parity))
666}
667
668fn sign_with_wallet(
669    state: &mut CheatcodesCore,
670    signer: Option<Address>,
671    digest: &B256,
672) -> Result<alloy_primitives::Signature> {
673    let mut wallets = state.wallets().inner.lock();
674    // A sender without a key of its own signs with its owner's key.
675    let default_signer =
676        wallets.provided_sender.map(|sender| wallets.sender_owner.unwrap_or(sender));
677    let signers = wallets.multi_wallet.signers()?;
678    if signers.is_empty() {
679        bail!("no wallets available");
680    }
681
682    let signer = if let Some(signer) = signer {
683        signer
684    } else if let Some(default_signer) = default_signer {
685        default_signer
686    } else if signers.len() == 1 {
687        *signers.keys().next().unwrap()
688    } else {
689        bail!(
690            "could not determine signer, there are multiple signers available use vm.sign(signer, digest) to specify one"
691        );
692    };
693
694    let wallet = signers
695        .get(&signer)
696        .ok_or_else(|| fmt_err!("signer with address {signer} is not available"))?;
697
698    let sig = foundry_common::block_on(wallet.sign_hash(digest))?;
699    debug_assert_eq!(sig.recover_address_from_prehash(digest)?, signer);
700    Ok(sig)
701}
702
703fn sign_p256(private_key: &U256, digest: &B256) -> Result {
704    Ok(sign_p256_low_s(&parse_private_key_p256(private_key)?, digest.as_slice())?.abi_encode())
705}
706
707fn parse_affine_point(x: &U256, y: &U256, name: &str) -> Result<AffinePoint> {
708    if x.is_zero() && y.is_zero() {
709        return Ok(AffinePoint::IDENTITY);
710    }
711
712    let encoded = EncodedPoint::from_affine_coordinates(
713        &FieldBytes::from(x.to_be_bytes()),
714        &FieldBytes::from(y.to_be_bytes()),
715        false,
716    );
717    AffinePoint::from_encoded_point(&encoded)
718        .into_option()
719        .ok_or_else(|| fmt_err!("invalid secp256k1 {name}"))
720}
721
722fn parse_projective_point(x: &U256, y: &U256, z: &U256, name: &str) -> Result<ProjectivePoint> {
723    let x_field = parse_field_element(x, name)?;
724    let y_field = parse_field_element(y, name)?;
725    let z_field = parse_field_element(z, name)?;
726
727    if bool::from(z_field.is_zero()) {
728        ensure!(
729            bool::from(x_field.is_zero()) && !bool::from(y_field.is_zero()),
730            "invalid secp256k1 {name}"
731        );
732        return Ok(ProjectivePoint::IDENTITY);
733    }
734
735    let z_inv = z_field.invert().expect("non-zero field element is invertible");
736    let affine_x = U256::from_be_slice(&(x_field * z_inv).to_bytes());
737    let affine_y = U256::from_be_slice(&(y_field * z_inv).to_bytes());
738
739    Ok(ProjectivePoint::from(parse_affine_point(&affine_x, &affine_y, name)?))
740}
741
742fn parse_field_element(value: &U256, name: &str) -> Result<FieldElement> {
743    FieldElement::from_bytes(&FieldBytes::from(value.to_be_bytes()))
744        .into_option()
745        .ok_or_else(|| fmt_err!("invalid secp256k1 {name}"))
746}
747
748fn reduce_ec_scalar(scalar: &U256) -> Scalar {
749    <Scalar as Reduce<K256U256>>::reduce_bytes(&scalar.to_be_bytes().into())
750}
751
752fn encode_affine_point(point: ProjectivePoint) -> Result {
753    if bool::from(point.is_identity()) {
754        return Ok((U256::ZERO, U256::ZERO).abi_encode());
755    }
756
757    let encoded = point.to_affine().to_encoded_point(false);
758    let x = U256::from_be_slice(encoded.x().expect("non-identity point has x coordinate"));
759    let y = U256::from_be_slice(encoded.y().expect("non-identity point has y coordinate"));
760
761    Ok((x, y).abi_encode())
762}
763
764fn encode_projective_point(point: ProjectivePoint) -> Result {
765    if bool::from(point.is_identity()) {
766        return Ok((U256::ZERO, U256::ONE, U256::ZERO).abi_encode());
767    }
768
769    let encoded = point.to_affine().to_encoded_point(false);
770    let x = U256::from_be_slice(encoded.x().expect("non-identity point has x coordinate"));
771    let y = U256::from_be_slice(encoded.y().expect("non-identity point has y coordinate"));
772
773    Ok((x, y, U256::ONE).abi_encode())
774}
775
776fn validate_private_key<C: ecdsa::PrimeCurve>(private_key: &U256) -> Result<()> {
777    ensure!(!private_key.is_zero(), "private key cannot be 0");
778    let order = U256::from_be_slice(&C::ORDER.to_be_byte_array());
779    ensure!(
780        *private_key < order,
781        "private key must be less than the {curve:?} curve order ({order})",
782        curve = C::default(),
783    );
784
785    Ok(())
786}
787
788fn parse_private_key(private_key: &U256) -> Result<SigningKey> {
789    validate_private_key::<k256::Secp256k1>(private_key)?;
790    Ok(SigningKey::from_bytes((&private_key.to_be_bytes()).into())?)
791}
792
793fn parse_private_key_p256(private_key: &U256) -> Result<P256SigningKey> {
794    validate_private_key::<p256::NistP256>(private_key)?;
795    Ok(P256SigningKey::from_bytes((&private_key.to_be_bytes()).into())?)
796}
797
798fn parse_signing_key_ed25519(private_key: &B256) -> Result<Ed25519SigningKey> {
799    Ed25519SigningKey::try_from(private_key.as_slice())
800        .map_err(|e| fmt_err!("invalid Ed25519 private key: {e}"))
801}
802
803fn create_ed25519_key(salt: &B256) -> Result {
804    let signing_key = parse_signing_key_ed25519(salt)?;
805    let public_key = B256::from_slice(signing_key.verification_key().as_ref());
806    Ok((public_key, *salt).abi_encode())
807}
808
809fn public_key_ed25519(private_key: &B256) -> Result {
810    let signing_key = parse_signing_key_ed25519(private_key)?;
811    Ok(B256::from_slice(signing_key.verification_key().as_ref()).abi_encode())
812}
813
814fn sign_ed25519(namespace: &[u8], message: &[u8], private_key: &B256) -> Result {
815    let signing_key = parse_signing_key_ed25519(private_key)?;
816    let combined = [namespace, message].concat();
817    let signature: [u8; 64] = signing_key.sign(&combined).into();
818    Ok(signature.to_vec().abi_encode())
819}
820
821fn verify_ed25519(signature: &[u8], namespace: &[u8], message: &[u8], public_key: &B256) -> Result {
822    if signature.len() != 64 {
823        return Ok(false.abi_encode());
824    }
825
826    let Ok(verification_key) = Ed25519VerificationKey::try_from(public_key.as_slice()) else {
827        return Ok(false.abi_encode());
828    };
829
830    let Ok(sig_bytes): Result<[u8; 64], _> = signature.try_into() else {
831        return Ok(false.abi_encode());
832    };
833
834    let combined = [namespace, message].concat();
835    let valid = verification_key.verify(&Ed25519Signature::from(sig_bytes), &combined).is_ok();
836    Ok(valid.abi_encode())
837}
838
839pub(super) fn parse_wallet(private_key: &U256) -> Result<PrivateKeySigner> {
840    parse_private_key(private_key).map(PrivateKeySigner::from)
841}
842
843pub(super) fn with_private_key_signer<R>(
844    state: &mut CheatcodesCore,
845    private_key: &U256,
846    f: impl FnOnce(&PrivateKeySigner) -> Result<R>,
847) -> Result<R> {
848    if !state.private_key_signers.contains_key(private_key)
849        && state.private_key_signers.len() < PRIVATE_KEY_SIGNER_CACHE_LIMIT
850    {
851        let wallet = parse_wallet(private_key)?;
852        state.private_key_signers.insert(*private_key, wallet);
853    }
854
855    if let Some(wallet) = state.private_key_signers.get(private_key) {
856        f(wallet)
857    } else {
858        let wallet = parse_wallet(private_key)?;
859        f(&wallet)
860    }
861}
862
863fn derive_key_str(mnemonic: &str, path: &str, index: u32, language: &str) -> Result {
864    let private_key = derive_private_key_with_language(mnemonic, path, index, language)
865        .map_err(|e| fmt_err!("{e}"))?;
866    Ok(private_key.abi_encode())
867}
868
869fn derive_key<W: Wordlist>(mnemonic: &str, path: &str, index: u32) -> Result {
870    let private_key =
871        derive_private_key::<W>(mnemonic, path, index).map_err(|e| fmt_err!("{e}"))?;
872    Ok(private_key.abi_encode())
873}
874
875fn derive_wallets_str(
876    mnemonic: &str,
877    path: &str,
878    language: &str,
879    count: u32,
880) -> Result<Vec<PrivateKeySigner>> {
881    match language {
882        "chinese_simplified" => derive_wallets::<ChineseSimplified>(mnemonic, path, count),
883        "chinese_traditional" => derive_wallets::<ChineseTraditional>(mnemonic, path, count),
884        "czech" => derive_wallets::<Czech>(mnemonic, path, count),
885        "english" => derive_wallets::<English>(mnemonic, path, count),
886        "french" => derive_wallets::<French>(mnemonic, path, count),
887        "italian" => derive_wallets::<Italian>(mnemonic, path, count),
888        "japanese" => derive_wallets::<Japanese>(mnemonic, path, count),
889        "korean" => derive_wallets::<Korean>(mnemonic, path, count),
890        "portuguese" => derive_wallets::<Portuguese>(mnemonic, path, count),
891        "spanish" => derive_wallets::<Spanish>(mnemonic, path, count),
892        _ => Err(fmt_err!("unsupported mnemonic language: {language:?}")),
893    }
894}
895
896fn derive_wallets<W: Wordlist>(
897    mnemonic: &str,
898    path: &str,
899    count: u32,
900) -> Result<Vec<PrivateKeySigner>> {
901    foundry_common::wallet::validate_bip32_path(path).map_err(|e| fmt_err!("{e}"))?;
902
903    let mut wallets = Vec::with_capacity(count as usize);
904    for idx in 0..count {
905        let full_path = foundry_common::wallet::derive_key_path_checked(path, idx)
906            .map_err(|e| fmt_err!("{e}"))?;
907        let wallet =
908            MnemonicBuilder::<W>::default().phrase(mnemonic).derivation_path(full_path)?.build()?;
909        wallets.push(wallet);
910    }
911
912    Ok(wallets)
913}
914
915#[cfg(test)]
916mod tests {
917    use super::*;
918    use alloy_primitives::{Bytes, FixedBytes, LogData, hex::FromHex};
919    use alloy_sol_types::SolCall;
920    use evm2::evm::{AccountInfo, StateCheckpoint};
921    use k256::{Secp256k1, elliptic_curve::Curve};
922    use p256::ecdsa::{
923        Signature as P256Signature, VerifyingKey, signature::hazmat::PrehashVerifier,
924    };
925    use tempo_contracts::precompiles::ISignatureVerifier;
926    use tempo_hardfork::TempoHardfork;
927    use tempo_precompiles::{
928        Precompile,
929        account_keychain::{AccountKeychain, IAccountKeychain, KeyRestrictions, SignatureType},
930        error::Result as PrecompileResult,
931        signature_verifier::SignatureVerifier,
932        storage::{
933            ConfigCommitmentWriteGas, PrecompileStorageProvider, StorageCtx,
934            hashmap::HashMapStorageProvider,
935        },
936    };
937    use tempo_primitives::TempoBlockEnv;
938
939    /// A [`HashMapStorageProvider`] with a settable block timestamp.
940    struct TimestampedStorage {
941        inner: HashMapStorageProvider,
942        block_env: TempoBlockEnv,
943    }
944
945    impl TimestampedStorage {
946        fn new(chain_id: u64, spec: TempoHardfork, timestamp: u64) -> Self {
947            let block_env =
948                TempoBlockEnv { timestamp: U256::from(timestamp), ..Default::default() };
949            Self { inner: HashMapStorageProvider::new_with_spec(chain_id, spec), block_env }
950        }
951
952        fn set_timestamp(&mut self, timestamp: u64) {
953            self.block_env.timestamp = U256::from(timestamp);
954        }
955    }
956
957    impl PrecompileStorageProvider for TimestampedStorage {
958        fn chain_id(&self) -> u64 {
959            self.inner.chain_id()
960        }
961
962        fn block_env(&self) -> &TempoBlockEnv {
963            &self.block_env
964        }
965
966        fn set_code(&mut self, address: Address, code: Bytes) -> PrecompileResult<()> {
967            self.inner.set_code(address, code)
968        }
969
970        fn with_account_info(
971            &mut self,
972            address: Address,
973            f: &mut dyn FnMut(&AccountInfo),
974        ) -> PrecompileResult<()> {
975            self.inner.with_account_info(address, f)
976        }
977
978        fn with_warm_caller_info(
979            &mut self,
980            address: Address,
981            f: &mut dyn FnMut(&AccountInfo),
982        ) -> PrecompileResult<()> {
983            self.inner.with_warm_caller_info(address, f)
984        }
985
986        fn sload(&mut self, address: Address, key: U256) -> PrecompileResult<U256> {
987            self.inner.sload(address, key)
988        }
989
990        fn tload(&mut self, address: Address, key: U256) -> PrecompileResult<U256> {
991            self.inner.tload(address, key)
992        }
993
994        fn sstore(&mut self, address: Address, key: U256, value: U256) -> PrecompileResult<()> {
995            self.inner.sstore(address, key, value)
996        }
997
998        fn tstore(&mut self, address: Address, key: U256, value: U256) -> PrecompileResult<()> {
999            self.inner.tstore(address, key, value)
1000        }
1001
1002        fn emit_event(&mut self, address: Address, event: LogData) -> PrecompileResult<()> {
1003            self.inner.emit_event(address, event)
1004        }
1005
1006        fn deduct_gas(&mut self, gas: u64) -> PrecompileResult<()> {
1007            self.inner.deduct_gas(gas)
1008        }
1009
1010        fn refund_gas(&mut self, gas: i64) {
1011            self.inner.refund_gas(gas)
1012        }
1013
1014        fn gas_limit(&self) -> u64 {
1015            self.inner.gas_limit()
1016        }
1017
1018        fn gas_used(&self) -> u64 {
1019            self.inner.gas_used()
1020        }
1021
1022        fn state_gas_used(&self) -> i64 {
1023            self.inner.state_gas_used()
1024        }
1025
1026        fn state_gas_spilled(&self) -> u64 {
1027            self.inner.state_gas_spilled()
1028        }
1029
1030        fn gas_refunded(&self) -> i64 {
1031            self.inner.gas_refunded()
1032        }
1033
1034        fn reservoir(&self) -> u64 {
1035            self.inner.reservoir()
1036        }
1037
1038        fn spec(&self) -> TempoHardfork {
1039            self.inner.spec()
1040        }
1041
1042        fn amsterdam_eip8037_enabled(&self) -> bool {
1043            self.inner.amsterdam_eip8037_enabled()
1044        }
1045
1046        fn is_static(&self) -> bool {
1047            self.inner.is_static()
1048        }
1049
1050        fn checkpoint(&mut self) -> StateCheckpoint {
1051            self.inner.checkpoint()
1052        }
1053
1054        fn checkpoint_commit(&mut self, checkpoint: StateCheckpoint) {
1055            self.inner.checkpoint_commit(checkpoint)
1056        }
1057
1058        fn checkpoint_revert(&mut self, checkpoint: StateCheckpoint) {
1059            self.inner.checkpoint_revert(checkpoint)
1060        }
1061
1062        fn set_tip1060_storage_credits(&mut self, enabled: bool) {
1063            self.inner.set_tip1060_storage_credits(enabled)
1064        }
1065
1066        fn config_commitment(&mut self, address: Address) -> PrecompileResult<B256> {
1067            self.inner.config_commitment(address)
1068        }
1069
1070        fn set_config_commitment(
1071            &mut self,
1072            address: Address,
1073            commitment: B256,
1074            gas: ConfigCommitmentWriteGas,
1075        ) -> PrecompileResult<()> {
1076            self.inner.set_config_commitment(address, commitment, gas)
1077        }
1078    }
1079
1080    #[test]
1081    fn test_sign_p256() {
1082        let pk_u256: U256 = "1".parse().unwrap();
1083        let signing_key = P256SigningKey::from_bytes(&pk_u256.to_be_bytes().into()).unwrap();
1084        let digest = FixedBytes::from_hex(
1085            "0x44acf6b7e36c1342c2c5897204fe09504e1e2efb1a900377dbc4e7a6a133ec56",
1086        )
1087        .unwrap();
1088
1089        let result = sign_p256(&pk_u256, &digest).unwrap();
1090        let result_bytes: [u8; 64] = result.try_into().unwrap();
1091        let signature = P256Signature::from_bytes(&result_bytes.into()).unwrap();
1092        let verifying_key = VerifyingKey::from(&signing_key);
1093        assert!(verifying_key.verify_prehash(digest.as_slice(), &signature).is_ok());
1094    }
1095
1096    #[test]
1097    fn test_sign_p256_pk_too_large() {
1098        // max n from https://neuromancer.sk/std/secg/secp256r1
1099        let pk =
1100            "0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551".parse().unwrap();
1101        let digest = FixedBytes::from_hex(
1102            "0x54705ba3baafdbdfba8c5f9a70f7a89bee98d906b53e31074da7baecdc0da9ad",
1103        )
1104        .unwrap();
1105        let result = sign_p256(&pk, &digest);
1106        assert_eq!(
1107            result.err().unwrap().to_string(),
1108            "private key must be less than the NistP256 curve order (115792089210356248762697446949407573529996955224135760342422259061068512044369)"
1109        );
1110    }
1111
1112    #[test]
1113    fn test_sign_p256_pk_0() {
1114        let digest = FixedBytes::from_hex(
1115            "0x54705ba3baafdbdfba8c5f9a70f7a89bee98d906b53e31074da7baecdc0da9ad",
1116        )
1117        .unwrap();
1118        let result = sign_p256(&U256::ZERO, &digest);
1119        assert_eq!(result.err().unwrap().to_string(), "private key cannot be 0");
1120    }
1121
1122    #[test]
1123    fn test_sign_with_nonce_varies_and_recovers() {
1124        // Given a fixed private key and digest
1125        let pk_u256: U256 = U256::ONE;
1126        let digest = FixedBytes::from_hex(
1127            "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
1128        )
1129        .unwrap();
1130
1131        // Two distinct nonces
1132        let n1: U256 = U256::from(123u64);
1133        let n2: U256 = U256::from(456u64);
1134
1135        // Sign with both nonces
1136        let sig1 = sign_with_nonce(&pk_u256, &digest, &n1).expect("sig1");
1137        let sig2 = sign_with_nonce(&pk_u256, &digest, &n2).expect("sig2");
1138
1139        // (r,s) must differ when nonce differs
1140        assert!(
1141            sig1.r() != sig2.r() || sig1.s() != sig2.s(),
1142            "signatures should differ with different nonces"
1143        );
1144
1145        // ecrecover must yield the address for both signatures
1146        let sk = parse_private_key(&pk_u256).unwrap();
1147        let expected = alloy_signer::utils::secret_key_to_address(&sk);
1148
1149        assert_eq!(sig1.recover_address_from_prehash(&digest).unwrap(), expected);
1150        assert_eq!(sig2.recover_address_from_prehash(&digest).unwrap(), expected);
1151    }
1152
1153    #[test]
1154    fn test_sign_with_nonce_zero_nonce_errors() {
1155        // nonce = 0 should be rejected
1156        let pk_u256: U256 = U256::ONE;
1157        let digest = FixedBytes::from_hex(
1158            "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
1159        )
1160        .unwrap();
1161        let n0: U256 = U256::ZERO;
1162
1163        let err = sign_with_nonce(&pk_u256, &digest, &n0).unwrap_err();
1164        let msg = err.to_string();
1165        assert!(msg.contains("nonce cannot be 0"), "unexpected error: {msg}");
1166    }
1167
1168    #[test]
1169    fn test_sign_with_nonce_nonce_ge_order_errors() {
1170        // nonce >= n should be rejected
1171        // Curve order n as U256
1172        let n_u256 = U256::from_be_slice(&Secp256k1::ORDER.to_be_byte_array());
1173
1174        let pk_u256: U256 = U256::ONE;
1175        let digest = FixedBytes::from_hex(
1176            "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
1177        )
1178        .unwrap();
1179
1180        // Try exactly n (>= n invalid)
1181        let err = sign_with_nonce(&pk_u256, &digest, &n_u256).unwrap_err();
1182        let msg = err.to_string();
1183        assert!(msg.contains("invalid nonce scalar"), "unexpected error: {msg}");
1184    }
1185
1186    #[test]
1187    fn test_sign_keychain_encodes_v2_signature_for_account() {
1188        let private_key = U256::from(0xB0Bu64);
1189        let account = Address::repeat_byte(0x11);
1190        let digest = B256::repeat_byte(0x22);
1191        let mut state = CheatcodesCore::default();
1192
1193        let result = sign_keychain(&mut state, &private_key, &account, &digest).unwrap();
1194        let signature = Vec::<u8>::abi_decode(&result).unwrap();
1195
1196        assert_eq!(signature.len(), 86);
1197        assert_eq!(signature[0], 0x04);
1198        assert_eq!(Address::from_slice(&signature[1..21]), account);
1199
1200        let parsed = TempoSignature::from_bytes(&signature).unwrap();
1201        assert!(parsed.is_v2_keychain());
1202
1203        let keychain = parsed.as_keychain().unwrap();
1204        let expected_key = parse_wallet(&private_key).unwrap().address();
1205        assert_eq!(keychain.user_address, account);
1206        assert_eq!(keychain.key_id(&digest).unwrap(), expected_key);
1207    }
1208
1209    #[test]
1210    fn private_key_signers_are_cached_for_repeated_lookup() {
1211        let private_key = U256::from(0xB0Bu64);
1212        let mut state = CheatcodesCore::default();
1213
1214        let first =
1215            with_private_key_signer(&mut state, &private_key, |wallet| Ok(wallet.address()))
1216                .unwrap();
1217        assert_eq!(state.private_key_signers.len(), 1);
1218
1219        let second =
1220            with_private_key_signer(&mut state, &private_key, |wallet| Ok(wallet.address()))
1221                .unwrap();
1222        assert_eq!(state.private_key_signers.len(), 1);
1223        assert_eq!(first, second);
1224    }
1225
1226    #[test]
1227    fn test_sign_keychain_matches_t6_signature_verifier_state() {
1228        let root_pk = U256::from(0xA11CEu64);
1229        let access_pk = U256::from(0xB0Bu64);
1230        let admin_pk = U256::from(0xC0FFEEu64);
1231        let revoked_pk = U256::from(0xBADu64);
1232        let expired_pk = U256::from(0xE441u64);
1233        let unknown_pk = U256::from(0xFACEu64);
1234
1235        let root = parse_wallet(&root_pk).unwrap().address();
1236        let access_key = parse_wallet(&access_pk).unwrap().address();
1237        let admin_key = parse_wallet(&admin_pk).unwrap().address();
1238        let revoked_key = parse_wallet(&revoked_pk).unwrap().address();
1239        let expired_key = parse_wallet(&expired_pk).unwrap().address();
1240
1241        let hash = B256::repeat_byte(0x44);
1242        let admin_hash = B256::repeat_byte(0x66);
1243
1244        let mut storage = TimestampedStorage::new(1, TempoHardfork::T6, 1_000);
1245        StorageCtx::enter(&mut storage, || {
1246            let mut keychain = AccountKeychain::new();
1247            keychain.initialize()?;
1248            keychain.set_tx_origin(root)?;
1249
1250            authorize_t6_access_key(&mut keychain, root, access_key, u64::MAX)?;
1251            authorize_t6_access_key(&mut keychain, root, revoked_key, u64::MAX)?;
1252            authorize_t6_access_key(&mut keychain, root, expired_key, 1_005)?;
1253            keychain.authorize_admin_key(root, admin_key, SignatureType::Secp256k1, None)?;
1254            keychain.revoke_key(root, IAccountKeychain::revokeKeyCall { keyId: revoked_key })?;
1255
1256            assert!(verify_keychain(root, hash, keychain_signature(&access_pk, root, hash)));
1257            assert!(!verify_keychain(root, hash, keychain_signature(&revoked_pk, root, hash)));
1258            assert!(!verify_keychain(root, hash, keychain_signature(&unknown_pk, root, hash)));
1259            assert!(!verify_keychain(
1260                Address::repeat_byte(0x99),
1261                hash,
1262                keychain_signature(&access_pk, root, hash)
1263            ));
1264            assert!(verify_keychain_admin(
1265                root,
1266                admin_hash,
1267                keychain_signature(&admin_pk, root, admin_hash)
1268            ));
1269            assert!(verify_keychain_admin(
1270                root,
1271                admin_hash,
1272                keychain_signature(&root_pk, root, admin_hash)
1273            ));
1274            assert!(!verify_keychain_admin(
1275                root,
1276                admin_hash,
1277                keychain_signature(&access_pk, root, admin_hash)
1278            ));
1279            assert!(!verify_keychain_admin(
1280                Address::repeat_byte(0x88),
1281                admin_hash,
1282                keychain_signature(&admin_pk, root, admin_hash)
1283            ));
1284            assert_keychain_signature_reverts(root, hash, vec![0x04]);
1285
1286            Ok::<_, eyre::Report>(())
1287        })
1288        .unwrap();
1289
1290        storage.set_timestamp(1_006);
1291        StorageCtx::enter(&mut storage, || {
1292            assert!(!verify_keychain(root, hash, keychain_signature(&expired_pk, root, hash)));
1293            Ok::<_, eyre::Report>(())
1294        })
1295        .unwrap();
1296    }
1297
1298    fn authorize_t6_access_key(
1299        keychain: &mut AccountKeychain,
1300        account: Address,
1301        key_id: Address,
1302        expiry: u64,
1303    ) -> eyre::Result<()> {
1304        keychain.authorize_key(
1305            account,
1306            key_id,
1307            SignatureType::Secp256k1,
1308            KeyRestrictions {
1309                expiry,
1310                enforceLimits: false,
1311                limits: vec![],
1312                allowAnyCalls: true,
1313                allowedCalls: vec![],
1314            },
1315            None,
1316        )?;
1317        Ok(())
1318    }
1319
1320    fn keychain_signature(private_key: &U256, account: Address, hash: B256) -> Vec<u8> {
1321        let mut state = CheatcodesCore::default();
1322        Vec::<u8>::abi_decode(&sign_keychain(&mut state, private_key, &account, &hash).unwrap())
1323            .unwrap()
1324    }
1325
1326    fn verify_keychain(account: Address, hash: B256, signature: Vec<u8>) -> bool {
1327        let calldata =
1328            ISignatureVerifier::verifyKeychainCall { account, hash, signature: signature.into() }
1329                .abi_encode();
1330
1331        let output = SignatureVerifier::new().call(&calldata, Address::ZERO).unwrap();
1332        ISignatureVerifier::verifyKeychainCall::abi_decode_returns(output.bytes()).unwrap()
1333    }
1334
1335    fn verify_keychain_admin(account: Address, hash: B256, signature: Vec<u8>) -> bool {
1336        let calldata = ISignatureVerifier::verifyKeychainAdminCall {
1337            account,
1338            hash,
1339            signature: signature.into(),
1340        }
1341        .abi_encode();
1342
1343        let output = SignatureVerifier::new().call(&calldata, Address::ZERO).unwrap();
1344        ISignatureVerifier::verifyKeychainAdminCall::abi_decode_returns(output.bytes()).unwrap()
1345    }
1346
1347    fn assert_keychain_signature_reverts(account: Address, hash: B256, signature: Vec<u8>) {
1348        let calldata =
1349            ISignatureVerifier::verifyKeychainCall { account, hash, signature: signature.into() }
1350                .abi_encode();
1351
1352        let output = SignatureVerifier::new().call(&calldata, Address::ZERO);
1353        assert!(
1354            matches!(output, Err(evm2::precompiles::PrecompileError::Revert(_))),
1355            "malformed keychain signature should revert"
1356        );
1357    }
1358
1359    #[test]
1360    fn test_create_ed25519_key_determinism() {
1361        let salt = B256::repeat_byte(1u8);
1362        let result1 = create_ed25519_key(&salt).unwrap();
1363        let result2 = create_ed25519_key(&salt).unwrap();
1364        assert_eq!(result1, result2, "same salt should produce same keys");
1365    }
1366
1367    #[test]
1368    fn test_create_ed25519_key_different_salts() {
1369        let salt1 = B256::repeat_byte(1u8);
1370        let salt2 = B256::repeat_byte(2u8);
1371        let result1 = create_ed25519_key(&salt1).unwrap();
1372        let result2 = create_ed25519_key(&salt2).unwrap();
1373        assert_ne!(result1, result2, "different salts should produce different keys");
1374    }
1375
1376    #[test]
1377    fn test_public_key_ed25519_consistency() {
1378        let salt = B256::repeat_byte(42u8);
1379        let create_result = create_ed25519_key(&salt).unwrap();
1380        let (expected_public, private): (B256, B256) =
1381            <(B256, B256)>::abi_decode(&create_result).unwrap();
1382
1383        let derived_public_result = public_key_ed25519(&private).unwrap();
1384        let derived_public = B256::abi_decode(&derived_public_result).unwrap();
1385
1386        assert_eq!(expected_public, derived_public, "derived public key should match");
1387    }
1388
1389    #[test]
1390    fn test_sign_and_verify_ed25519_valid() {
1391        let salt = B256::repeat_byte(123u8);
1392        let create_result = create_ed25519_key(&salt).unwrap();
1393        let (public_key, private_key): (B256, B256) =
1394            <(B256, B256)>::abi_decode(&create_result).unwrap();
1395
1396        let namespace = b"test.namespace";
1397        let message = b"hello world";
1398        let sig_result = sign_ed25519(namespace, message, &private_key).unwrap();
1399        let sig_bytes: Vec<u8> = Vec::abi_decode(&sig_result).unwrap();
1400
1401        let verify_result = verify_ed25519(&sig_bytes, namespace, message, &public_key).unwrap();
1402        let valid = bool::abi_decode(&verify_result).unwrap();
1403
1404        assert!(valid, "signature should be valid");
1405    }
1406
1407    #[test]
1408    fn test_verify_ed25519_invalid_signature() {
1409        let salt = B256::repeat_byte(123u8);
1410        let create_result = create_ed25519_key(&salt).unwrap();
1411        let (public_key, _): (B256, B256) = <(B256, B256)>::abi_decode(&create_result).unwrap();
1412
1413        let invalid_sig = [0u8; 64];
1414        let namespace = b"test.namespace";
1415        let message = b"hello world";
1416
1417        let verify_result = verify_ed25519(&invalid_sig, namespace, message, &public_key).unwrap();
1418        let valid = bool::abi_decode(&verify_result).unwrap();
1419
1420        assert!(!valid, "invalid signature should not verify");
1421    }
1422
1423    #[test]
1424    fn test_verify_ed25519_namespace_separation() {
1425        let salt = B256::repeat_byte(123u8);
1426        let create_result = create_ed25519_key(&salt).unwrap();
1427        let (public_key, private_key): (B256, B256) =
1428            <(B256, B256)>::abi_decode(&create_result).unwrap();
1429
1430        let namespace_a = b"namespace.a";
1431        let message = b"message";
1432        let sig_result = sign_ed25519(namespace_a, message, &private_key).unwrap();
1433        let sig_bytes: Vec<u8> = Vec::abi_decode(&sig_result).unwrap();
1434
1435        let namespace_b = b"namespace.b";
1436        let verify_result = verify_ed25519(&sig_bytes, namespace_b, message, &public_key).unwrap();
1437        let valid = bool::abi_decode(&verify_result).unwrap();
1438        assert!(!valid, "signature with namespace A should not verify with namespace B");
1439
1440        let verify_result = verify_ed25519(&sig_bytes, namespace_a, message, &public_key).unwrap();
1441        let valid = bool::abi_decode(&verify_result).unwrap();
1442        assert!(valid, "signature should verify with correct namespace");
1443    }
1444
1445    #[test]
1446    fn test_verify_ed25519_invalid_signature_length() {
1447        let salt = B256::repeat_byte(123u8);
1448        let create_result = create_ed25519_key(&salt).unwrap();
1449        let (public_key, _): (B256, B256) = <(B256, B256)>::abi_decode(&create_result).unwrap();
1450
1451        let invalid_sig = [0u8; 32];
1452        let namespace = b"test";
1453        let message = b"message";
1454
1455        let verify_result = verify_ed25519(&invalid_sig, namespace, message, &public_key).unwrap();
1456        let valid = bool::abi_decode(&verify_result).unwrap();
1457        assert!(!valid, "signature with wrong length should not verify");
1458    }
1459
1460    const MNEMONIC: &str = "test test test test test test test test test test test junk";
1461
1462    #[test]
1463    fn derive_key_rejects_harden_bit_overflow() {
1464        let err = derive_key::<English>(MNEMONIC, "m/44'/60'/0'/0/2147483648'", 0)
1465            .unwrap_err()
1466            .to_string();
1467        assert!(err.contains("harden bit"), "{err}");
1468
1469        let err = derive_key::<English>(MNEMONIC, "m/44'/60'/0'/0/2147483648h", 0)
1470            .unwrap_err()
1471            .to_string();
1472        assert!(err.contains("harden bit"), "{err}");
1473
1474        let err =
1475            derive_key::<English>(MNEMONIC, "m/44'/60'/0'/0", foundry_common::wallet::BIP32_HARDEN)
1476                .unwrap_err()
1477                .to_string();
1478        assert!(err.contains("harden bit"), "{err}");
1479
1480        assert!(derive_key::<English>(MNEMONIC, "m/44'/60'/0'/0", 0).is_ok());
1481        assert!(
1482            derive_key::<English>(
1483                MNEMONIC,
1484                &format!("m/44'/60'/0'/0/{}", foundry_common::wallet::BIP32_HARDEN - 1),
1485                0
1486            )
1487            .is_ok()
1488        );
1489    }
1490
1491    #[test]
1492    fn remember_keys_rejects_harden_bit_overflow() {
1493        let err = derive_wallets::<English>(MNEMONIC, "m/44'/60'/0'/0/2147483648'", 1)
1494            .unwrap_err()
1495            .to_string();
1496        assert!(err.contains("harden bit"), "{err}");
1497        assert!(derive_wallets::<English>(MNEMONIC, "m/44'/60'/0'/0", 1).is_ok());
1498    }
1499}