diff --git a/enclave/app/Cargo.lock b/enclave/app/Cargo.lock index 6f6aaca..0dc6c79 100644 --- a/enclave/app/Cargo.lock +++ b/enclave/app/Cargo.lock @@ -2,28 +2,1098 @@ # It is not intended for manual editing. version = 3 +[[package]] +name = "ahash" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47" +dependencies = [ + "getrandom", + "once_cell", + "version_check", +] + [[package]] name = "app" version = "1.0.0" dependencies = [ - "sgx_types", + "sgx_types 1.1.4", "sgx_urts", + "skw_ipfs", +] + +[[package]] +name = "autocfg" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a" + +[[package]] +name = "base64" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd" + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bumpalo" +version = "3.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4a45a46ab1f2412e53d3a0ade76ffad2025804294569aae387231a0cd6e0899" + +[[package]] +name = "bytes" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8" + +[[package]] +name = "cc" +version = "1.0.72" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22a9137b95ea06864e018375b72adfb7db6e6f68cfc8df5a04d00288050485ee" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "core-foundation" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6888e10551bb93e424d8df1d07f1a8b4fceb0001a3a4b048bfc47554946f47b3" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc" + +[[package]] +name = "encoding_rs" +version = "0.8.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7896dc8abb250ffdda33912550faa54c88ec8b998dec0b2c55ab224921ce11df" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "fastrand" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "779d043b6a0b90cc4c0ed7ee380a6504394cee7efd7db050e3774eee387324b2" +dependencies = [ + "instant", +] + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foreign-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" +dependencies = [ + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-shared" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" + +[[package]] +name = "form_urlencoded" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191" +dependencies = [ + "matches", + "percent-encoding", +] + +[[package]] +name = "futures-channel" +version = "0.3.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba3dda0b6588335f360afc675d0564c17a77a2bda81ca178a4b6081bd86c7f0b" +dependencies = [ + "futures-core", +] + +[[package]] +name = "futures-core" +version = "0.3.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0c8ff0461b82559810cdccfde3215c3f373807f5e5232b71479bff7bb2583d7" + +[[package]] +name = "futures-io" +version = "0.3.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1f9d34af5a1aac6fb380f735fe510746c38067c5bf16c7fd250280503c971b2" + +[[package]] +name = "futures-sink" +version = "0.3.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3055baccb68d74ff6480350f8d6eb8fcfa3aa11bdc1a1ae3afdd0514617d508" + +[[package]] +name = "futures-task" +version = "0.3.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ee7c6485c30167ce4dfb83ac568a849fe53274c831081476ee13e0dce1aad72" + +[[package]] +name = "futures-util" +version = "0.3.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9b5cf40b47a271f77a8b1bec03ca09044d99d2372c0de244e66430761127164" +dependencies = [ + "futures-core", + "futures-io", + "futures-task", + "memchr", + "pin-project-lite", + "pin-utils", + "slab", +] + +[[package]] +name = "getrandom" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "418d37c8b1d42553c93648be529cb70f920d3baf8ef469b74b9638df426e0b4c" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "h2" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c9de88456263e249e241fcd211d3954e2c9b0ef7ccfc235a444eb367cae3689" +dependencies = [ + "bytes", + "fnv", + "futures-core", + "futures-sink", + "futures-util", + "http", + "indexmap", + "slab", + "tokio", + "tokio-util", + "tracing", +] + +[[package]] +name = "hashbrown" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e" +dependencies = [ + "ahash", +] + +[[package]] +name = "hashbrown_tstd" +version = "0.11.2" +source = "git+https://github.com/apache/teaclave-sgx-sdk.git#565960cd7b4b36d1188459d75652619971c43f7e" + +[[package]] +name = "hermit-abi" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" +dependencies = [ + "libc", +] + +[[package]] +name = "http" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "31f4c6746584866f0feabcc69893c5b51beef3831656a968ed7ae254cdc4fd03" +dependencies = [ + "bytes", + "fnv", + "itoa 1.0.1", +] + +[[package]] +name = "http-body" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ff4f84919677303da5f147645dbea6b1881f368d03ac84e1dc09031ebd7b2c6" +dependencies = [ + "bytes", + "http", + "pin-project-lite", +] + +[[package]] +name = "httparse" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "acd94fdbe1d4ff688b67b04eee2e17bd50995534a61539e45adfefb45e5e5503" + +[[package]] +name = "httpdate" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421" + +[[package]] +name = "hyper" +version = "0.14.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7ec3e62bdc98a2f0393a5048e4c30ef659440ea6e0e572965103e72bd836f55" +dependencies = [ + "bytes", + "futures-channel", + "futures-core", + "futures-util", + "h2", + "http", + "http-body", + "httparse", + "httpdate", + "itoa 0.4.8", + "pin-project-lite", + "socket2", + "tokio", + "tower-service", + "tracing", + "want", +] + +[[package]] +name = "hyper-tls" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905" +dependencies = [ + "bytes", + "hyper", + "native-tls", + "tokio", + "tokio-native-tls", +] + +[[package]] +name = "idna" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8" +dependencies = [ + "matches", + "unicode-bidi", + "unicode-normalization", +] + +[[package]] +name = "indexmap" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223" +dependencies = [ + "autocfg", + "hashbrown", +] + +[[package]] +name = "instant" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c" +dependencies = [ + "cfg-if", ] +[[package]] +name = "ipnet" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68f2d64f2edebec4ce84ad108148e67e1064789bee435edc5b60ad398714a3a9" + +[[package]] +name = "itoa" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4" + +[[package]] +name = "itoa" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35" + +[[package]] +name = "js-sys" +version = "0.3.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7cc9ffccd38c451a86bf13657df244e9c3f37493cce8e5e21e940963777acc84" +dependencies = [ + "wasm-bindgen", +] + +[[package]] +name = "lazy_static" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" + [[package]] name = "libc" version = "0.2.102" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a2a5ac8f984bfcf3a823267e5fde638acc3325f6496633a5da6bb6eb2171e103" +[[package]] +name = "log" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "matches" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f" + +[[package]] +name = "memchr" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a" + +[[package]] +name = "mime" +version = "0.3.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d" + +[[package]] +name = "mime_guess" +version = "2.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2684d4c2e97d99848d30b324b00c8fcc7e5c897b7cbb5819b09e7c90e8baf212" +dependencies = [ + "mime", + "unicase", +] + +[[package]] +name = "mio" +version = "0.7.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8067b404fe97c70829f082dec8bcf4f71225d7eaea1d8645349cb76fa06205cc" +dependencies = [ + "libc", + "log", + "miow", + "ntapi", + "winapi", +] + +[[package]] +name = "miow" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21" +dependencies = [ + "winapi", +] + +[[package]] +name = "native-tls" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48ba9f7719b5a0f42f338907614285fb5fd70e53858141f69898a1fb7203b24d" +dependencies = [ + "lazy_static", + "libc", + "log", + "openssl", + "openssl-probe", + "openssl-sys", + "schannel", + "security-framework", + "security-framework-sys", + "tempfile", +] + +[[package]] +name = "ntapi" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44" +dependencies = [ + "winapi", +] + +[[package]] +name = "num_cpus" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1" +dependencies = [ + "hermit-abi", + "libc", +] + +[[package]] +name = "once_cell" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5" + +[[package]] +name = "openssl" +version = "0.10.38" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c7ae222234c30df141154f159066c5093ff73b63204dcda7121eb082fc56a95" +dependencies = [ + "bitflags", + "cfg-if", + "foreign-types", + "libc", + "once_cell", + "openssl-sys", +] + +[[package]] +name = "openssl-probe" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" + +[[package]] +name = "openssl-sys" +version = "0.9.72" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e46109c383602735fa0a2e48dd2b7c892b048e1bf69e5c3b1d804b7d9c203cb" +dependencies = [ + "autocfg", + "cc", + "libc", + "pkg-config", + "vcpkg", +] + +[[package]] +name = "percent-encoding" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e" + +[[package]] +name = "pin-project-lite" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e280fbe77cc62c91527259e9442153f4688736748d24660126286329742b4c6c" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "pkg-config" +version = "0.3.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58893f751c9b0412871a09abd62ecd2a00298c6c83befa223ef98c52aef40cbe" + +[[package]] +name = "proc-macro2" +version = "1.0.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029" +dependencies = [ + "unicode-xid", +] + +[[package]] +name = "quote" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47aa80447ce4daf1717500037052af176af5d38cc3e571d9ec1c7353fc10c87d" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "redox_syscall" +version = "0.2.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff" +dependencies = [ + "bitflags", +] + +[[package]] +name = "remove_dir_all" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7" +dependencies = [ + "winapi", +] + +[[package]] +name = "reqwest" +version = "0.11.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87f242f1488a539a79bac6dbe7c8609ae43b7914b7736210f239a37cccb32525" +dependencies = [ + "base64", + "bytes", + "encoding_rs", + "futures-core", + "futures-util", + "h2", + "http", + "http-body", + "hyper", + "hyper-tls", + "ipnet", + "js-sys", + "lazy_static", + "log", + "mime", + "mime_guess", + "native-tls", + "percent-encoding", + "pin-project-lite", + "serde", + "serde_json", + "serde_urlencoded", + "tokio", + "tokio-native-tls", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "winreg", +] + +[[package]] +name = "ryu" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f" + +[[package]] +name = "schannel" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75" +dependencies = [ + "lazy_static", + "winapi", +] + +[[package]] +name = "security-framework" +version = "2.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "525bc1abfda2e1998d152c45cf13e696f76d0a4972310b22fac1658b05df7c87" +dependencies = [ + "bitflags", + "core-foundation", + "core-foundation-sys", + "libc", + "security-framework-sys", +] + +[[package]] +name = "security-framework-sys" +version = "2.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9dd14d83160b528b7bfd66439110573efcfbe281b17fc2ca9f39f550d619c7e" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "serde" +version = "1.0.133" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97565067517b60e2d1ea8b268e59ce036de907ac523ad83a0475da04e818989a" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.133" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed201699328568d8d08208fdd080e3ff594e6c422e438b6705905da01005d537" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.74" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee2bb9cd061c5865d345bb02ca49fcef1391741b672b54a0bf7b679badec3142" +dependencies = [ + "itoa 1.0.1", + "ryu", + "serde", +] + +[[package]] +name = "serde_urlencoded" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edfa57a7f8d9c1d260a549e7224100f6c43d43f9103e06dd8b4095a9b2b43ce9" +dependencies = [ + "form_urlencoded", + "itoa 0.4.8", + "ryu", + "serde", +] + +[[package]] +name = "sgx_alloc" +version = "1.1.4" +source = "git+https://github.com/apache/teaclave-sgx-sdk.git#565960cd7b4b36d1188459d75652619971c43f7e" + +[[package]] +name = "sgx_backtrace_sys" +version = "1.1.4" +source = "git+https://github.com/apache/teaclave-sgx-sdk.git#565960cd7b4b36d1188459d75652619971c43f7e" +dependencies = [ + "cc", + "sgx_build_helper", + "sgx_libc", +] + +[[package]] +name = "sgx_build_helper" +version = "1.1.4" +source = "git+https://github.com/apache/teaclave-sgx-sdk.git#565960cd7b4b36d1188459d75652619971c43f7e" + +[[package]] +name = "sgx_demangle" +version = "1.1.4" +source = "git+https://github.com/apache/teaclave-sgx-sdk.git#565960cd7b4b36d1188459d75652619971c43f7e" + +[[package]] +name = "sgx_libc" +version = "1.1.4" +source = "git+https://github.com/apache/teaclave-sgx-sdk.git#565960cd7b4b36d1188459d75652619971c43f7e" +dependencies = [ + "sgx_types 1.1.4 (git+https://github.com/apache/teaclave-sgx-sdk.git)", +] + +[[package]] +name = "sgx_tprotected_fs" +version = "1.1.4" +source = "git+https://github.com/apache/teaclave-sgx-sdk.git#565960cd7b4b36d1188459d75652619971c43f7e" +dependencies = [ + "sgx_trts", + "sgx_types 1.1.4 (git+https://github.com/apache/teaclave-sgx-sdk.git)", +] + +[[package]] +name = "sgx_trts" +version = "1.1.4" +source = "git+https://github.com/apache/teaclave-sgx-sdk.git#565960cd7b4b36d1188459d75652619971c43f7e" +dependencies = [ + "sgx_libc", + "sgx_types 1.1.4 (git+https://github.com/apache/teaclave-sgx-sdk.git)", +] + +[[package]] +name = "sgx_tstd" +version = "1.1.4" +source = "git+https://github.com/apache/teaclave-sgx-sdk.git#565960cd7b4b36d1188459d75652619971c43f7e" +dependencies = [ + "hashbrown_tstd", + "sgx_alloc", + "sgx_backtrace_sys", + "sgx_demangle", + "sgx_libc", + "sgx_tprotected_fs", + "sgx_trts", + "sgx_types 1.1.4 (git+https://github.com/apache/teaclave-sgx-sdk.git)", + "sgx_unwind", +] + +[[package]] +name = "sgx_types" +version = "1.1.4" + [[package]] name = "sgx_types" version = "1.1.4" +source = "git+https://github.com/apache/teaclave-sgx-sdk.git#565960cd7b4b36d1188459d75652619971c43f7e" + +[[package]] +name = "sgx_unwind" +version = "1.1.4" +source = "git+https://github.com/apache/teaclave-sgx-sdk.git#565960cd7b4b36d1188459d75652619971c43f7e" +dependencies = [ + "sgx_build_helper", +] [[package]] name = "sgx_urts" version = "1.1.4" dependencies = [ "libc", - "sgx_types", + "sgx_types 1.1.4", +] + +[[package]] +name = "skw_ipfs" +version = "0.1.0" +dependencies = [ + "hashbrown", + "reqwest", + "serde", + "serde_json", + "skw_types", +] + +[[package]] +name = "skw_types" +version = "0.1.0" +dependencies = [ + "sgx_tstd", +] + +[[package]] +name = "slab" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9def91fd1e018fe007022791f865d0ccc9b3a0d5001e01aabb8b40e46000afb5" + +[[package]] +name = "socket2" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5dc90fe6c7be1a323296982db1836d1ea9e47b6839496dde9a541bc496df3516" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "syn" +version = "1.0.85" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a684ac3dcd8913827e18cd09a68384ee66c1de24157e3c556c9ab16d85695fb7" +dependencies = [ + "proc-macro2", + "quote", + "unicode-xid", +] + +[[package]] +name = "tempfile" +version = "3.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4" +dependencies = [ + "cfg-if", + "fastrand", + "libc", + "redox_syscall", + "remove_dir_all", + "winapi", +] + +[[package]] +name = "tinyvec" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c1c1d5a42b6245520c249549ec267180beaffcc0615401ac8e31853d4b6d8d2" +dependencies = [ + "tinyvec_macros", +] + +[[package]] +name = "tinyvec_macros" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c" + +[[package]] +name = "tokio" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbbf1c778ec206785635ce8ad57fe52b3009ae9e0c9f574a728f3049d3e55838" +dependencies = [ + "bytes", + "libc", + "memchr", + "mio", + "num_cpus", + "pin-project-lite", + "winapi", +] + +[[package]] +name = "tokio-native-tls" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7d995660bd2b7f8c1568414c1126076c13fbb725c40112dc0120b78eb9b717b" +dependencies = [ + "native-tls", + "tokio", +] + +[[package]] +name = "tokio-util" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e99e1983e5d376cd8eb4b66604d2e99e79f5bd988c3055891dcd8c9e2604cc0" +dependencies = [ + "bytes", + "futures-core", + "futures-sink", + "log", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "tower-service" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6" + +[[package]] +name = "tracing" +version = "0.1.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "375a639232caf30edfc78e8d89b2d4c375515393e7af7e16f01cd96917fb2105" +dependencies = [ + "cfg-if", + "pin-project-lite", + "tracing-core", +] + +[[package]] +name = "tracing-core" +version = "0.1.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f4ed65637b8390770814083d20756f87bfa2c21bf2f110babdc5438351746e4" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "try-lock" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642" + +[[package]] +name = "unicase" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6" +dependencies = [ + "version_check", +] + +[[package]] +name = "unicode-bidi" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f" + +[[package]] +name = "unicode-normalization" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9" +dependencies = [ + "tinyvec", +] + +[[package]] +name = "unicode-xid" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3" + +[[package]] +name = "url" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c" +dependencies = [ + "form_urlencoded", + "idna", + "matches", + "percent-encoding", +] + +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + +[[package]] +name = "version_check" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" + +[[package]] +name = "want" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0" +dependencies = [ + "log", + "try-lock", +] + +[[package]] +name = "wasi" +version = "0.10.2+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6" + +[[package]] +name = "wasm-bindgen" +version = "0.2.78" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "632f73e236b219150ea279196e54e610f5dbafa5d61786303d4da54f84e47fce" +dependencies = [ + "cfg-if", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.78" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a317bf8f9fba2476b4b2c85ef4c4af8ff39c3c7f0cdfeed4f82c34a880aa837b" +dependencies = [ + "bumpalo", + "lazy_static", + "log", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e8d7523cb1f2a4c96c1317ca690031b714a51cc14e05f712446691f413f5d39" +dependencies = [ + "cfg-if", + "js-sys", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.78" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d56146e7c495528bf6587663bea13a8eb588d39b36b679d83972e1a2dbbdacf9" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.78" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7803e0eea25835f8abdc585cd3021b3deb11543c6fe226dcd30b228857c5c5ab" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.78" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0237232789cf037d5480773fe568aac745bfe2afbc11a863e97901780a6b47cc" + +[[package]] +name = "web-sys" +version = "0.3.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38eb105f1c59d9eaa6b5cdc92b859d85b926e82cb2e0945cd0c9259faa6fe9fb" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "winreg" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0120db82e8a1e0b9fb3345a539c478767c0048d842860994d96113d5b667bd69" +dependencies = [ + "winapi", ] diff --git a/enclave/app/Cargo.toml b/enclave/app/Cargo.toml index fc1423d..de9308d 100644 --- a/enclave/app/Cargo.toml +++ b/enclave/app/Cargo.toml @@ -5,5 +5,6 @@ authors = ["SkyeKiwi "] build = "build.rs" [dependencies] +skw_ipfs = { path = "../crates/skw-ipfs" } sgx_types = { path = "../../teaclave-sgx-sdk/sgx_types" } sgx_urts = { path = "../../teaclave-sgx-sdk/sgx_urts" } diff --git a/enclave/app/src/main.rs b/enclave/app/src/main.rs index 429a92b..8057a73 100644 --- a/enclave/app/src/main.rs +++ b/enclave/app/src/main.rs @@ -39,6 +39,11 @@ fn main() { }, }; + const CONTENT: &str = "some random string ..."; + let result = skw_ipfs::IpfsClient::add(CONTENT.as_bytes().to_vec()).unwrap(); + let recovered = skw_ipfs::IpfsClient::cat(result.cid).unwrap(); + println!("{:?}", String::from_utf8(recovered)); + let input_string = String::from("This is a normal world string passed into Enclave!\n"); let mut retval = sgx_status_t::SGX_SUCCESS; diff --git a/enclave/crates/skw-ipfs/src/lib.rs b/enclave/crates/skw-ipfs/src/lib.rs index 5556046..12b0533 100644 --- a/enclave/crates/skw-ipfs/src/lib.rs +++ b/enclave/crates/skw-ipfs/src/lib.rs @@ -108,7 +108,7 @@ impl IpfsClient { #[test] fn ipfs_works() { - const CONTENT: &'static str = "some random string ..."; + const CONTENT: &str = "some random string ..."; let result = IpfsClient::add(CONTENT.as_bytes().to_vec()).unwrap(); let recovered = IpfsClient::cat(result.cid).unwrap(); diff --git a/mock-enclave/src/near-test-contracts/Cargo.toml b/mock-enclave/src/near-test-contracts/Cargo.toml new file mode 100644 index 0000000..f5b09d1 --- /dev/null +++ b/mock-enclave/src/near-test-contracts/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "near-test-contracts" +version = "0.0.0" +publish = false +authors = ["Near Inc "] +# Please update rust-toolchain.toml as well when changing version here: +rust-version = "1.56.0" +edition = "2021" +license = "Apache-2.0" + +[dependencies] +once_cell = "1" +wat = "1.0.40" diff --git a/mock-enclave/src/near-test-contracts/README.md b/mock-enclave/src/near-test-contracts/README.md new file mode 100644 index 0000000..502cfa4 --- /dev/null +++ b/mock-enclave/src/near-test-contracts/README.md @@ -0,0 +1,21 @@ +A collection of smart-contract used in nearcore tests. + +Rust contracts are built via `build.rs`, the Assembly Script contract +is build manually and committed to the git repository. +`res/near_evm.wasm` and `res/ZombieOwnership.bin` are taken from + +and it's for reproduce a performance issue encountered in EVM +contracts. + +If you want to use a contract from rust core, add + +```toml +[dev-dependencies] +near-test-contracts = { path = "../near-test-contracts" } +``` + +to the Cargo.toml and use `near_test_contract::rs_contract()`. + +If you want to use a contract from an integration test, you can read +the wasm file directly from the `./res` directory. To populate +`./res`, you need to make sure that this crate was compiled. diff --git a/mock-enclave/src/near-test-contracts/build.rs b/mock-enclave/src/near-test-contracts/build.rs new file mode 100644 index 0000000..43c43bc --- /dev/null +++ b/mock-enclave/src/near-test-contracts/build.rs @@ -0,0 +1,79 @@ +use std::path::Path; +use std::path::PathBuf; +use std::process::Command; +use std::{env, fs, io, process}; + +fn main() { + if let Err(err) = try_main() { + eprintln!("{}", err); + process::exit(1); + } +} + +fn try_main() -> io::Result<()> { + build_contract("./test-contract-rs", &[], "test_contract_rs")?; + build_contract( + "./test-contract-rs", + &["--features", "nightly_protocol_features"], + "nightly_test_contract_rs", + )?; + build_contract("./contract-for-fuzzing-rs", &[], "contract_for_fuzzing_rs")?; + build_contract( + "./test-contract-rs", + &["--features", "base_protocol"], + "test_contract_rs_base_protocol", + )?; + Ok(()) +} + +fn build_contract(dir: &str, args: &[&str], output: &str) -> io::Result<()> { + let mut cmd = cargo_build_cmd(); + cmd.args(args); + cmd.current_dir(dir); + check_status(cmd)?; + + let target_dir = shared_target_dir().unwrap_or_else(|| format!("./{}/target", dir).into()); + fs::copy( + target_dir.join(format!("wasm32-unknown-unknown/release/{}.wasm", dir.replace('-', "_"))), + format!("./res/{}.wasm", output), + )?; + println!("cargo:rerun-if-changed=./{}/src/lib.rs", dir); + println!("cargo:rerun-if-changed=./{}/Cargo.toml", dir); + Ok(()) +} + +fn cargo_build_cmd() -> Command { + let mut res = Command::new("cargo"); + res.env("RUSTFLAGS", "-C link-arg=-s"); + res.env_remove("CARGO_ENCODED_RUSTFLAGS"); + if let Some(target_dir) = shared_target_dir() { + res.env("CARGO_TARGET_DIR", target_dir); + } + + res.args(&["build", "--target=wasm32-unknown-unknown", "--release"]); + res +} + +fn check_status(mut cmd: Command) -> io::Result<()> { + let status = cmd.status().map_err(|err| { + io::Error::new(io::ErrorKind::Other, format!("command `{:?}` failed to run: {}", cmd, err)) + })?; + if !status.success() { + return Err(io::Error::new( + io::ErrorKind::Other, + format!("command `{:?}` exited with non-zero status: {:?}", cmd, status), + )); + } + Ok(()) +} + +fn shared_target_dir() -> Option { + let target_dir = env::var("CARGO_TARGET_DIR").ok()?; + // Avoid sharing the same target directory with the patent Cargo + // invocation, to avoid deadlock on the target dir. + // + // That is, this logic is needed for the case like the following: + // + // CARGO_TARGET_DIR=/tmp cargo build -p near-test-contracts --release + Some(Path::new(&target_dir).join("near-test-contracts")) +} diff --git a/mock-enclave/src/near-test-contracts/contract-for-fuzzing-rs/Cargo.lock b/mock-enclave/src/near-test-contracts/contract-for-fuzzing-rs/Cargo.lock new file mode 100644 index 0000000..e2d40b9 --- /dev/null +++ b/mock-enclave/src/near-test-contracts/contract-for-fuzzing-rs/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "contract-for-fuzzing-rs" +version = "0.1.0" diff --git a/mock-enclave/src/near-test-contracts/contract-for-fuzzing-rs/Cargo.toml b/mock-enclave/src/near-test-contracts/contract-for-fuzzing-rs/Cargo.toml new file mode 100644 index 0000000..015e490 --- /dev/null +++ b/mock-enclave/src/near-test-contracts/contract-for-fuzzing-rs/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "contract-for-fuzzing-rs" +version = "0.1.0" +authors = ["Near Inc "] +publish = false +# Please update rust-toolchain.toml as well when changing version here: +rust-version = "1.56.0" +edition = "2018" + +[lib] +crate-type = ["cdylib"] + +[profile.release] +codegen-units = 1 +# Tell `rustc` to optimize for small code size. +opt-level = "z" +lto = true +debug = false +panic = "abort" +rpath = false +debug-assertions = false +incremental = false + +[workspace] +members = [] diff --git a/mock-enclave/src/near-test-contracts/contract-for-fuzzing-rs/src/lib.rs b/mock-enclave/src/near-test-contracts/contract-for-fuzzing-rs/src/lib.rs new file mode 100644 index 0000000..c091c51 --- /dev/null +++ b/mock-enclave/src/near-test-contracts/contract-for-fuzzing-rs/src/lib.rs @@ -0,0 +1,304 @@ +use std::mem::size_of; + +#[allow(unused)] +extern "C" { + // ############# + // # Registers # + // ############# + fn read_register(register_id: u64, ptr: u64); + fn register_len(register_id: u64) -> u64; + // ############### + // # Context API # + // ############### + fn current_account_id(register_id: u64); + fn signer_account_id(register_id: u64); + fn signer_account_pk(register_id: u64); + fn predecessor_account_id(register_id: u64); + fn input(register_id: u64); + // TODO #1903 fn block_height() -> u64; + fn block_index() -> u64; + fn block_timestamp() -> u64; + fn epoch_height() -> u64; + fn storage_usage() -> u64; + // ################# + // # Economics API # + // ################# + fn account_balance(balance_ptr: u64); + fn attached_deposit(balance_ptr: u64); + fn prepaid_gas() -> u64; + fn used_gas() -> u64; + // ############ + // # Math API # + // ############ + fn random_seed(register_id: u64); + fn sha256(value_len: u64, value_ptr: u64, register_id: u64); + // ##################### + // # Miscellaneous API # + // ##################### + fn value_return(value_len: u64, value_ptr: u64); + fn panic(); + fn panic_utf8(len: u64, ptr: u64); + fn log_utf8(len: u64, ptr: u64); + fn log_utf16(len: u64, ptr: u64); + fn abort(msg_ptr: u32, filename_ptr: u32, line: u32, col: u32); + // ################ + // # Promises API # + // ################ + fn promise_create( + account_id_len: u64, + account_id_ptr: u64, + method_name_len: u64, + method_name_ptr: u64, + arguments_len: u64, + arguments_ptr: u64, + amount_ptr: u64, + gas: u64, + ) -> u64; + fn promise_then( + promise_index: u64, + account_id_len: u64, + account_id_ptr: u64, + method_name_len: u64, + method_name_ptr: u64, + arguments_len: u64, + arguments_ptr: u64, + amount_ptr: u64, + gas: u64, + ) -> u64; + fn promise_and(promise_idx_ptr: u64, promise_idx_count: u64) -> u64; + fn promise_batch_create(account_id_len: u64, account_id_ptr: u64) -> u64; + fn promise_batch_then(promise_index: u64, account_id_len: u64, account_id_ptr: u64) -> u64; + // ####################### + // # Promise API actions # + // ####################### + fn promise_batch_action_create_account(promise_index: u64); + fn promise_batch_action_deploy_contract(promise_index: u64, code_len: u64, code_ptr: u64); + fn promise_batch_action_function_call( + promise_index: u64, + method_name_len: u64, + method_name_ptr: u64, + arguments_len: u64, + arguments_ptr: u64, + amount_ptr: u64, + gas: u64, + ); + fn promise_batch_action_transfer(promise_index: u64, amount_ptr: u64); + fn promise_batch_action_stake( + promise_index: u64, + amount_ptr: u64, + public_key_len: u64, + public_key_ptr: u64, + ); + fn promise_batch_action_add_key_with_full_access( + promise_index: u64, + public_key_len: u64, + public_key_ptr: u64, + nonce: u64, + ); + fn promise_batch_action_add_key_with_function_call( + promise_index: u64, + public_key_len: u64, + public_key_ptr: u64, + nonce: u64, + allowance_ptr: u64, + receiver_id_len: u64, + receiver_id_ptr: u64, + method_names_len: u64, + method_names_ptr: u64, + ); + fn promise_batch_action_delete_key( + promise_index: u64, + public_key_len: u64, + public_key_ptr: u64, + ); + fn promise_batch_action_delete_account( + promise_index: u64, + beneficiary_id_len: u64, + beneficiary_id_ptr: u64, + ); + // ####################### + // # Promise API results # + // ####################### + fn promise_results_count() -> u64; + fn promise_result(result_idx: u64, register_id: u64) -> u64; + fn promise_return(promise_id: u64); + // ############### + // # Storage API # + // ############### + fn storage_write( + key_len: u64, + key_ptr: u64, + value_len: u64, + value_ptr: u64, + register_id: u64, + ) -> u64; + fn storage_read(key_len: u64, key_ptr: u64, register_id: u64) -> u64; + fn storage_remove(key_len: u64, key_ptr: u64, register_id: u64) -> u64; + fn storage_has_key(key_len: u64, key_ptr: u64) -> u64; + fn storage_iter_prefix(prefix_len: u64, prefix_ptr: u64) -> u64; + fn storage_iter_range(start_len: u64, start_ptr: u64, end_len: u64, end_ptr: u64) -> u64; + fn storage_iter_next(iterator_id: u64, key_register_id: u64, value_register_id: u64) -> u64; + // ############### + // # Validator API # + // ############### + fn validator_stake(account_id_len: u64, account_id_ptr: u64, stake_ptr: u64); + fn validator_total_stake(stake_ptr: u64); + // ################# + // # alt_bn128 API # + // ################# + #[cfg(feature = "protocol_feature_alt_bn128")] + fn alt_bn128_g1_multiexp(value_len: u64, value_ptr: u64, register_id: u64); + #[cfg(feature = "protocol_feature_alt_bn128")] + fn alt_bn128_g1_sum(value_len: u64, value_ptr: u64, register_id: u64); + #[cfg(feature = "protocol_feature_alt_bn128")] + fn alt_bn128_pairing_check(value_len: u64, value_ptr: u64) -> u64; +} + +#[no_mangle] +pub unsafe fn number_from_input() { + input(0); + let value = [0u8; size_of::()]; + read_register(0, value.as_ptr() as u64); + value_return(value.len() as u64, &value as *const u8 as u64); +} + +#[no_mangle] +pub unsafe fn count_sum() { + input(0); + let data = [0u8; size_of::()]; + read_register(0, data.as_ptr() as u64); + + let number_of_numbers = u64::from_le_bytes(data); + + let mut sum: u64 = 0; + + for i in 0..number_of_numbers { + promise_result(i, 0); + + let data = [0u8; size_of::()]; + read_register(0, data.as_ptr() as u64); + + let number = u64::from_le_bytes(data); + sum += number; + } + + let value = sum.to_le_bytes(); + + value_return(value.len() as u64, &value as *const u8 as u64); +} + +#[no_mangle] +pub unsafe fn sum_of_numbers() { + input(0); + let data = [0u8; size_of::()]; + read_register(0, data.as_ptr() as u64); + + let number_of_numbers = u64::from_le_bytes(data); + let mut promise_ids = vec![]; + + for i in 1..=number_of_numbers { + let i: u64 = 1; + let method_name = "number_from_input".as_bytes(); + let account_id = { + signer_account_id(0); + let result = vec![0; register_len(0) as usize]; + read_register(0, result.as_ptr() as *const u64 as u64); + result + }; + let arguments = i.to_le_bytes(); + + promise_ids.push(promise_create( + account_id.len() as u64, + account_id.as_ptr() as u64, + method_name.len() as u64, + method_name.as_ptr() as u64, + arguments.len() as u64, + arguments.as_ptr() as u64, + 0, + 3_000_000_000, + )); + } + + let promise_idx = promise_and(promise_ids.as_ptr() as u64, promise_ids.len() as u64); + + { + let method_name = "count_sum".as_bytes(); + let account_id = { + signer_account_id(0); + let result = vec![0; register_len(0) as usize]; + read_register(0, result.as_ptr() as *const u64 as u64); + result + }; + let arguments = number_of_numbers.to_le_bytes(); + + promise_then( + promise_idx, + account_id.len() as u64, + account_id.as_ptr() as u64, + method_name.len() as u64, + method_name.as_ptr() as u64, + arguments.len() as u64, + arguments.as_ptr() as u64, + 0, + 3_000_000_000_000, + ); + } +} + +// Function that does not do anything at all. +#[no_mangle] +pub fn noop() {} + +#[no_mangle] +pub unsafe fn data_producer() { + input(0); + let data = [0u8; size_of::()]; + read_register(0, data.as_ptr() as u64); + let size = u64::from_le_bytes(data); + + let data = vec![0u8; size as usize]; + value_return(data.len() as _, data.as_ptr() as _); +} + +#[no_mangle] +pub unsafe fn data_receipt_with_size() { + input(0); + let data = [0u8; size_of::()]; + read_register(0, data.as_ptr() as u64); + let size = u64::from_le_bytes(data); + + let buf = [0u8; 1000]; + current_account_id(0); + let buf_len = register_len(0); + read_register(0, buf.as_ptr() as _); + + let method_name = b"data_producer"; + let args = size.to_le_bytes(); + let mut ids = [0u64; 10]; + let amount = 0u128; + let gas = prepaid_gas(); + let id = promise_create( + buf_len, + buf.as_ptr() as _, + method_name.len() as _, + method_name.as_ptr() as _, + args.len() as _, + args.as_ptr() as _, + &amount as *const u128 as *const u64 as u64, + gas / 20, + ); + + let method_name = b"noop"; + let args = b""; + promise_then( + id, + buf_len, + buf.as_ptr() as _, + method_name.len() as _, + method_name.as_ptr() as _, + args.len() as _, + args.as_ptr() as _, + &amount as *const u128 as *const u64 as u64, + gas / 3, + ); +} diff --git a/mock-enclave/src/near-test-contracts/res/.gitignore b/mock-enclave/src/near-test-contracts/res/.gitignore new file mode 100644 index 0000000..51bb69e --- /dev/null +++ b/mock-enclave/src/near-test-contracts/res/.gitignore @@ -0,0 +1,3 @@ +*.wasm +!test_contract_ts.wasm +!near_evm.wasm diff --git a/mock-enclave/src/near-test-contracts/res/ZombieOwnership.bin b/mock-enclave/src/near-test-contracts/res/ZombieOwnership.bin new file mode 100644 index 0000000..bc8e363 --- /dev/null +++ b/mock-enclave/src/near-test-contracts/res/ZombieOwnership.bin @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/mock-enclave/src/near-test-contracts/res/near_evm.wasm b/mock-enclave/src/near-test-contracts/res/near_evm.wasm new file mode 100644 index 0000000..1907938 Binary files /dev/null and b/mock-enclave/src/near-test-contracts/res/near_evm.wasm differ diff --git a/mock-enclave/src/near-test-contracts/res/test_contract_ts.wasm b/mock-enclave/src/near-test-contracts/res/test_contract_ts.wasm new file mode 100644 index 0000000..d8d2e17 Binary files /dev/null and b/mock-enclave/src/near-test-contracts/res/test_contract_ts.wasm differ diff --git a/mock-enclave/src/near-test-contracts/src/lib.rs b/mock-enclave/src/near-test-contracts/src/lib.rs new file mode 100644 index 0000000..0fd0804 --- /dev/null +++ b/mock-enclave/src/near-test-contracts/src/lib.rs @@ -0,0 +1,85 @@ +#![doc = include_str!("../README.md")] + +use once_cell::sync::OnceCell; +use std::fmt::Write; +use std::path::Path; + +/// Trivial contact with a do-nothing main function. +pub fn trivial_contract() -> &'static [u8] { + static CONTRACT: OnceCell> = OnceCell::new(); + CONTRACT + .get_or_init(|| wat::parse_str(r#"(module (func (export "main")))"#).unwrap()) + .as_slice() +} + +/// Standard test contract which can call various host functions. +/// +/// Note: the contract relies on the latest protocol version, and +/// might not work for tests using an older version. +pub fn rs_contract() -> &'static [u8] { + static CONTRACT: OnceCell> = OnceCell::new(); + CONTRACT.get_or_init(|| read_contract("test_contract_rs.wasm")).as_slice() +} + +pub fn rs_contract_base_protocol() -> &'static [u8] { + static CONTRACT: OnceCell> = OnceCell::new(); + CONTRACT.get_or_init(|| read_contract("test_contract_rs_base_protocol.wasm")).as_slice() +} + +pub fn nightly_rs_contract() -> &'static [u8] { + static CONTRACT: OnceCell> = OnceCell::new(); + CONTRACT.get_or_init(|| read_contract("nightly_test_contract_rs.wasm")).as_slice() +} + +pub fn ts_contract() -> &'static [u8] { + static CONTRACT: OnceCell> = OnceCell::new(); + CONTRACT.get_or_init(|| read_contract("test_contract_ts.wasm")).as_slice() +} + +pub fn fuzzing_contract() -> &'static [u8] { + static CONTRACT: OnceCell> = OnceCell::new(); + CONTRACT.get_or_init(|| read_contract("contract_for_fuzzing_rs.wasm")).as_slice() +} + +/// Read given wasm file or panic if unable to. +fn read_contract(file_name: &str) -> Vec { + let base = Path::new(env!("CARGO_MANIFEST_DIR")); + let path = base.join("res").join(file_name); + match std::fs::read(&path) { + Ok(data) => data, + Err(err) => panic!("{}: {}", path.display(), err), + } +} + +#[test] +fn smoke_test() { + assert!(!rs_contract().is_empty()); + assert!(!nightly_rs_contract().is_empty()); + assert!(!ts_contract().is_empty()); + assert!(!trivial_contract().is_empty()); + assert!(!fuzzing_contract().is_empty()); + assert!(!rs_contract_base_protocol().is_empty()); +} + +pub fn many_functions_contract(function_count: u32) -> Vec { + let mut functions = String::new(); + for i in 0..function_count { + writeln!( + &mut functions, + "(func + i32.const {} + drop + return)", + i + ) + .unwrap(); + } + + let code = format!( + r#"(module + (export "main" (func 0)) + {})"#, + functions + ); + wat::parse_str(code).unwrap() +} diff --git a/mock-enclave/src/near-test-contracts/test-contract-rs/Cargo.lock b/mock-enclave/src/near-test-contracts/test-contract-rs/Cargo.lock new file mode 100644 index 0000000..26eebcc --- /dev/null +++ b/mock-enclave/src/near-test-contracts/test-contract-rs/Cargo.lock @@ -0,0 +1,97 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +[[package]] +name = "base64" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd" + +[[package]] +name = "cfg-if" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b486ce3ccf7ffd79fdeb678eac06a9e6c09fc88d33836340becb8fffe87c5e33" + +[[package]] +name = "itoa" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "501266b7edd0174f8530248f87f99c88fbe60ca4ef3dd486835b8d8d53136f7f" + +[[package]] +name = "libc" +version = "0.2.62" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34fcd2c08d2f832f376f4173a231990fa5aef4e99fb569867318a227ef4c06ba" + +[[package]] +name = "memory_units" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8452105ba047068f40ff7093dd1d9da90898e63dd61736462e9cdda6a90ad3c3" + +[[package]] +name = "ryu" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c92464b447c0ee8c4fb3824ecc8383b81717b9f1e74ba2e72540aef7b9f82997" + +[[package]] +name = "serde" +version = "1.0.101" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9796c9b7ba2ffe7a9ce53c2287dfc48080f4b2b362fcc245a259b3a7201119dd" + +[[package]] +name = "serde_json" +version = "1.0.62" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea1c6153794552ea7cf7cf63b1231a25de00ec90db326ba6264440fa08e31486" +dependencies = [ + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "test-contract-rs" +version = "0.1.0" +dependencies = [ + "base64", + "serde_json", + "wee_alloc", +] + +[[package]] +name = "wee_alloc" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dbb3b5a6b2bb17cb6ad44a2e68a43e8d2722c997da10e928665c72ec6c0a0b8e" +dependencies = [ + "cfg-if", + "libc", + "memory_units", + "winapi", +] + +[[package]] +name = "winapi" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8093091eeb260906a183e6ae1abdba2ef5ef2257a21801128899c3fc699229c6" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" diff --git a/mock-enclave/src/near-test-contracts/test-contract-rs/Cargo.toml b/mock-enclave/src/near-test-contracts/test-contract-rs/Cargo.toml new file mode 100644 index 0000000..e2ceac0 --- /dev/null +++ b/mock-enclave/src/near-test-contracts/test-contract-rs/Cargo.toml @@ -0,0 +1,35 @@ +[package] +name = "test-contract-rs" +version = "0.1.0" +authors = ["Near Inc "] +publish = false +# Please update rust-toolchain.toml as well when changing version here: +rust-version = "1.56.0" +edition = "2021" + +[lib] +crate-type = ["cdylib"] + +[dependencies] +base64 = "0.13" +serde_json = "1" +wee_alloc = { version = "0.4.5", default-features = false } + +[profile.release] +codegen-units = 1 +# Tell `rustc` to optimize for small code size. +opt-level = "z" +lto = true +debug = false +panic = "abort" +rpath = false +debug-assertions = false +incremental = false + +[workspace] +members = [] + +[features] +nightly_protocol_features = ["protocol_feature_alt_bn128"] +protocol_feature_alt_bn128 = [] +base_protocol = [] diff --git a/mock-enclave/src/near-test-contracts/test-contract-rs/src/lib.rs b/mock-enclave/src/near-test-contracts/test-contract-rs/src/lib.rs new file mode 100644 index 0000000..8647e19 --- /dev/null +++ b/mock-enclave/src/near-test-contracts/test-contract-rs/src/lib.rs @@ -0,0 +1,804 @@ +#[global_allocator] +static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT; + +use std::mem::size_of; + +#[allow(unused)] +extern "C" { + // ############# + // # Registers # + // ############# + fn read_register(register_id: u64, ptr: u64); + fn register_len(register_id: u64) -> u64; + // ############### + // # Context API # + // ############### + fn current_account_id(register_id: u64); + fn signer_account_id(register_id: u64); + fn signer_account_pk(register_id: u64); + fn predecessor_account_id(register_id: u64); + fn input(register_id: u64); + // TODO #1903 fn block_height() -> u64; + fn block_index() -> u64; + fn block_timestamp() -> u64; + fn epoch_height() -> u64; + fn storage_usage() -> u64; + // ################# + // # Economics API # + // ################# + fn account_balance(balance_ptr: u64); + fn attached_deposit(balance_ptr: u64); + fn prepaid_gas() -> u64; + fn used_gas() -> u64; + // ############ + // # Math API # + // ############ + fn random_seed(register_id: u64); + fn sha256(value_len: u64, value_ptr: u64, register_id: u64); + // ##################### + // # Miscellaneous API # + // ##################### + fn value_return(value_len: u64, value_ptr: u64); + fn panic(); + fn panic_utf8(len: u64, ptr: u64); + fn log_utf8(len: u64, ptr: u64); + fn log_utf16(len: u64, ptr: u64); + fn abort(msg_ptr: u32, filename_ptr: u32, line: u32, col: u32); + // ################ + // # Promises API # + // ################ + fn promise_create( + account_id_len: u64, + account_id_ptr: u64, + method_name_len: u64, + method_name_ptr: u64, + arguments_len: u64, + arguments_ptr: u64, + amount_ptr: u64, + gas: u64, + ) -> u64; + fn promise_then( + promise_index: u64, + account_id_len: u64, + account_id_ptr: u64, + method_name_len: u64, + method_name_ptr: u64, + arguments_len: u64, + arguments_ptr: u64, + amount_ptr: u64, + gas: u64, + ) -> u64; + fn promise_and(promise_idx_ptr: u64, promise_idx_count: u64) -> u64; + fn promise_batch_create(account_id_len: u64, account_id_ptr: u64) -> u64; + fn promise_batch_then(promise_index: u64, account_id_len: u64, account_id_ptr: u64) -> u64; + // ####################### + // # Promise API actions # + // ####################### + fn promise_batch_action_create_account(promise_index: u64); + fn promise_batch_action_deploy_contract(promise_index: u64, code_len: u64, code_ptr: u64); + fn promise_batch_action_function_call( + promise_index: u64, + method_name_len: u64, + method_name_ptr: u64, + arguments_len: u64, + arguments_ptr: u64, + amount_ptr: u64, + gas: u64, + ); + fn promise_batch_action_transfer(promise_index: u64, amount_ptr: u64); + fn promise_batch_action_stake( + promise_index: u64, + amount_ptr: u64, + public_key_len: u64, + public_key_ptr: u64, + ); + fn promise_batch_action_add_key_with_full_access( + promise_index: u64, + public_key_len: u64, + public_key_ptr: u64, + nonce: u64, + ); + fn promise_batch_action_add_key_with_function_call( + promise_index: u64, + public_key_len: u64, + public_key_ptr: u64, + nonce: u64, + allowance_ptr: u64, + receiver_id_len: u64, + receiver_id_ptr: u64, + method_names_len: u64, + method_names_ptr: u64, + ); + fn promise_batch_action_delete_key( + promise_index: u64, + public_key_len: u64, + public_key_ptr: u64, + ); + fn promise_batch_action_delete_account( + promise_index: u64, + beneficiary_id_len: u64, + beneficiary_id_ptr: u64, + ); + // ####################### + // # Promise API results # + // ####################### + fn promise_results_count() -> u64; + fn promise_result(result_idx: u64, register_id: u64) -> u64; + fn promise_return(promise_id: u64); + // ############### + // # Storage API # + // ############### + fn storage_write( + key_len: u64, + key_ptr: u64, + value_len: u64, + value_ptr: u64, + register_id: u64, + ) -> u64; + fn storage_read(key_len: u64, key_ptr: u64, register_id: u64) -> u64; + fn storage_remove(key_len: u64, key_ptr: u64, register_id: u64) -> u64; + fn storage_has_key(key_len: u64, key_ptr: u64) -> u64; + fn storage_iter_prefix(prefix_len: u64, prefix_ptr: u64) -> u64; + fn storage_iter_range(start_len: u64, start_ptr: u64, end_len: u64, end_ptr: u64) -> u64; + fn storage_iter_next(iterator_id: u64, key_register_id: u64, value_register_id: u64) -> u64; + // ################# + // # Validator API # + // ################# + fn validator_stake(account_id_len: u64, account_id_ptr: u64, stake_ptr: u64); + fn validator_total_stake(stake_ptr: u64); + // ################### + // # Math Extensions # + // ################### + #[cfg(not(feature = "base_protocol"))] + fn ripemd160(value_len: u64, value_ptr: u64, register_id: u64); + // ################# + // # alt_bn128 API # + // ################# + #[cfg(feature = "protocol_feature_alt_bn128")] + fn alt_bn128_g1_multiexp(value_len: u64, value_ptr: u64, register_id: u64); + #[cfg(feature = "protocol_feature_alt_bn128")] + fn alt_bn128_g1_sum(value_len: u64, value_ptr: u64, register_id: u64); + #[cfg(feature = "protocol_feature_alt_bn128")] + fn alt_bn128_pairing_check(value_len: u64, value_ptr: u64) -> u64; +} + +macro_rules! ext_test { + ($export_func:ident, $call_ext:expr) => { + #[no_mangle] + pub unsafe fn $export_func() { + $call_ext(0); + let result = vec![0; register_len(0) as usize]; + read_register(0, result.as_ptr() as *const u64 as u64); + value_return(result.len() as u64, result.as_ptr() as *const u64 as u64); + } + }; +} + +macro_rules! ext_test_u64 { + ($export_func:ident, $call_ext:expr) => { + #[no_mangle] + pub unsafe fn $export_func() { + let mut result = [0u8; size_of::()]; + result.copy_from_slice(&$call_ext().to_le_bytes()); + value_return(result.len() as u64, result.as_ptr() as *const u64 as u64); + } + }; +} + +macro_rules! ext_test_u128 { + ($export_func:ident, $call_ext:expr) => { + #[no_mangle] + pub unsafe fn $export_func() { + let result = &[0u8; size_of::()]; + $call_ext(result.as_ptr() as *const u64 as u64); + value_return(result.len() as u64, result.as_ptr() as *const u64 as u64); + } + }; +} + +ext_test_u64!(ext_storage_usage, storage_usage); +ext_test_u64!(ext_block_index, block_index); +ext_test_u64!(ext_block_timestamp, block_timestamp); +ext_test_u64!(ext_prepaid_gas, prepaid_gas); + +ext_test!(ext_random_seed, random_seed); +ext_test!(ext_predecessor_account_id, predecessor_account_id); +ext_test!(ext_signer_pk, signer_account_pk); +ext_test!(ext_signer_id, signer_account_id); +ext_test!(ext_account_id, current_account_id); + +ext_test_u128!(ext_account_balance, account_balance); +ext_test_u128!(ext_attached_deposit, attached_deposit); + +ext_test_u128!(ext_validator_total_stake, validator_total_stake); + +#[no_mangle] +pub unsafe fn ext_sha256() { + input(0); + let bytes = vec![0; register_len(0) as usize]; + read_register(0, bytes.as_ptr() as *const u64 as u64); + sha256(bytes.len() as u64, bytes.as_ptr() as *const u64 as u64, 0); + let result = vec![0; register_len(0) as usize]; + read_register(0, result.as_ptr() as *const u64 as u64); + value_return(result.len() as u64, result.as_ptr() as *const u64 as u64); +} + +#[no_mangle] +pub unsafe fn ext_used_gas() { + let initial_used_gas = used_gas(); + let mut a = 1; + let mut b = 1; + for _ in 0..30 { + let c = a + b; + a = b; + b = c; + } + assert_eq!(a, 1346269); + let gas = used_gas() - initial_used_gas; + let result = gas.to_le_bytes(); + value_return(result.len() as u64, result.as_ptr() as *const u64 as u64); +} + +#[cfg(feature = "protocol_feature_alt_bn128")] +#[no_mangle] +pub unsafe fn ext_alt_bn128_g1_multiexp() { + input(0); + alt_bn128_g1_multiexp(u64::MAX, 0, 1); + value_return(u64::MAX, 1); +} + +#[cfg(feature = "protocol_feature_alt_bn128")] +#[no_mangle] +pub unsafe fn ext_alt_bn128_g1_sum() { + input(0); + alt_bn128_g1_sum(u64::MAX, 0, 1); + value_return(u64::MAX, 1); +} + +#[cfg(feature = "protocol_feature_alt_bn128")] +#[no_mangle] +pub unsafe fn ext_alt_bn128_pairing_check() { + input(0); + let res = alt_bn128_pairing_check(u64::MAX, 0); + let byte = [res as u8; 1]; + value_return(1, byte.as_ptr() as _); +} + +#[no_mangle] +pub unsafe fn ext_validator_stake() { + input(0); + let account_id = vec![0; register_len(0) as usize]; + read_register(0, account_id.as_ptr() as *const u64 as u64); + let result = [0u8; size_of::()]; + validator_stake( + account_id.len() as u64, + account_id.as_ptr() as *const u64 as u64, + result.as_ptr() as *const u64 as u64, + ); + value_return(result.len() as u64, result.as_ptr() as *const u64 as u64); +} + +#[no_mangle] +pub unsafe fn write_key_value() { + input(0); + if register_len(0) != 2 * size_of::() as u64 { + panic() + } + let data = [0u8; 2 * size_of::()]; + read_register(0, data.as_ptr() as u64); + + let key = &data[0..size_of::()]; + let value = &data[size_of::()..]; + let result = storage_write( + key.len() as u64, + key.as_ptr() as u64, + value.len() as u64, + value.as_ptr() as u64, + 1, + ); + value_return(size_of::() as u64, &result as *const u64 as u64); +} + +#[no_mangle] +pub unsafe fn write_block_height() { + let block_height = block_index(); + let mut key = [0u8; size_of::()]; + key.copy_from_slice(&block_height.to_le_bytes()); + let value = b"hello"; + storage_write(key.len() as _, key.as_ptr() as _, value.len() as _, value.as_ptr() as _, 0); +} + +#[no_mangle] +pub unsafe fn write_random_value() { + random_seed(0); + let data = [0u8; 32]; + read_register(0, data.as_ptr() as u64); + let value = b"hello"; + storage_write(data.len() as _, data.as_ptr() as _, value.len() as _, value.as_ptr() as _, 1); +} + +#[no_mangle] +pub unsafe fn read_value() { + input(0); + if register_len(0) != size_of::() as u64 { + panic() + } + let key = [0u8; size_of::()]; + read_register(0, key.as_ptr() as u64); + let result = storage_read(key.len() as u64, key.as_ptr() as u64, 1); + if result == 1 { + let value = [0u8; size_of::()]; + read_register(1, value.as_ptr() as u64); + value_return(value.len() as u64, &value as *const u8 as u64); + } +} + +#[no_mangle] +pub unsafe fn log_something() { + let data = b"hello"; + log_utf8(data.len() as u64, data.as_ptr() as _); +} + +#[no_mangle] +pub unsafe fn loop_forever() { + loop {} +} + +#[no_mangle] +pub unsafe fn abort_with_zero() { + // Tries to abort with 0 ptr to check underflow handling. + abort(0, 0, 0, 0); +} + +#[no_mangle] +pub unsafe fn panic_with_message() { + let data = b"WAT?"; + panic_utf8(data.len() as u64, data.as_ptr() as _); +} + +#[no_mangle] +pub unsafe fn panic_after_logging() { + let data = b"hello"; + log_utf8(data.len() as u64, data.as_ptr() as _); + let data = b"WAT?"; + panic_utf8(data.len() as u64, data.as_ptr() as _); +} + +#[no_mangle] +pub unsafe fn run_test() { + let value: [u8; 4] = 10i32.to_le_bytes(); + value_return(value.len() as u64, value.as_ptr() as _); +} + +#[no_mangle] +pub unsafe fn run_test_with_storage_change() { + let key = b"hello"; + let value = b"world"; + storage_write(key.len() as _, key.as_ptr() as _, value.len() as _, value.as_ptr() as _, 0); +} + +#[no_mangle] +pub unsafe fn sum_with_input() { + input(0); + if register_len(0) != 2 * size_of::() as u64 { + panic() + } + let data = [0u8; 2 * size_of::()]; + read_register(0, data.as_ptr() as u64); + + let mut key = [0u8; size_of::()]; + let mut value = [0u8; size_of::()]; + key.copy_from_slice(&data[..size_of::()]); + value.copy_from_slice(&data[size_of::()..]); + let key = u64::from_le_bytes(key); + let value = u64::from_le_bytes(value); + let result = key + value; + value_return(size_of::() as u64, &result as *const u64 as u64); +} + +/// Writes and reads some data into/from storage. Uses 8-bit key/values. +#[no_mangle] +pub unsafe fn benchmark_storage_8b() { + input(0); + if register_len(0) != size_of::() as u64 { + panic() + } + let data = [0u8; size_of::()]; + read_register(0, data.as_ptr() as u64); + let n: u64 = u64::from_le_bytes(data); + + let mut sum = 0u64; + for i in 0..n { + let el = i.to_le_bytes(); + storage_write(el.len() as u64, el.as_ptr() as u64, el.len() as u64, el.as_ptr() as u64, 0); + + let result = storage_read(el.len() as u64, el.as_ptr() as u64, 0); + if result == 1 { + let value = [0u8; size_of::()]; + read_register(0, value.as_ptr() as u64); + sum += u64::from_le_bytes(value); + } + } + + value_return(size_of::() as u64, &sum as *const u64 as u64); +} + +#[inline] +fn generate_data(data: &mut [u8]) { + for i in 0..data.len() { + data[i] = (i % u8::MAX as usize) as u8; + } +} + +/// Writes and reads some data into/from storage. Uses 10KiB key/values. +#[no_mangle] +pub unsafe fn benchmark_storage_10kib() { + input(0); + if register_len(0) != size_of::() as u64 { + panic() + } + let data = [0u8; size_of::()]; + read_register(0, data.as_ptr() as u64); + let n: u64 = u64::from_le_bytes(data); + + let mut el = [0u8; 10 << 10]; + generate_data(&mut el); + + let mut sum = 0u64; + for i in 0..n { + el[..size_of::()].copy_from_slice(&i.to_le_bytes()); + storage_write(el.len() as u64, el.as_ptr() as u64, el.len() as u64, el.as_ptr() as u64, 0); + + let result = storage_read(el.len() as u64, el.as_ptr() as u64, 0); + if result == 1 { + let el = [0u8; 10 << 10]; + read_register(0, el.as_ptr() as u64); + let mut value = [0u8; size_of::()]; + value.copy_from_slice(&el[0..size_of::()]); + sum += u64::from_le_bytes(value); + } + } + + value_return(size_of::() as u64, &sum as *const u64 as u64); +} + +/// Passes through input into output. +#[no_mangle] +pub unsafe fn pass_through() { + input(0); + if register_len(0) != size_of::() as u64 { + panic() + } + let data = [0u8; size_of::()]; + read_register(0, data.as_ptr() as u64); + value_return(data.len() as u64, data.as_ptr() as u64); +} + +/// Sums numbers. +#[no_mangle] +pub unsafe fn sum_n() { + input(0); + if register_len(0) != size_of::() as u64 { + panic() + } + let data = [0u8; size_of::()]; + read_register(0, data.as_ptr() as u64); + let n = u64::from_le_bytes(data); + + let mut sum = 0u64; + for i in 0..n { + // LLVM optimizes sum += i into O(1) computation, use volatile to thwart + // that. + let new_sum = std::ptr::read_volatile(&sum).wrapping_add(i); + std::ptr::write_volatile(&mut sum, new_sum); + } + + let data = sum.to_le_bytes(); + value_return(data.len() as u64, data.as_ptr() as u64); +} + +/// Calculates Fibonacci numbers in inefficient way. Used to burn gas for the +/// sanity/max_gas_burnt_view.py test. The implementation has exponential +/// complexity (1.62^n to be exact) so even small increase in argument result in +/// large increase in gas use. +#[no_mangle] +pub unsafe fn fibonacci() { + input(0); + if register_len(0) != 1 { + panic() + } + let mut n: u8 = 0; + read_register(0, &mut n as *mut u8 as u64); + let data = fib(n).to_le_bytes(); + value_return(data.len() as u64, data.as_ptr() as u64); +} + +fn fib(n: u8) -> u64 { + if n < 2 { + n as u64 + } else { + fib(n - 2) + fib(n - 1) + } +} + +#[no_mangle] +pub unsafe fn insert_strings() { + input(0); + if register_len(0) != 2 * size_of::() as u64 { + panic() + } + let data = [0u8; 2 * size_of::()]; + read_register(0, data.as_ptr() as u64); + + let mut from = [0u8; size_of::()]; + let mut to = [0u8; size_of::()]; + from.copy_from_slice(&data[..size_of::()]); + to.copy_from_slice(&data[size_of::()..]); + let from = u64::from_le_bytes(from); + let to = u64::from_le_bytes(to); + let s = vec![b'a'; to as usize]; + for i in from..to { + let mut key = s[(to - i) as usize..].to_vec(); + key.push(b'b'); + let value = b"x"; + storage_write( + key.len() as u64, + key.as_ptr() as u64, + value.len() as u64, + value.as_ptr() as u64, + 0, + ); + } +} + +#[no_mangle] +pub unsafe fn delete_strings() { + input(0); + if register_len(0) != 2 * size_of::() as u64 { + panic() + } + let data = [0u8; 2 * size_of::()]; + read_register(0, data.as_ptr() as u64); + + let mut from = [0u8; size_of::()]; + let mut to = [0u8; size_of::()]; + from.copy_from_slice(&data[..size_of::()]); + to.copy_from_slice(&data[size_of::()..]); + let from = u64::from_le_bytes(from); + let to = u64::from_le_bytes(to); + let s = vec![b'a'; to as usize]; + for i in from..to { + let mut key = s[(to - i) as usize..].to_vec(); + key.push(b'b'); + storage_remove(key.len() as u64, key.as_ptr() as u64, 0); + } +} + +#[no_mangle] +pub unsafe fn recurse() { + input(0); + if register_len(0) != size_of::() as u64 { + panic() + } + let data = [0u8; size_of::()]; + read_register(0, data.as_ptr() as u64); + let n = u64::from_le_bytes(data); + let res = internal_recurse(n); + let data = res.to_le_bytes(); + value_return(data.len() as u64, data.as_ptr() as u64); +} + +/// Rust compiler is getting smarter and starts to optimize my deep recursion. +/// We're going to fight it with a more obscure implementations. +#[no_mangle] +fn internal_recurse(n: u64) -> u64 { + if n <= 1 { + n + } else { + let a = internal_recurse(n - 1) + 1; + if a % 2 == 1 { + (a + n) / 2 + } else { + a + } + } +} + +#[no_mangle] +pub fn out_of_memory() { + let mut vec = Vec::new(); + loop { + vec.push(vec![0; 1024]); + } +} + +// Can be used for debugging +#[no_mangle] +fn log_u64(msg: u64) { + unsafe { + log_utf8(8, &msg as *const u64 as u64); + } +} + +pub fn from_base64(s: &str) -> Vec { + base64::decode(s).unwrap() +} + +#[no_mangle] +fn call_promise() { + unsafe { + input(0); + let data = vec![0u8; register_len(0) as usize]; + read_register(0, data.as_ptr() as u64); + let input_args: serde_json::Value = serde_json::from_slice(&data).unwrap(); + for arg in input_args.as_array().unwrap() { + let actual_id = if let Some(create) = arg.get("create") { + let account_id = create["account_id"].as_str().unwrap().as_bytes(); + let method_name = create["method_name"].as_str().unwrap().as_bytes(); + let arguments = serde_json::to_vec(&create["arguments"]).unwrap(); + let amount = create["amount"].as_str().unwrap().parse::().unwrap(); + let gas = create["gas"].as_i64().unwrap() as u64; + promise_create( + account_id.len() as u64, + account_id.as_ptr() as u64, + method_name.len() as u64, + method_name.as_ptr() as u64, + arguments.len() as u64, + arguments.as_ptr() as u64, + &amount as *const u128 as *const u64 as u64, + gas, + ) + } else if let Some(then) = arg.get("then") { + let promise_index = then["promise_index"].as_i64().unwrap() as u64; + let account_id = then["account_id"].as_str().unwrap().as_bytes(); + let method_name = then["method_name"].as_str().unwrap().as_bytes(); + let arguments = serde_json::to_vec(&then["arguments"]).unwrap(); + let amount = then["amount"].as_str().unwrap().parse::().unwrap(); + let gas = then["gas"].as_i64().unwrap() as u64; + promise_then( + promise_index, + account_id.len() as u64, + account_id.as_ptr() as u64, + method_name.len() as u64, + method_name.as_ptr() as u64, + arguments.len() as u64, + arguments.as_ptr() as u64, + &amount as *const u128 as *const u64 as u64, + gas, + ) + } else if let Some(and) = arg.get("and") { + let and = and.as_array().unwrap(); + let mut curr = and[0].as_i64().unwrap() as u64; + for other in &and[1..] { + curr = promise_and(curr, other.as_i64().unwrap() as u64); + } + curr + } else if let Some(batch_create) = arg.get("batch_create") { + let account_id = batch_create["account_id"].as_str().unwrap().as_bytes(); + promise_batch_create(account_id.len() as u64, account_id.as_ptr() as u64) + } else if let Some(batch_then) = arg.get("batch_then") { + let promise_index = batch_then["promise_index"].as_i64().unwrap() as u64; + let account_id = batch_then["account_id"].as_str().unwrap().as_bytes(); + promise_batch_then( + promise_index, + account_id.len() as u64, + account_id.as_ptr() as u64, + ) + } else if let Some(action) = arg.get("action_create_account") { + let promise_index = action["promise_index"].as_i64().unwrap() as u64; + promise_batch_action_create_account(promise_index); + promise_index + } else if let Some(action) = arg.get("action_deploy_contract") { + let promise_index = action["promise_index"].as_i64().unwrap() as u64; + let code = from_base64(action["code"].as_str().unwrap()); + promise_batch_action_deploy_contract( + promise_index, + code.len() as u64, + code.as_ptr() as u64, + ); + promise_index + } else if let Some(action) = arg.get("action_function_call") { + let promise_index = action["promise_index"].as_i64().unwrap() as u64; + let method_name = action["method_name"].as_str().unwrap().as_bytes(); + let arguments = serde_json::to_vec(&action["arguments"]).unwrap(); + let amount = action["amount"].as_str().unwrap().parse::().unwrap(); + let gas = action["gas"].as_i64().unwrap() as u64; + promise_batch_action_function_call( + promise_index, + method_name.len() as u64, + method_name.as_ptr() as u64, + arguments.len() as u64, + arguments.as_ptr() as u64, + &amount as *const u128 as *const u64 as u64, + gas, + ); + promise_index + } else if let Some(action) = arg.get("action_transfer") { + let promise_index = action["promise_index"].as_i64().unwrap() as u64; + let amount = action["amount"].as_str().unwrap().parse::().unwrap(); + promise_batch_action_transfer( + promise_index, + &amount as *const u128 as *const u64 as u64, + ); + promise_index + } else if let Some(action) = arg.get("action_stake") { + let promise_index = action["promise_index"].as_i64().unwrap() as u64; + let amount = action["amount"].as_str().unwrap().parse::().unwrap(); + let public_key = from_base64(action["public_key"].as_str().unwrap()); + promise_batch_action_stake( + promise_index, + &amount as *const u128 as *const u64 as u64, + public_key.len() as u64, + public_key.as_ptr() as u64, + ); + promise_index + } else if let Some(action) = arg.get("action_add_key_with_full_access") { + let promise_index = action["promise_index"].as_i64().unwrap() as u64; + let public_key = from_base64(action["public_key"].as_str().unwrap()); + let nonce = action["nonce"].as_i64().unwrap() as u64; + promise_batch_action_add_key_with_full_access( + promise_index, + public_key.len() as u64, + public_key.as_ptr() as u64, + nonce, + ); + promise_index + } else if let Some(action) = arg.get("action_add_key_with_function_call") { + let promise_index = action["promise_index"].as_i64().unwrap() as u64; + let public_key = from_base64(action["public_key"].as_str().unwrap()); + let nonce = action["nonce"].as_i64().unwrap() as u64; + let allowance = action["allowance"].as_str().unwrap().parse::().unwrap(); + let receiver_id = action["receiver_id"].as_str().unwrap().as_bytes(); + let method_names = action["method_names"].as_str().unwrap().as_bytes(); + promise_batch_action_add_key_with_function_call( + promise_index, + public_key.len() as u64, + public_key.as_ptr() as u64, + nonce, + &allowance as *const u128 as *const u64 as u64, + receiver_id.len() as u64, + receiver_id.as_ptr() as u64, + method_names.len() as u64, + method_names.as_ptr() as u64, + ); + promise_index + } else if let Some(action) = arg.get("action_delete_key") { + let promise_index = action["promise_index"].as_i64().unwrap() as u64; + let public_key = from_base64(action["public_key"].as_str().unwrap()); + promise_batch_action_delete_key( + promise_index, + public_key.len() as u64, + public_key.as_ptr() as u64, + ); + promise_index + } else if let Some(action) = arg.get("action_delete_account") { + let promise_index = action["promise_index"].as_i64().unwrap() as u64; + let beneficiary_id = action["beneficiary_id"].as_str().unwrap().as_bytes(); + promise_batch_action_delete_account( + promise_index, + beneficiary_id.len() as u64, + beneficiary_id.as_ptr() as u64, + ); + promise_index + } else { + unimplemented!() + }; + let expected_id = arg["id"].as_i64().unwrap() as u64; + assert_eq!(actual_id, expected_id); + if let Some(ret) = arg.get("return") { + if ret.as_bool().unwrap() == true { + promise_return(actual_id); + } + } + } + } +} + +#[cfg(not(feature = "base_protocol"))] +#[no_mangle] +fn do_ripemd() { + let data = b"tesdsst"; + unsafe { + ripemd160(data.len() as _, data.as_ptr() as _, 0); + } +} diff --git a/mock-enclave/src/near-test-contracts/test-contract-ts/.gitignore b/mock-enclave/src/near-test-contracts/test-contract-ts/.gitignore new file mode 100644 index 0000000..378eac2 --- /dev/null +++ b/mock-enclave/src/near-test-contracts/test-contract-ts/.gitignore @@ -0,0 +1 @@ +build diff --git a/mock-enclave/src/near-test-contracts/test-contract-ts/README.md b/mock-enclave/src/near-test-contracts/test-contract-ts/README.md new file mode 100644 index 0000000..575f63b --- /dev/null +++ b/mock-enclave/src/near-test-contracts/test-contract-ts/README.md @@ -0,0 +1,31 @@ +A smart contract written in AssemblyScript that can be used to make +sure near runtime is compatible with AssemblyScript smart contracts. + +# Pre-requisites + +Switch to the smart contract directory and point npm to AssemblyScript: +```bash +npm install --save-dev AssemblyScript/assemblyscript +``` + +Then install dependencies with +```bash +npm install +``` + +# Building + +Build smart contract with: +```bash +npm run asbuild:untouched +``` + +And copy the smart contract into `res` directory: +```bash +cp build/untouched.wasm ../res/test_contract_ts.wasm +``` + +Then run the Rust integration test with: +```bash +cargo test --package near-vm-runner --test test_ts_contract "" -- --nocapture +``` diff --git a/mock-enclave/src/near-test-contracts/test-contract-ts/assembly/index.ts b/mock-enclave/src/near-test-contracts/test-contract-ts/assembly/index.ts new file mode 100644 index 0000000..7849e55 --- /dev/null +++ b/mock-enclave/src/near-test-contracts/test-contract-ts/assembly/index.ts @@ -0,0 +1,57 @@ +@external("env", "read_register") +declare function read_register(register_id: u64, ptr: u64): void; +@external("env", "register_len") +declare function register_len(register_id: u64): u64; + +@external("env", "storage_write") +declare function storage_write(key_len: u64, key_ptr: u64, value_len: u64, value_ptr: u64, register_id: u64): u64; +@external("env", "storage_read") +declare function storage_read(key_len: u64, key_ptr: u64, register_id: u64): u64; + +@external("env", "input") +declare function input(register_id: u64): void; +@external("env", "value_return") +declare function value_return(value_len: u64, value_ptr: u64): void; + +@external("env", "panic") +declare function panic(): void; + +export function try_storage_write(): void { + input(0); + let len = register_len(0); + if (len == U64.MAX_VALUE) { + panic(); + } + let buffer = new Uint8Array(len as i32); + read_register(0, buffer.buffer as u64); + let input_str = String.UTF8.decode(buffer.buffer); + let input_split = input_str.split(" "); + let key_str = input_split[0]; + let value_str = input_split[1] + + let key = String.UTF8.encode(key_str); + let value = String.UTF8.encode(value_str); + storage_write(key.byteLength, key as u64, value.byteLength, value as u64, 0); +} + +export function try_storage_read(): void { + input(0); + let key_len = register_len(0); + if (key_len == U64.MAX_VALUE) { + panic(); + } + let key = new Uint8Array(key_len as i32); + read_register(0, key.buffer as u64); + + let res = storage_read(key.buffer.byteLength, key.buffer as u64, 1); + if (res == 1) { + let value_len = register_len(1); + let value = new Uint8Array(value_len as i32); + read_register(1, value.buffer as u64); + value_return(value.buffer.byteLength, value.buffer as u64); + } +} + +export function try_panic(): void { + panic(); +} diff --git a/mock-enclave/src/near-test-contracts/test-contract-ts/assembly/tsconfig.json b/mock-enclave/src/near-test-contracts/test-contract-ts/assembly/tsconfig.json new file mode 100644 index 0000000..c614e5c --- /dev/null +++ b/mock-enclave/src/near-test-contracts/test-contract-ts/assembly/tsconfig.json @@ -0,0 +1,6 @@ +{ + "extends": "../node_modules/assemblyscript/std/assembly.json", + "include": [ + "./**/*.ts" + ] +} \ No newline at end of file diff --git a/mock-enclave/src/near-test-contracts/test-contract-ts/package-lock.json b/mock-enclave/src/near-test-contracts/test-contract-ts/package-lock.json new file mode 100644 index 0000000..48e341a --- /dev/null +++ b/mock-enclave/src/near-test-contracts/test-contract-ts/package-lock.json @@ -0,0 +1,3 @@ +{ + "lockfileVersion": 1 +} diff --git a/mock-enclave/src/near-test-contracts/test-contract-ts/package.json b/mock-enclave/src/near-test-contracts/test-contract-ts/package.json new file mode 100644 index 0000000..34f562f --- /dev/null +++ b/mock-enclave/src/near-test-contracts/test-contract-ts/package.json @@ -0,0 +1,7 @@ +{ + "scripts": { + "asbuild:untouched": "asc assembly/index.ts -b build/untouched.wasm -t build/untouched.wat --sourceMap --validate --debug", + "asbuild:optimized": "asc assembly/index.ts -b build/optimized.wasm -t build/optimized.wat --sourceMap --validate --optimize", + "asbuild": "npm run asbuild:untouched && npm run asbuild:optimized" + } +} diff --git a/mock-enclave/src/skw-vm-engine-cli/Cargo.lock b/mock-enclave/src/skw-vm-engine-cli/Cargo.lock index d97016d..45aa419 100644 --- a/mock-enclave/src/skw-vm-engine-cli/Cargo.lock +++ b/mock-enclave/src/skw-vm-engine-cli/Cargo.lock @@ -1451,7 +1451,6 @@ dependencies = [ "sha2", "sha3", "skw-vm-primitives", - "wasmi", ] [[package]] @@ -1461,6 +1460,7 @@ dependencies = [ "num-rational 0.3.2", "serde", "sha2", + "wasmi", ] [[package]] diff --git a/mock-enclave/src/skw-vm-engine/Cargo.lock b/mock-enclave/src/skw-vm-engine/Cargo.lock index 947f3e3..52dd68e 100644 --- a/mock-enclave/src/skw-vm-engine/Cargo.lock +++ b/mock-enclave/src/skw-vm-engine/Cargo.lock @@ -849,7 +849,6 @@ dependencies = [ [[package]] name = "near-test-contracts" version = "0.0.0" -source = "git+https://github.com/near/nearcore?tag=crates-0.11.0#8d04fa95d4cb8191e636bd24517ea7744b78ec5f" dependencies = [ "once_cell", "wat", @@ -1331,7 +1330,6 @@ dependencies = [ "sha2", "sha3", "skw-vm-primitives", - "wasmi", ] [[package]] @@ -1341,6 +1339,7 @@ dependencies = [ "num-rational 0.3.2", "serde", "sha2", + "wasmi", ] [[package]] diff --git a/mock-enclave/src/skw-vm-engine/Cargo.toml b/mock-enclave/src/skw-vm-engine/Cargo.toml index bf43ea7..2c173bb 100644 --- a/mock-enclave/src/skw-vm-engine/Cargo.toml +++ b/mock-enclave/src/skw-vm-engine/Cargo.toml @@ -36,7 +36,7 @@ tracing = { version = "0.1", default-features = false } threadpool = "1.8.1" [dev-dependencies] -near-test-contracts = { git = "https://github.com/near/nearcore", tag = "crates-0.11.0" } +near-test-contracts = { path = "../near-test-contracts" } assert_matches = "1.3" wat = "1.0.40" base64 = "0.13" diff --git a/mock-enclave/src/skw-vm-engine/src/cache.rs b/mock-enclave/src/skw-vm-engine/src/cache.rs index 06a00ed..8637c2a 100644 --- a/mock-enclave/src/skw-vm-engine/src/cache.rs +++ b/mock-enclave/src/skw-vm-engine/src/cache.rs @@ -20,17 +20,6 @@ pub fn create_module_instance(contract_code: &ContractCode, config: &VMConfig) - let code_hash = contract_code.hash; MODULE_CACHE.write().unwrap().get(&code_hash); - // match get_module_instance(&code_hash) { - // Some(Ok(module_ref)) => Ok(module_ref), - // None => {} - - // // we should not ever get here - // // toxic cache - removing - // Some(Err(_)) => { - // MODULE_CACHE.write().unwrap().pop(&code_hash); - // } - // } - let mut cache = MODULE_CACHE.write().unwrap(); match cache.get(&code_hash).map(create_instance) { Some(Ok(module_ref)) => return Ok(module_ref), @@ -56,13 +45,13 @@ pub fn create_module_instance(contract_code: &ContractCode, config: &VMConfig) - result } -// pub fn get_module_instance(code_hash: &CryptoHash) -> Option> { -// MODULE_CACHE -// .read() -// .unwrap() -// .peek(code_hash) -// .map(create_instance) -// } +pub fn get_module_instance(code_hash: &CryptoHash) -> Option> { + MODULE_CACHE + .read() + .unwrap() + .peek(code_hash) + .map(create_instance) +} pub fn create_instance(module: &wasmi::Module) -> Result { let resolver = WasmiImportResolver {}; diff --git a/mock-enclave/src/skw-vm-engine/src/externals.rs b/mock-enclave/src/skw-vm-engine/src/externals.rs index 741b05f..77ee51b 100644 --- a/mock-enclave/src/skw-vm-engine/src/externals.rs +++ b/mock-enclave/src/skw-vm-engine/src/externals.rs @@ -1,5 +1,10 @@ -use wasmi::{Externals, RuntimeArgs, RuntimeValue, Trap, TrapKind}; +use wasmi::{ + Externals, RuntimeArgs, Trap, TrapKind, HostError, + RuntimeValue, +}; + use skw_vm_host::{VMLogic}; +use skw_vm_primitives::errors::{VMLogicError}; #[derive(PartialEq, Eq)] pub enum HostFunctions { @@ -121,28 +126,342 @@ impl<'a> Externals for VMHost<'a> { args: RuntimeArgs, ) -> Result, Trap> { match HostFunctions::from(index) { - HostFunctions::ReadRegister => { - let register_id: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; - let ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; - // Some(self.0.read_register(register_id, ptr).unwrap()) - Ok(None) - }, - _ => { - Ok(None) - } - // HostFunctions::RegisterLen => { - // let register_id: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; - // self.register_len(register_id)? - // }, - // HostFunctions::WriteRegister => { - // let register_id: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; - // let data_len: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; - // let data_ptr: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; - // self.write_register(register_id, data_len, data_ptr)? - // }, - // _ => { - // println!("BOOOOO"); - // } + HostFunctions::ReadRegister => { + let register_id: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.read_register(register_id, ptr) + .map(|_| None) + .map_err(|e| e.into()) + }, + HostFunctions::RegisterLen => { + let register_id: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.register_len(register_id) + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::WriteRegister => { + let register_id: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let data_len: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let data_ptr: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.write_register(register_id, data_len, data_ptr) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::CurrentAccountId => { + let register_id: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.current_account_id(register_id) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::SignerAccountId => { + let register_id: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.signer_account_id(register_id) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::SignerAccountPublicKey => { + let register_id: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.signer_account_pk(register_id) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::PredecessorAccountId => { + let register_id: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.predecessor_account_id(register_id) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::Input => { + let register_id: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.input(register_id) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::BlockNumber => { + self.0.block_number() + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::BlockTimestamp => { + self.0.block_timestamp() + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::EpochHeight => { + self.0.epoch_height() + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::StorageUsage => { + self.0.storage_usage() + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::AccountBalance => { + let balance_ptr: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.account_balance(balance_ptr) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::AttachedDeposit => { + let balance_ptr: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.attached_deposit(balance_ptr) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::PrepaidGas => { + self.0.prepaid_gas() + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::UsedGas => { + self.0.used_gas() + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::RandomSeed => { + let register_id: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.random_seed(register_id) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::Sha256 => { + let value_len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let value_ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let register_id: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.sha256(value_len, value_ptr, register_id) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::Keccak256 => { + let value_len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let value_ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let register_id: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.keccak256(value_len, value_ptr, register_id) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::Keccak512 => { + let value_len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let value_ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let register_id: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.keccak512(value_len, value_ptr, register_id) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::Ripemd160 => { + let value_len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let value_ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let register_id: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.ripemd160(value_len, value_ptr, register_id) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::Ecrecover => { + let hash_len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let hash_ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let sign_len: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + let sig_ptr: u64 = args.nth_checked(3).map_err(|_| TrapKind::UnexpectedSignature)?; + let v: u64 = args.nth_checked(4).map_err(|_| TrapKind::UnexpectedSignature)?; + let malleability_flag: u64 = args.nth_checked(5).map_err(|_| TrapKind::UnexpectedSignature)?; + let register_id: u64 = args.nth_checked(6).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.ecrecover(hash_len, hash_ptr, sign_len, sig_ptr, v, malleability_flag, register_id) + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::ValueReturn => { + let value_len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let value_ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.value_return(value_len, value_ptr) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::Panic => { + self.0.panic() + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::PanicUtf8 => { + let len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.panic_utf8(len, ptr) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::LogUtf8 => { + let len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.log_utf8(len, ptr) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::LogUtf16 => { + let len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.log_utf16(len, ptr) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::Abort => { + let msg_ptr: u32 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let filename_ptr: u32 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let line: u32 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + let col: u32 = args.nth_checked(3).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.abort(msg_ptr, filename_ptr, line, col) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::PromiseCreate => { + let account_id_len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let account_id_ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let method_name_len: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + let method_name_ptr: u64 = args.nth_checked(3).map_err(|_| TrapKind::UnexpectedSignature)?; + let arguments_len: u64 = args.nth_checked(4).map_err(|_| TrapKind::UnexpectedSignature)?; + let arguments_ptr: u64 = args.nth_checked(5).map_err(|_| TrapKind::UnexpectedSignature)?; + let amount_ptr: u64 = args.nth_checked(6).map_err(|_| TrapKind::UnexpectedSignature)?; + let gas: u64 = args.nth_checked(7).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.promise_create(account_id_len, account_id_ptr, method_name_len, method_name_ptr, arguments_len, arguments_ptr, amount_ptr, gas) + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::PromiseThen => { + let promise_index: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let account_id_len: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let account_id_ptr: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + let method_name_len: u64 = args.nth_checked(3).map_err(|_| TrapKind::UnexpectedSignature)?; + let method_name_ptr: u64 = args.nth_checked(4).map_err(|_| TrapKind::UnexpectedSignature)?; + let arguments_len: u64 = args.nth_checked(5).map_err(|_| TrapKind::UnexpectedSignature)?; + let arguments_ptr: u64 = args.nth_checked(6).map_err(|_| TrapKind::UnexpectedSignature)?; + let amount_ptr: u64 = args.nth_checked(7).map_err(|_| TrapKind::UnexpectedSignature)?; + let gas: u64 = args.nth_checked(8).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.promise_then(promise_index, account_id_len, account_id_ptr, method_name_len, method_name_ptr, arguments_len, arguments_ptr, amount_ptr, gas) + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::PromiseAnd => { + let promise_idx_ptr: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let promise_idx_count: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.promise_and(promise_idx_ptr, promise_idx_count) + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::PromiseBatchCreate => { + let account_id_len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let account_id_ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.promise_batch_create(account_id_len, account_id_ptr) + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::PromiseBatchThen => { + let promise_index: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let account_id_len: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let account_id_ptr: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.promise_batch_then(promise_index, account_id_len, account_id_ptr) + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::PromiseBatchActionCreateAccount => { + let promise_index: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.promise_batch_action_create_account(promise_index) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::PromiseBatchActionDeployContract => { + let promise_index: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let code_len: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let code_ptr: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.promise_batch_action_deploy_contract(promise_index, code_len, code_ptr) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::PromiseBatchActionFunctionCall => { + let promise_index: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let method_name_len: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let method_name_ptr: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + let arguments_len: u64 = args.nth_checked(3).map_err(|_| TrapKind::UnexpectedSignature)?; + let arguments_ptr: u64 = args.nth_checked(4).map_err(|_| TrapKind::UnexpectedSignature)?; + let amount_ptr: u64 = args.nth_checked(5).map_err(|_| TrapKind::UnexpectedSignature)?; + let gas: u64 = args.nth_checked(6).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.promise_batch_action_function_call(promise_index, method_name_len, method_name_ptr, arguments_len, arguments_ptr, amount_ptr, gas) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::PromiseBatchActionTransfer => { + let promise_index: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let amount_ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.promise_batch_action_transfer(promise_index, amount_ptr) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::PromiseBatchActionDeleteAccount => { + let promise_index: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let beneficiary_id_len: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let beneficiary_id_ptr: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.promise_batch_action_delete_account(promise_index, beneficiary_id_len, beneficiary_id_ptr) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::PromiseResultsCount => { + self.0.promise_results_count() + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::PromiseResult => { + let result_idx: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let register_id: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.promise_result(result_idx, register_id) + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::PromiseReturn => { + let promise_idx: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.promise_return(promise_idx) + .map(|_| None ) + .map_err(|e| e.into()) + }, + HostFunctions::StorageWrite => { + let key_len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let key_ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let value_len: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + let value_ptr: u64 = args.nth_checked(3).map_err(|_| TrapKind::UnexpectedSignature)?; + let register_id: u64 = args.nth_checked(4).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.storage_write(key_len, key_ptr, value_len, value_ptr, register_id) + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::StorageRead => { + let key_len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let key_ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let register_id: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.storage_read(key_len, key_ptr, register_id) + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::StorageRemove => { + let key_len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let key_ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + let register_id: u64 = args.nth_checked(2).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.storage_remove(key_len, key_ptr, register_id) + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::StorageHasKey => { + let key_len: u64 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + let key_ptr: u64 = args.nth_checked(1).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.storage_has_key(key_len, key_ptr) + .map(|ret| Some(ret.into()) ) + .map_err(|e| e.into()) + }, + HostFunctions::Gas => { + let gas_amount: u32 = args.nth_checked(0).map_err(|_| TrapKind::UnexpectedSignature)?; + self.0.gas(gas_amount) + .map(|_| None ) + .map_err(|e| e.into()) + }, + + _ => { + Err(Trap::new(TrapKind::Unreachable)) + } } } } diff --git a/mock-enclave/src/skw-vm-host/Cargo.toml b/mock-enclave/src/skw-vm-host/Cargo.toml index 696fb00..76c1220 100644 --- a/mock-enclave/src/skw-vm-host/Cargo.toml +++ b/mock-enclave/src/skw-vm-host/Cargo.toml @@ -25,7 +25,6 @@ parity-secp256k1 = "0.7" near-crypto = { git = "https://github.com/near/nearcore" } skw-vm-primitives = { path = "../skw-vm-primitives" } -wasmi = "0.10.0" bn = { package = "zeropool-bn", version = "0.5.9", features = [], optional = true } diff --git a/mock-enclave/src/skw-vm-primitives/Cargo.toml b/mock-enclave/src/skw-vm-primitives/Cargo.toml index cbee7ef..400f8ff 100644 --- a/mock-enclave/src/skw-vm-primitives/Cargo.toml +++ b/mock-enclave/src/skw-vm-primitives/Cargo.toml @@ -16,6 +16,7 @@ Primitives types for the SkyeKiwi Network Secret Contracts sha2 = "0.9" serde = { version = "1", optional = true } num-rational = { version = "0.3.1", default-features = false } +wasmi = "0.10.0" [features] default = ["std"] diff --git a/mock-enclave/src/skw-vm-primitives/src/errors.rs b/mock-enclave/src/skw-vm-primitives/src/errors.rs index b6a06b0..cddc0ec 100644 --- a/mock-enclave/src/skw-vm-primitives/src/errors.rs +++ b/mock-enclave/src/skw-vm-primitives/src/errors.rs @@ -223,6 +223,8 @@ pub enum VMLogicError { InconsistentStateError(InconsistentStateError), } +impl wasmi::HostError for VMLogicError {} + /// An error which can be returned when parsing a NEAR Account ID. #[derive(Eq, Clone, Debug, PartialEq)] pub struct ParseAccountError {