wacc 2.0.0

Web Assembly Cryptographic Constructs VM implementation
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

// SPDX-License-Identifier: Apache-2.0
use crate::{api, error::ApiError, Context, Error};
use log::info;
use wasmtime::{AsContextMut, Caller, Engine, FuncType, Linker, Val, ValType::I32};

pub fn add_to_linker(engine: &Engine, linker: &mut Linker<Context>) -> Result<(), Error> {
    linker
        .func_new(
            "wacc",
            "_check_preimage_value",
            FuncType::new(engine, [I32, I32, I32, I32], [I32]),
            check_preimage_value,
        )
        .map_err(|e| ApiError::RegisterApiFailed {
            function_name: "_check_preimage_value".to_string(),
            reason: format!("{e}"),
        })?;
    Ok(())
}

pub fn check_preimage_value(
    mut caller: Caller<'_, Context>,
    params: &[Val],
    results: &mut [Val],
) -> Result<(), wasmtime::Error> {
    // check preconditions
    if params.len() != 4 {
        let mut ctx = caller.as_context_mut();
        let context = ctx.data_mut();
        results[0] = context.fail("check_preimage_value requires hash and key-path parameters");
        return Ok(());
    }

    // get the hash bytes and key-path string pairs from WASM memory
    let (h, k) = params.split_at(2);
    info!("check_preimage_value: {h:?}, {k:?}");

    // read hash bytes from WASM memory
    let hash_bytes = match api::get_bytes(&mut caller, h) {
        Ok(b) => b,
        Err(e) => {
            let mut ctx = caller.as_context_mut();
            let context = ctx.data_mut();
            results[0] = context.fail(&e.to_string());
            return Ok(());
        }
    };

    // read KVP path string from WASM memory
    let key = match api::get_string(&mut caller, k) {
        Ok(s) => s,
        Err(e) => {
            let mut ctx = caller.as_context_mut();
            let context = ctx.data_mut();
            results[0] = context.fail(&e.to_string());
            return Ok(());
        }
    };

    // call context method
    let mut ctx = caller.as_context_mut();
    let context = ctx.data_mut();
    results[0] = context.check_preimage_value(&hash_bytes, &key);

    Ok(())
}