Struct RuntimeContextWrapper 

pub struct RuntimeContextWrapper {
    pub ctx: RefCell<RuntimeContext>,
}

Fields

ctx: RefCell<RuntimeContext>

Implementations

impl RuntimeContextWrapper

pub fn new(ctx: RuntimeContext) -> Self

pub fn into_inner(self) -> RuntimeContext

Trait Implementations

impl CryptoAPI for RuntimeContextWrapper

fn keccak256_permute(state: &mut [u64; 25])

In-place Keccak-f[1600] permutation over 25 lanes of 64-bit.

fn sha256_extend(w: &mut [u32; 64])

Expand/prepare the SHA-256 message schedule in-place.

fn sha256_compress(state: &mut [u32; 8], w: &[u32; 64])

One SHA-256 compression round.

fn ed25519_decompress(y: [u8; 32], sign: u32) -> [u8; 64]

Decompress an Ed25519 point from compressed y and a sign bit.

fn ed25519_add(p: [u8; 64], q: [u8; 64]) -> [u8; 64]

Add two Ed25519 points in raw affine form.

fn tower_fp1_bn254_add(x: [u8; 32], y: [u8; 32]) -> [u8; 32]

BN254 base field (Fp) addition: (x + y) mod p. Inputs/Output: 32-byte little-endian field elements.

fn tower_fp1_bn254_sub(x: [u8; 32], y: [u8; 32]) -> [u8; 32]

BN254 base field (Fp) subtraction: (x - y) mod p. Inputs/Output: 32-byte little-endian field elements.

fn tower_fp1_bn254_mul(x: [u8; 32], y: [u8; 32]) -> [u8; 32]

BN254 base field (Fp) multiplication: (x * y) mod p. Inputs/Output: 32-byte little-endian field elements.

fn tower_fp1_bls12381_add(x: [u8; 48], y: [u8; 48]) -> [u8; 48]

BLS12-381 base field (Fp) addition: (x + y) mod p. Inputs/Output: 48-byte little-endian field elements.

fn tower_fp1_bls12381_sub(x: [u8; 48], y: [u8; 48]) -> [u8; 48]

BLS12-381 base field (Fp) subtraction: (x - y) mod p. Inputs/Output: 48-byte little-endian field elements.

fn tower_fp1_bls12381_mul(x: [u8; 48], y: [u8; 48]) -> [u8; 48]

BLS12-381 base field (Fp) multiplication: (x * y) mod p. Inputs/Output: 48-byte little-endian field elements.

fn tower_fp2_bn254_add( a_c0: [u8; 32], a_c1: [u8; 32], b_c0: [u8; 32], b_c1: [u8; 32], ) -> ([u8; 32], [u8; 32])

BN254 quadratic extension field (Fp2) addition.

fn tower_fp2_bn254_sub( a_c0: [u8; 32], a_c1: [u8; 32], b_c0: [u8; 32], b_c1: [u8; 32], ) -> ([u8; 32], [u8; 32])

BN254 quadratic extension field (Fp2) subtraction. Returns (diff_c0, diff_c1).

fn tower_fp2_bn254_mul( a_c0: [u8; 32], a_c1: [u8; 32], b_c0: [u8; 32], b_c1: [u8; 32], ) -> ([u8; 32], [u8; 32])

BN254 quadratic extension field (Fp2) multiplication. Returns (prod_c0, prod_c1) reduced modulo p.

fn tower_fp2_bls12381_add( a_c0: [u8; 48], a_c1: [u8; 48], b_c0: [u8; 48], b_c1: [u8; 48], ) -> ([u8; 48], [u8; 48])

BLS12-381 quadratic extension field (Fp2) addition. Each limb is 48-byte little-endian; returns (sum_c0, sum_c1).

fn tower_fp2_bls12381_sub( a_c0: [u8; 48], a_c1: [u8; 48], b_c0: [u8; 48], b_c1: [u8; 48], ) -> ([u8; 48], [u8; 48])

BLS12-381 quadratic extension field (Fp2) subtraction. Returns (diff_c0, diff_c1).

fn tower_fp2_bls12381_mul( a_c0: [u8; 48], a_c1: [u8; 48], b_c0: [u8; 48], b_c1: [u8; 48], ) -> ([u8; 48], [u8; 48])

BLS12-381 quadratic extension field (Fp2) multiplication. Returns (prod_c0, prod_c1) reduced modulo p.

fn secp256k1_add(p: [u8; 64], q: [u8; 64]) -> [u8; 64]

Add two secp256k1 G1 points (affine x||y, 64 bytes total). Returns the affine sum encoded as x||y (little-endian coordinates).

fn secp256k1_decompress(x: [u8; 32], sign: u32) -> [u8; 64]

Decompress a secp256k1 point from x and sign bit. Inputs: x is 32-byte x (big-endian); sign selects the y root. Output: 64-byte x||y (big-endian per coordinate).

fn secp256k1_double(p: [u8; 64]) -> [u8; 64]

Point doubling on secp256k1. Input: affine x||y; Output: affine x||y.

fn secp256r1_add(p: [u8; 64], q: [u8; 64]) -> [u8; 64]

Add two secp256r1 (P-256) G1 points (affine x||y, 64 bytes total). Returns the affine sum encoded as x||y (little-endian coordinates).

fn secp256r1_decompress(x: [u8; 32], sign: u32) -> [u8; 64]

Decompress a secp256r1 point from x and sign bit. Inputs: x is 32-byte x (big-endian); sign selects the y root. Output: 64-byte x||y (big-endian per coordinate).

fn secp256r1_double(p: [u8; 64]) -> [u8; 64]

Point doubling on secp256r1. Input: affine x||y; Output: affine x||y.

fn bls12381_add(p: [u8; 96], q: [u8; 96]) -> [u8; 96]

Add two BLS12-381 G1 points (affine x||y, 96 bytes total). Returns the affine sum encoded as x||y (little-endian coordinates).

fn bls12381_decompress(x: [u8; 48], sign: u32) -> [u8; 96]

Decompress a BLS12-381 G1 point from x and sign bit. Inputs: x is Fp-sized x (big-endian); sign selects the y root. Output: affine x||y encoding.

fn bls12381_double(p: [u8; 96]) -> [u8; 96]

Point doubling on BLS12-381 G1. Input: affine x||y; Output: affine x||y.

fn bn254_add(p: [u8; 64], q: [u8; 64]) -> [u8; 64]

Add two BN254 G1 points (affine x||y, 64 bytes total). Returns the affine sum encoded as x||y.

fn bn254_double(p: [u8; 64]) -> [u8; 64]

Point doubling on BN254 G1. Input: affine x||y; Output: affine x||y.

fn uint256_mul_mod(x: &[u8; 32], y: &[u8; 32], m: &[u8; 32]) -> [u8; 32]

Compute (x * y) mod m for 256-bit integers. Inputs: x, y, m are 32-byte little-endian; Output: 32-byte little-endian result in [0, m).

fn uint256_x2048_mul(a: &[u8; 32], b: &[u8; 256]) -> ([u8; 256], [u8; 32])

Multiply a 256-bit integer by a 2048-bit integer.

impl Default for RuntimeContextWrapper

fn default() -> RuntimeContextWrapper

Returns the “default value” for a type.

impl NativeAPI for RuntimeContextWrapper

fn exit(&self, exit_code: ExitCode) -> !

Low-level function that terminates the execution of the program and exits with the specified exit code.

fn state(&self) -> u32

fn read(&self, target: &mut [u8], offset: u32)

fn input_size(&self) -> u32

Returns the size of the input data provided to the runtime environment.

fn write(&self, value: &[u8])

fn output_size(&self) -> u32

fn read_output(&self, target: &mut [u8], offset: u32)

fn exec( &self, code_hash: BytecodeOrHash, input: Cow<'_, [u8]>, fuel_limit: Option<u64>, state: u32, ) -> (u64, i64, i32)

Executes a nested call with specified bytecode poseidon hash.

fn resume( &self, call_id: u32, return_data: &[u8], exit_code: i32, fuel_consumed: u64, fuel_refunded: i64, ) -> (u64, i64, i32)

Resumes the execution of a previously suspended function call.

fn forward_output(&self, offset: u32, len: u32)

fn fuel(&self) -> u64

fn debug_log(message: &str)

fn charge_fuel(&self, fuel_consumed: u64)

Charges specified amount of fuel. In contrast to _charge_fuel_manually, can be called from untrusted code since it can only charge fuel.

fn enter_unconstrained(&self)

fn exit_unconstrained(&self)

fn write_fd(&self, fd: u32, slice: &[u8])