bobcat_create/
lib.rs

1#![no_std]
2
3#[cfg(feature = "alloc")]
4extern crate alloc;
5
6#[cfg(feature = "alloc")]
7use alloc::vec::Vec;
8
9use bobcat_storage::const_keccak256;
10
11pub use bobcat_maths::U;
12
13pub type Address = [u8; 20];
14
15#[cfg(target_arch = "wasm32")]
16mod impls {
17    #[link(wasm_import_module = "vm_hooks")]
18    unsafe extern "C" {
19        pub(crate) fn create1(
20            code: *const u8,
21            code_len: usize,
22            endowment: *const u8,
23            contract: *mut u8,
24            revert_data_len: *mut usize,
25        );
26
27        pub(crate) fn create2(
28            code: *const u8,
29            code_len: usize,
30            endowment: *const u8,
31            salt: *const u8,
32            contract: *mut u8,
33            revert_data_len: *mut usize,
34        );
35
36        pub(crate) fn read_return_data(dest: *mut u8, offset: usize, size: usize) -> usize;
37    }
38}
39
40#[cfg(not(target_arch = "wasm32"))]
41mod impls {
42    // Sorry -- on the host, these don't do anything.
43
44    pub(crate) unsafe fn create1(
45        _code: *const u8,
46        _code_len: usize,
47        _endowment: *const u8,
48        _contract: *mut u8,
49        _revert_data_len: *mut usize,
50    ) {
51    }
52
53    pub(crate) unsafe fn create2(
54        _code: *const u8,
55        _code_len: usize,
56        _endowment: *const u8,
57        _salt: *const u8,
58        _contract: *mut u8,
59        _revert_data_len: *mut usize,
60    ) {
61    }
62
63    pub(crate) unsafe fn read_return_data(_dest: *mut u8, _offset: usize, _size: usize) -> usize {
64        0
65    }
66}
67
68fn create1_partial(code: &[u8], endowment: U) -> (Address, usize) {
69    let mut addr = [0u8; 20];
70    let mut revert_len = 0;
71    unsafe {
72        impls::create1(
73            code.as_ptr(),
74            code.len(),
75            endowment.as_ptr(),
76            addr.as_mut_ptr(),
77            &mut revert_len as *mut usize,
78        )
79    }
80    (addr, revert_len)
81}
82
83pub fn create1_slice<const REVERT_CAP: usize>(
84    code: &[u8],
85    endowment: U,
86) -> (Address, [u8; REVERT_CAP], usize) {
87    let (addr, i) = create1_partial(code, endowment);
88    let mut b = [0u8; REVERT_CAP];
89    let mut l = 0;
90    if i > 0 {
91        assert!(REVERT_CAP >= i, "create1 not enough space");
92        l = unsafe { impls::read_return_data(b.as_mut_ptr(), 0, i) };
93    }
94    (addr, b, l)
95}
96
97pub fn create1_slice_res<const REVERT_CAP: usize>(
98    code: &[u8],
99    endowment: U,
100) -> Result<Address, ([u8; REVERT_CAP], usize)> {
101    let (addr, b, l) = create1_slice(code, endowment);
102    if addr != [0u8; 20] {
103        Ok(addr)
104    } else {
105        Err((b, l))
106    }
107}
108
109#[cfg(feature = "alloc")]
110pub fn create1_vec(code: &[u8], endowment: U) -> Result<Address, Vec<u8>> {
111    create1_partial(code, endowment).map_err(|i| {
112        let mut b = Vec::with_capacity(i);
113        let l = unsafe { impls::read_return_data(b.as_mut_ptr(), 0, i) };
114        unsafe { b.set_len(l) }
115        b
116    })
117}
118
119fn create2_partial(code: &[u8], endowment: U, salt: U) -> Result<Address, usize> {
120    let mut addr = [0u8; 20];
121    let mut revert_len = 0;
122    unsafe {
123        impls::create2(
124            code.as_ptr(),
125            code.len(),
126            endowment.as_ptr(),
127            salt.as_ptr(),
128            addr.as_mut_ptr(),
129            &mut revert_len as *mut usize,
130        )
131    }
132    if addr == [0u8; 20] {
133        Err(revert_len)
134    } else {
135        Ok(addr)
136    }
137}
138
139pub fn create2_slice<const REVERT_CAP: usize>(
140    code: &[u8],
141    endowment: U,
142    salt: U,
143) -> Result<Address, ([u8; REVERT_CAP], usize)> {
144    create2_partial(code, endowment, salt).map_err(|i| {
145        let mut b = [0u8; REVERT_CAP];
146        assert!(REVERT_CAP >= i, "create2 not enough space");
147        let l = unsafe { impls::read_return_data(b.as_mut_ptr(), 0, i) };
148        (b, l)
149    })
150}
151
152#[cfg(feature = "alloc")]
153pub fn create2_vec(code: &[u8], endowment: U, salt: U) -> Result<Address, Vec<u8>> {
154    create2_partial(code, endowment, salt).map_err(|i| {
155        let mut b = Vec::with_capacity(i);
156        let l = unsafe { impls::read_return_data(b.as_mut_ptr(), 0, i) };
157        unsafe {
158            b.set_len(l);
159        }
160        b
161    })
162}
163
164pub fn create2_slice_salt_keccak256<const REVERT_CAP: usize>(
165    code: &[u8],
166    endowment: U,
167    salt: &[u8],
168) -> Result<Address, ([u8; REVERT_CAP], usize)> {
169    create2_slice::<REVERT_CAP>(code, endowment, const_keccak256(salt))
170}
171
172#[cfg(feature = "alloc")]
173pub fn create2_vec_salt_keccak256(
174    code: &[u8],
175    endowment: U,
176    salt: &[u8],
177) -> Result<Address, Vec<u8>> {
178    create2_vec(code, endowment, const_keccak256(salt))
179}
bobcat_create/lib.rs

bobcat_create/
lib.rs
