16770817670

Committed 06 Aug 2025 07:46AM UTC coverage: 93.355% (-0.3%) from 93.675%

Build # 16770817670

Build Type

push

github

Committed by

Chik-Network

Commit Message

update 0.16.0

Run Details

526 of 581 new or added lines in 26 files covered. (90.53%)

1 existing line in 1 file now uncovered.

6294 of 6742 relevant lines covered (93.36%)

29671867.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/wasm/src/run_program.rs

use js_sys::Array;
use std::rc::Rc;
use wasm_bindgen::prelude::*;

use crate::flags::ALLOW_BACKREFS;
use crate::lazy_node::LazyNode;
use klvmr::allocator::Allocator;
use klvmr::chik_dialect::ChikDialect;
use klvmr::chik_dialect::NO_UNKNOWN_OPS as _no_unknown_ops;
use klvmr::cost::Cost;
use klvmr::run_program::run_program;
use klvmr::serde::{node_from_bytes, node_from_bytes_backrefs, node_to_bytes};

#[wasm_bindgen]
pub struct Flag;

#[wasm_bindgen]
impl Flag {
    #[wasm_bindgen]
    pub fn no_unknown_ops() -> u32 {
        _no_unknown_ops
    }

    #[wasm_bindgen]
    pub fn allow_backrefs() -> u32 {
        ALLOW_BACKREFS
    }
}

#[wasm_bindgen]
pub fn run_klvm(program: &[u8], args: &[u8], flag: u32) -> Vec<u8> {
    let max_cost: Cost = 1_000_000_000_000_000;

    let mut allocator = Allocator::new();
    let deserializer = if (flag & ALLOW_BACKREFS) != 0 {
        node_from_bytes_backrefs
    } else {
        node_from_bytes
    };
    let program = deserializer(&mut allocator, program).unwrap();
    let args = deserializer(&mut allocator, args).unwrap();
    let dialect = ChikDialect::new(flag);

    let r = run_program(&mut allocator, &dialect, program, args, max_cost);
    match r {
        Ok(reduction) => node_to_bytes(&allocator, reduction.1).unwrap(),
        Err(_eval_err) => format!("{_eval_err:?}").into(),
    }
}

#[wasm_bindgen]
pub fn run_chik_program(
    program: &[u8],
    args: &[u8],
    max_cost: Cost, // Expecting `BigInt` to be passed from JavaScript world
    flag: u32,
) -> Result<Array, String> {
    let mut allocator = Allocator::new();
    let deserializer = if (flag & ALLOW_BACKREFS) != 0 {
        node_from_bytes_backrefs
    } else {
        node_from_bytes
    };
    let program = deserializer(&mut allocator, program).unwrap();
    let args = deserializer(&mut allocator, args).unwrap();
    let dialect = ChikDialect::new(flag);

    let r = run_program(&mut allocator, &dialect, program, args, max_cost);
    match r {
        Ok(reduction) => {
            let cost = JsValue::from(reduction.0);
            let node = LazyNode::new(Rc::new(allocator), reduction.1);
            let val = JsValue::from(node);

            let tuple = Array::new_with_length(2);
            tuple.set(0, cost);
            tuple.set(1, val);
            Ok(tuple)
        }
        Err(_eval_err) => Err(format!("{_eval_err:?}")),
    }
}

1	use js_sys::Array;
2	use std::rc::Rc;
3	use wasm_bindgen::prelude::*;
4
5	use crate::flags::ALLOW_BACKREFS;
6	use crate::lazy_node::LazyNode;
7	use klvmr::allocator::Allocator;
8	use klvmr::chik_dialect::ChikDialect;
9	use klvmr::chik_dialect::NO_UNKNOWN_OPS as _no_unknown_ops;
10	use klvmr::cost::Cost;
11	use klvmr::run_program::run_program;
12	use klvmr::serde::{node_from_bytes, node_from_bytes_backrefs, node_to_bytes};
13
14	#[wasm_bindgen]
15	pub struct Flag;
16
17	#[wasm_bindgen]
18	impl Flag {
19	#[wasm_bindgen]
20	pub fn no_unknown_ops() -> u32 {	×
21	_no_unknown_ops	×
22	}	×
23
24	#[wasm_bindgen]
25	pub fn allow_backrefs() -> u32 {	×
26	ALLOW_BACKREFS	×
27	}	×
28	}
29
30	#[wasm_bindgen]
31	pub fn run_klvm(program: &[u8], args: &[u8], flag: u32) -> Vec<u8> {	×
32	let max_cost: Cost = 1_000_000_000_000_000;	×
33
34	let mut allocator = Allocator::new();	×
35	let deserializer = if (flag & ALLOW_BACKREFS) != 0 {	×
36	node_from_bytes_backrefs	×
37	} else {	×
38	node_from_bytes	×
39	};	×
40	let program = deserializer(&mut allocator, program).unwrap();	×
41	let args = deserializer(&mut allocator, args).unwrap();	×
42	let dialect = ChikDialect::new(flag);	×
43
44	let r = run_program(&mut allocator, &dialect, program, args, max_cost);	×
45	match r {	×
46	Ok(reduction) => node_to_bytes(&allocator, reduction.1).unwrap(),	×
NEW 47	Err(_eval_err) => format!("{_eval_err:?}").into(),	×
48	}
49	}	×
50
51	#[wasm_bindgen]
52	pub fn run_chik_program(	×
53	program: &[u8],	×
54	args: &[u8],	×
55	max_cost: Cost, // Expecting `BigInt` to be passed from JavaScript world	×
56	flag: u32,	×
57	) -> Result<Array, String> {	×
58	let mut allocator = Allocator::new();	×
59	let deserializer = if (flag & ALLOW_BACKREFS) != 0 {	×
60	node_from_bytes_backrefs	×
61	} else {	×
62	node_from_bytes	×
63	};	×
64	let program = deserializer(&mut allocator, program).unwrap();	×
65	let args = deserializer(&mut allocator, args).unwrap();	×
66	let dialect = ChikDialect::new(flag);	×
67
68	let r = run_program(&mut allocator, &dialect, program, args, max_cost);	×
69	match r {	×
70	Ok(reduction) => {	×
71	let cost = JsValue::from(reduction.0);	×
72	let node = LazyNode::new(Rc::new(allocator), reduction.1);	×
73	let val = JsValue::from(node);	×
74
75	let tuple = Array::new_with_length(2);	×
76	tuple.set(0, cost);	×
77	tuple.set(1, val);	×
78	Ok(tuple)	×
79	}
NEW 80	Err(_eval_err) => Err(format!("{_eval_err:?}")),	×
81	}
82	}	×

Chik-Network / klvm_rs / 16770817670

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous