1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

// This file is part of Astar.

// Copyright (C) Stake Technologies Pte.Ltd.
// SPDX-License-Identifier: GPL-3.0-or-later

// Astar is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// Astar is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with Astar. If not, see <http://www.gnu.org/licenses/>.

#![cfg_attr(not(feature = "std"), no_std)]

use fp_evm::PrecompileHandle;
use sp_core::{crypto::UncheckedFrom, sr25519, H256};
use sp_core::{ByteArray, ConstU32};
use sp_std::marker::PhantomData;

use precompile_utils::prelude::*;

#[cfg(test)]
mod mock;
#[cfg(test)]
mod tests;

// SR25519 signature bytes
type SR25519SignatureBytes = ConstU32<64>;

/// A precompile to wrap substrate sr25519 functions.
pub struct Sr25519Precompile<Runtime>(PhantomData<Runtime>);

#[precompile_utils::precompile]
impl<Runtime: pallet_evm::Config> Sr25519Precompile<Runtime> {
    #[precompile::public("verify(bytes32,bytes,bytes)")]
    #[precompile::view]
    fn verify(
        _: &mut impl PrecompileHandle,
        public: H256,
        signature: BoundedBytes<SR25519SignatureBytes>,
        message: UnboundedBytes,
    ) -> EvmResult<bool> {
        // Parse pub key
        let public = sr25519::Public::unchecked_from(public);
        // Parse signature
        let signature = if let Ok(sig) = sr25519::Signature::from_slice(&signature.as_bytes()) {
            sig
        } else {
            // Return `false` if signature length is wrong
            return Ok(false);
        };

        log::trace!(
            target: "sr25519-precompile",
            "Verify signature {:?} for public {:?} and message {:?}",
            signature, public, message,
        );

        let is_confirmed =
            sp_io::crypto::sr25519_verify(&signature, &message.as_bytes(), &public.into());

        log::trace!(
            target: "sr25519-precompile",
            "Verified signature {:?} is {:?}",
            signature, is_confirmed,
        );

        Ok(is_confirmed)
    }
}