pub fn get_compiler_versions(&self) -> (Option<String>, Option<String>) {
        match self {
            CborCompilerVersion::Native(compiler_version) => {
                // For native Solc and Vyper compilers, CBOR is a 3 byte encoding of the compiler version: one byte each
                // for major, minor and patch version number. For example, 0.8.28 is encoded as [0, 8, 28].
                if compiler_version.len() == 3 {
                    let version_str = format!(
                        "{}.{}.{}",
                        compiler_version[0], compiler_version[1], compiler_version[2]
                    );
                    (Some(version_str), None)
                } else {
                    (None, None)
                }
            }
            CborCompilerVersion::ZKsync(compiler_versions) => {
                // For ZKsync compilers, the value consists of semicolon-separated pairs of colon-separated compiler names
                // and versions. For example: "zksolc:1.5.13", "zkvyper:1.5.10;vyper:0.4.1" or
                // "zksolc:1.5.13;solc:0.8.29;llvm:1.0.2".
                // It can also contain a pre-release compiler version as a string, but we intentionally return None in such cases,
                // as we don't support verification for such contracts.
                let compilers_parts: Vec<&str> = compiler_versions
                    .split(';')
                    .filter_map(|part| part.split_once(':').map(|(_, value)| value))
                    .collect();

                // Prerelease compiler version is not supported for verification so None is returned.
                if compilers_parts.is_empty() {
                    return (None, None);
                }
                let mut compiler_version = None;
                // Extract zk compiler version
                let zk_compiler_version = Some(format!("v{}", compilers_parts[0]));

                // Processing "zkvyper:<version>;vyper:<version>" version
                if compilers_parts.len() == 2 {
                    compiler_version = Some(compilers_parts[1].to_string());
                } else if compilers_parts.len() == 3 {
                    // Processing "zksolc:<version>;solc:<version>;llvm:<version>" version.
                    compiler_version = Some(format!(
                        "zkVM-{}-{}",
                        compilers_parts[1], compilers_parts[2]
                    ));
                }

                (compiler_version, zk_compiler_version)
            }
        }
    }
Returns the compiler versions from the metadata in a tuple (compiler_version, zk_compiler_version).
core/lib/types/src/contract_verification/contract_identifier.rs