ABI embedding

examples/abi/Cargo.toml

@@ -12,6 +12,13 @@ near-sdk = { path = "../../near-sdk", features = ["abi"] }
 serde = { version = "1", features = ["derive"] }
 schemars = "0.8"
 
+[dev-dependencies]
+workspaces = "0.4.1"
+serde_json = "1.0"
+tokio = { version = "1.14", features = ["full"] }
+anyhow = "1.0"
+near-abi = "0.1.0-pre.0"
+
 [profile.release]
 codegen-units = 1
 # Tell `rustc` to optimize for small code size.

examples/abi/src/lib.rs

@@ -44,3 +44,44 @@ impl Adder {
 fn sum_pair(a: &Pair, b: &Pair) -> Pair {
     Pair(a.0 + b.0, a.1 + b.1)
 }
+
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod tests {
+    use near_abi::*;
+    use tokio::fs;
+    use workspaces::prelude::*;
+
+    #[ignore]
+    #[tokio::test]
+    async fn embedded_abi_test() -> anyhow::Result<()> {
+        let wasm = fs::read("res/abi.wasm").await?;
+        let worker = workspaces::sandbox().await?;
+        let contract = worker.dev_deploy(&wasm).await?;
+
+        let res = contract.view(&worker, "__contract_abi", vec![]).await?;
+        let abi_root = serde_json::from_slice::<AbiRoot>(&res.result).unwrap();
+
+        assert_eq!(abi_root.schema_version, "0.1.0");
+        assert_eq!(abi_root.metadata.name, Some("abi".to_string()));
+        assert_eq!(abi_root.metadata.version, Some("0.1.0".to_string()));
+        assert_eq!(
+            &abi_root.metadata.authors[..],
+            &["Near Inc <[email protected]>".to_string()]
+        );
+        assert_eq!(abi_root.body.functions.len(), 3);
+
+        let add_function = &abi_root.body.functions[0];
+
+        assert_eq!(add_function.name, "add".to_string());
+        assert_eq!(add_function.doc, Some(" Adds two pairs point-wise.".to_string()));
+        assert!(add_function.is_view);
+        assert!(!add_function.is_init);
+        assert!(!add_function.is_payable);
+        assert!(!add_function.is_private);
+        assert_eq!(add_function.params.len(), 2);
+        assert_eq!(add_function.params[0].name, "a".to_string());
+        assert_eq!(add_function.params[1].name, "b".to_string());
+
+        Ok(())
+    }
+}

near-sdk-macros/Cargo.toml

@@ -21,4 +21,5 @@ quote = "1.0"
 Inflector = { version = "0.11.4", default-features = false, features = [] }
 
 [features]
-abi = []
+__abi-embed = []
+__abi-generate = []

near-sdk-macros/src/core_impl/abi/abi_embed.rs

@@ -0,0 +1,15 @@
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+
+pub fn embed() -> TokenStream2 {
+    let abi_path = env!("CARGO_NEAR_ABI_PATH");
+    quote! {
+        const _: () = {
+            const __CONTRACT_ABI: &'static [u8] = include_bytes!(#abi_path);
+            #[no_mangle]
+            pub extern "C" fn __contract_abi() {
+                near_sdk::env::value_return(__CONTRACT_ABI);
+            }
+        };
+    }
+}

near-sdk-macros/src/core_impl/abi.rs → near-sdk-macros/src/core_impl/abi/abi_generator.rs

@@ -18,15 +18,18 @@ pub fn generate(i: &ItemImplInfo) -> TokenStream2 {
 
     let functions: Vec<TokenStream2> = public_functions.iter().map(|m| m.abi_struct()).collect();
     let first_function_name = &public_functions[0].attr_signature_info.ident;
-    let near_abi_symbol = format_ident!("__near_abi_{}", &first_function_name);
+    let near_abi_symbol = format_ident!("__near_abi_{}", first_function_name);
     quote! {
         #[cfg(not(target_arch = "wasm32"))]
         const _: () = {
             #[no_mangle]
             pub fn #near_abi_symbol() -> near_sdk::__private::ChunkedAbiEntry {
                 let mut gen = near_sdk::__private::schemars::gen::SchemaGenerator::default();
                 let functions = vec![#(#functions),*];
-                near_sdk::__private::ChunkedAbiEntry::new(functions, gen.into_root_schema_for::<String>())
+                near_sdk::__private::ChunkedAbiEntry::new(
+                    functions,
+                    gen.into_root_schema_for::<String>()
+                )
             }
         };
     }

near-sdk-macros/src/core_impl/abi/mod.rs

@@ -0,0 +1,9 @@
+#[cfg(feature = "__abi-embed")]
+mod abi_embed;
+#[cfg(feature = "__abi-embed")]
+pub use abi_embed::embed;
+
+#[cfg(feature = "__abi-generate")]
+mod abi_generator;
+#[cfg(feature = "__abi-generate")]
+pub use abi_generator::generate;

near-sdk-macros/src/core_impl/mod.rs

@@ -1,4 +1,4 @@
-#[cfg(feature = "abi")]
+#[cfg(any(feature = "__abi-embed", feature = "__abi-generate"))]
 pub(crate) mod abi;
 mod code_generator;
 mod info_extractor;

near-sdk-macros/src/core_impl/utils/mod.rs

@@ -43,7 +43,7 @@ pub(crate) fn extract_ok_type(ty: &Type) -> Option<&Type> {
 /// Checks whether the given path is literally "Vec".
 /// Note that it won't match a fully qualified name `std::vec::Vec` or a type alias like
 /// `type MyVec = Vec<String>`.
-#[cfg(feature = "abi")]
+#[cfg(feature = "__abi-generate")]
 fn path_is_vec(path: &Path) -> bool {
     path.leading_colon.is_none()
         && path.segments.len() == 1
@@ -53,7 +53,7 @@ fn path_is_vec(path: &Path) -> bool {
 /// Extracts the inner generic type from a `Vec<_>` type.
 ///
 /// For example, given `Vec<String>` this function will return `String`.
-#[cfg(feature = "abi")]
+#[cfg(feature = "__abi-generate")]
 pub(crate) fn extract_vec_type(ty: &Type) -> Option<&Type> {
     match ty {
         Type::Path(type_path) if type_path.qself.is_none() && path_is_vec(&type_path.path) => {

near-sdk-macros/src/lib.rs

@@ -8,7 +8,7 @@ use proc_macro::TokenStream;
 
 use self::core_impl::*;
 use proc_macro2::Span;
-use quote::quote;
+use quote::{quote, ToTokens};
 use syn::visit::Visit;
 use syn::{File, ItemEnum, ItemImpl, ItemStruct, ItemTrait};
 
@@ -47,15 +47,25 @@ use syn::{File, ItemEnum, ItemImpl, ItemStruct, ItemTrait};
 pub fn near_bindgen(_attr: TokenStream, item: TokenStream) -> TokenStream {
     if let Ok(input) = syn::parse::<ItemStruct>(item.clone()) {
         let ext_gen = generate_ext_structs(&input.ident, Some(&input.generics));
+        #[cfg(feature = "__abi-embed")]
+        let abi_embedded = abi::embed();
+        #[cfg(not(feature = "__abi-embed"))]
+        let abi_embedded = quote! {};
         TokenStream::from(quote! {
             #input
             #ext_gen
+            #abi_embedded
         })
     } else if let Ok(input) = syn::parse::<ItemEnum>(item.clone()) {
         let ext_gen = generate_ext_structs(&input.ident, Some(&input.generics));
+        #[cfg(feature = "__abi-embed")]
+        let abi_embedded = abi::embed();
+        #[cfg(not(feature = "__abi-embed"))]
+        let abi_embedded = quote! {};
         TokenStream::from(quote! {
             #input
             #ext_gen
+            #abi_embedded
         })
     } else if let Ok(mut input) = syn::parse::<ItemImpl>(item) {
         let item_impl_info = match ItemImplInfo::new(&mut input) {
@@ -65,11 +75,23 @@ pub fn near_bindgen(_attr: TokenStream, item: TokenStream) -> TokenStream {
             }
         };
 
-        #[cfg(not(feature = "abi"))]
-        let abi_generated = proc_macro2::TokenStream::new();
-        #[cfg(feature = "abi")]
+        #[cfg(not(feature = "__abi-generate"))]
+        let abi_generated = quote! {};
+        #[cfg(feature = "__abi-generate")]
         let abi_generated = abi::generate(&item_impl_info);
 
+        for method in &item_impl_info.methods {
+            if method.attr_signature_info.ident == "__contract_abi" {
+                return TokenStream::from(
+                    syn::Error::new_spanned(
+                        method.attr_signature_info.original_sig.ident.to_token_stream(),
+                        "use of reserved contract method",
+                    )
+                    .to_compile_error(),
+                );
+            }
+        }
+
         let generated_code = item_impl_info.wrapper_code();
 
         // Add wrapper methods for ext call API

near-sdk/Cargo.toml

@@ -54,8 +54,11 @@ hex = { version = "0.4.3", features = ["serde"] }
 default = ["wee_alloc", "unit-testing"]
 expensive-debug = []
 unstable = []
-abi = ["near-abi", "schemars", "near-sdk-macros/abi"]
+abi = ["near-abi", "schemars"]
 unit-testing = ["near-vm-logic", "near-primitives-core", "near-primitives", "near-crypto"]
 
+__abi-embed = ["near-sdk-macros/__abi-embed"]
+__abi-generate = ["abi", "near-sdk-macros/__abi-generate"]
+
 [package.metadata.docs.rs]
 features = ["unstable"]