diff --git a/crates/ink/codegen/src/generator/metadata.rs b/crates/ink/codegen/src/generator/metadata.rs
index 63f477bb232..da21b6fe541 100644
--- a/crates/ink/codegen/src/generator/metadata.rs
+++ b/crates/ink/codegen/src/generator/metadata.rs
@@ -164,7 +164,7 @@ impl Metadata<'_> {
     /// Generates the ink! metadata for the given type.
     fn generate_type_spec(ty: &syn::Type) -> TokenStream2 {
         fn without_display_name(ty: &syn::Type) -> TokenStream2 {
-            quote! { ::ink::metadata::TypeSpec::new::<#ty>() }
+            quote! { ::ink::metadata::TypeSpec::of_type::<#ty>() }
         }
         if let syn::Type::Path(type_path) = ty {
             if type_path.qself.is_some() {
diff --git a/crates/metadata/src/layout/mod.rs b/crates/metadata/src/layout/mod.rs
index b21efaac099..e39ae101177 100644
--- a/crates/metadata/src/layout/mod.rs
+++ b/crates/metadata/src/layout/mod.rs
@@ -106,6 +106,14 @@ impl<'a> From<&'a Key> for LayoutKey {
 }
 
 impl LayoutKey {
+    /// Construct a custom layout key.
+    pub fn new<T>(key: T) -> Self
+    where
+        T: Into<u32>,
+    {
+        Self { key: key.into() }
+    }
+
     /// Returns the key of the layout key.
     pub fn key(&self) -> &Key {
         &self.key
@@ -125,19 +133,6 @@ pub struct RootLayout<F: Form = MetaForm> {
     layout: Box<Layout<F>>,
 }
 
-impl RootLayout {
-    /// Creates a new root layout.
-    pub fn new<L>(root_key: LayoutKey, layout: L) -> Self
-    where
-        L: Into<Layout>,
-    {
-        Self {
-            root_key,
-            layout: Box::new(layout.into()),
-        }
-    }
-}
-
 impl IntoPortable for RootLayout {
     type Output = RootLayout<PortableForm>;
 
@@ -153,6 +148,17 @@ impl<F> RootLayout<F>
 where
     F: Form,
 {
+    /// Creates a new root layout.
+    pub fn new<L>(root_key: LayoutKey, layout: L) -> Self
+    where
+        L: Into<Layout<F>>,
+    {
+        Self {
+            root_key,
+            layout: Box::new(layout.into()),
+        }
+    }
+
     /// Returns the root key of the sub-tree.
     pub fn root_key(&self) -> &LayoutKey {
         &self.root_key
@@ -179,7 +185,7 @@ pub struct LeafLayout<F: Form = MetaForm> {
 
 impl LeafLayout {
     /// Creates a new cell layout.
-    pub fn new<T>(key: LayoutKey) -> Self
+    pub fn from_key<T>(key: LayoutKey) -> Self
     where
         T: TypeInfo + 'static,
     {
@@ -241,6 +247,10 @@ where
     pub fn ty(&self) -> &F::Type {
         &self.ty
     }
+
+    pub fn new(key: LayoutKey, ty: <F as Form>::Type) -> Self {
+        Self { key, ty }
+    }
 }
 
 /// A hashing layout potentially hitting all cells of the storage.
@@ -448,24 +458,22 @@ pub struct StructLayout<F: Form = MetaForm> {
     fields: Vec<FieldLayout<F>>,
 }
 
-impl StructLayout {
+impl<F> StructLayout<F>
+where
+    F: Form,
+{
     /// Creates a new struct layout.
-    pub fn new<N, F>(name: N, fields: F) -> Self
+    pub fn new<N, T>(name: N, fields: T) -> Self
     where
-        N: Into<&'static str>,
-        F: IntoIterator<Item = FieldLayout>,
+        N: Into<F::String>,
+        T: IntoIterator<Item = FieldLayout<F>>,
     {
         Self {
             name: name.into(),
             fields: fields.into_iter().collect(),
         }
     }
-}
 
-impl<F> StructLayout<F>
-where
-    F: Form,
-{
     /// Returns the name of the struct.
     pub fn name(&self) -> &F::String {
         &self.name
@@ -481,7 +489,7 @@ impl IntoPortable for StructLayout {
 
     fn into_portable(self, registry: &mut Registry) -> Self::Output {
         StructLayout {
-            name: self.name.into(),
+            name: self.name.to_string(),
             fields: self
                 .fields
                 .into_iter()
@@ -507,24 +515,22 @@ pub struct FieldLayout<F: Form = MetaForm> {
     layout: Layout<F>,
 }
 
-impl FieldLayout {
-    /// Creates a new field layout.
+impl<F> FieldLayout<F>
+where
+    F: Form,
+{
+    /// Creates a new custom field layout.
     pub fn new<N, L>(name: N, layout: L) -> Self
     where
-        N: Into<&'static str>,
-        L: Into<Layout>,
+        N: Into<F::String>,
+        L: Into<Layout<F>>,
     {
         Self {
             name: name.into(),
             layout: layout.into(),
         }
     }
-}
 
-impl<F> FieldLayout<F>
-where
-    F: Form,
-{
     /// Returns the name of the field.
     pub fn name(&self) -> &F::String {
         &self.name
@@ -544,7 +550,7 @@ impl IntoPortable for FieldLayout {
 
     fn into_portable(self, registry: &mut Registry) -> Self::Output {
         FieldLayout {
-            name: self.name.into_portable(registry),
+            name: self.name.to_string(),
             layout: self.layout.into_portable(registry),
         }
     }
@@ -587,7 +593,7 @@ impl EnumLayout {
     /// Creates a new enum layout.
     pub fn new<N, K, V>(name: N, dispatch_key: K, variants: V) -> Self
     where
-        N: Into<&'static str>,
+        N: Into<<MetaForm as Form>::String>,
         K: Into<LayoutKey>,
         V: IntoIterator<Item = (Discriminant, StructLayout)>,
     {
@@ -624,7 +630,7 @@ impl IntoPortable for EnumLayout {
 
     fn into_portable(self, registry: &mut Registry) -> Self::Output {
         EnumLayout {
-            name: self.name.into(),
+            name: self.name.to_string(),
             dispatch_key: self.dispatch_key,
             variants: self
                 .variants
diff --git a/crates/metadata/src/layout/tests.rs b/crates/metadata/src/layout/tests.rs
index 464dd446a73..a62d7376267 100644
--- a/crates/metadata/src/layout/tests.rs
+++ b/crates/metadata/src/layout/tests.rs
@@ -26,8 +26,8 @@ fn named_fields_struct_layout(key: &Key) -> Layout {
     StructLayout::new(
         "Struct",
         vec![
-            FieldLayout::new("a", LeafLayout::new::<i32>(LayoutKey::from(key))),
-            FieldLayout::new("b", LeafLayout::new::<i64>(LayoutKey::from(key))),
+            FieldLayout::new("a", LeafLayout::from_key::<i32>(LayoutKey::from(key))),
+            FieldLayout::new("b", LeafLayout::from_key::<i64>(LayoutKey::from(key))),
         ],
     )
     .into()
@@ -73,8 +73,8 @@ fn tuple_struct_layout(key: &Key) -> Layout {
     StructLayout::new(
         "(A, B)",
         vec![
-            FieldLayout::new("0", LeafLayout::new::<i32>(LayoutKey::from(key))),
-            FieldLayout::new("1", LeafLayout::new::<i64>(LayoutKey::from(key))),
+            FieldLayout::new("0", LeafLayout::from_key::<i32>(LayoutKey::from(key))),
+            FieldLayout::new("1", LeafLayout::from_key::<i64>(LayoutKey::from(key))),
         ],
     )
     .into()
@@ -175,11 +175,11 @@ fn mixed_enum_layout(key: &Key) -> Layout {
                         vec![
                             FieldLayout::new(
                                 "0",
-                                LeafLayout::new::<i32>(LayoutKey::from(variant_key)),
+                                LeafLayout::from_key::<i32>(LayoutKey::from(variant_key)),
                             ),
                             FieldLayout::new(
                                 "1",
-                                LeafLayout::new::<i64>(LayoutKey::from(variant_key)),
+                                LeafLayout::from_key::<i64>(LayoutKey::from(variant_key)),
                             ),
                         ],
                     ),
@@ -194,11 +194,11 @@ fn mixed_enum_layout(key: &Key) -> Layout {
                         vec![
                             FieldLayout::new(
                                 "a",
-                                LeafLayout::new::<i32>(LayoutKey::from(variant_key)),
+                                LeafLayout::from_key::<i32>(LayoutKey::from(variant_key)),
                             ),
                             FieldLayout::new(
                                 "b",
-                                LeafLayout::new::<i64>(LayoutKey::from(variant_key)),
+                                LeafLayout::from_key::<i64>(LayoutKey::from(variant_key)),
                             ),
                         ],
                     ),
@@ -287,7 +287,7 @@ fn unbounded_hashing_layout(key: &Key) -> Layout {
             b"ink storage hashmap".to_vec(),
             Vec::new(),
         ),
-        LeafLayout::new::<(i32, bool)>(LayoutKey::from(root_key)),
+        LeafLayout::from_key::<(i32, bool)>(LayoutKey::from(root_key)),
     )
     .into()
 }
diff --git a/crates/metadata/src/layout/validate.rs b/crates/metadata/src/layout/validate.rs
index 87d70084810..a3984506aa1 100644
--- a/crates/metadata/src/layout/validate.rs
+++ b/crates/metadata/src/layout/validate.rs
@@ -112,7 +112,7 @@ mod tests {
             0.into(),
             RootLayout::new(
                 1.into(),
-                RootLayout::new(2.into(), LeafLayout::new::<u32>(2.into())),
+                RootLayout::new(2.into(), LeafLayout::from_key::<u32>(2.into())),
             ),
         );
 
@@ -159,7 +159,7 @@ mod tests {
                         StructLayout::new(
                             "Struct0",
                             vec![
-                                FieldLayout::new("d", LeafLayout::new::<u128>(root_0)),
+                                FieldLayout::new("d", LeafLayout::from_key::<u128>(root_0)),
                                 FieldLayout::new(
                                     "f",
                                     RootLayout::new(
@@ -180,7 +180,7 @@ mod tests {
                                                                     "g",
                                                                     RootLayout::new(
                                                                         root_4,
-                                                                        LeafLayout::new::<
+                                                                        LeafLayout::from_key::<
                                                                             BTreeSet<u64>,
                                                                         >(
                                                                             root_4
@@ -197,7 +197,7 @@ mod tests {
                                                         "Second",
                                                         vec![FieldLayout::new(
                                                             "0",
-                                                            LeafLayout::new::<u8>(root_2),
+                                                            LeafLayout::from_key::<u8>(root_2),
                                                         )],
                                                     ),
                                                 ),
@@ -209,7 +209,7 @@ mod tests {
                                                             "0",
                                                             RootLayout::new(
                                                                 root_3,
-                                                                LeafLayout::new::<String>(
+                                                                LeafLayout::from_key::<String>(
                                                                     root_3,
                                                                 ),
                                                             ),
@@ -223,10 +223,10 @@ mod tests {
                             ],
                         ),
                     ),
-                    FieldLayout::new("b", LeafLayout::new::<u32>(root_0)),
+                    FieldLayout::new("b", LeafLayout::from_key::<u32>(root_0)),
                     FieldLayout::new(
                         "c",
-                        RootLayout::new(root_1, LeafLayout::new::<Vec<u8>>(root_1)),
+                        RootLayout::new(root_1, LeafLayout::from_key::<Vec<u8>>(root_1)),
                     ),
                 ],
             ),
diff --git a/crates/metadata/src/lib.rs b/crates/metadata/src/lib.rs
index 74bae41240b..200df171b10 100644
--- a/crates/metadata/src/lib.rs
+++ b/crates/metadata/src/lib.rs
@@ -96,6 +96,7 @@ pub struct InkProject {
 }
 
 impl InkProject {
+    /// Create a new ink! project from a layout and a spec.
     pub fn new<L, S>(layout: L, spec: S) -> Self
     where
         L: Into<layout::Layout>,
@@ -110,9 +111,23 @@ impl InkProject {
             registry: registry.into(),
         }
     }
-}
 
-impl InkProject {
+    /// Create a new portable ink! project.
+    ///
+    /// The caller is responsible to register all types into the supplied registry.
+    pub fn new_portable(
+        layout: layout::Layout<PortableForm>,
+        spec: ContractSpec<PortableForm>,
+        registry: PortableRegistry,
+    ) -> Self {
+        Self {
+            version: Default::default(),
+            layout,
+            spec,
+            registry,
+        }
+    }
+
     /// Returns the metadata version used by the contract.
     pub fn version(&self) -> &MetadataVersion {
         &self.version
diff --git a/crates/metadata/src/specs.rs b/crates/metadata/src/specs.rs
index ad599de8c47..178db13d7f0 100644
--- a/crates/metadata/src/specs.rs
+++ b/crates/metadata/src/specs.rs
@@ -79,7 +79,7 @@ impl IntoPortable for ContractSpec {
                 .into_iter()
                 .map(|event| event.into_portable(registry))
                 .collect::<Vec<_>>(),
-            docs: registry.map_into_portable(self.docs),
+            docs: self.docs.into_iter().map(|s| s.into()).collect(),
         }
     }
 }
@@ -114,20 +114,25 @@ pub enum Valid {}
 /// The message builder is not ready to finalize construction.
 pub enum Invalid {}
 
-/// A builder for contracts.
 #[must_use]
-pub struct ContractSpecBuilder<S = Invalid> {
+pub struct ContractSpecBuilder<F, S = Invalid>
+where
+    F: Form,
+{
     /// The to-be-constructed contract specification.
-    spec: ContractSpec,
+    spec: ContractSpec<F>,
     /// Marker for compile-time checking of valid contract specifications.
     marker: PhantomData<fn() -> S>,
 }
 
-impl ContractSpecBuilder<Invalid> {
+impl<F> ContractSpecBuilder<F, Invalid>
+where
+    F: Form,
+{
     /// Sets the constructors of the contract specification.
-    pub fn constructors<C>(self, constructors: C) -> ContractSpecBuilder<Valid>
+    pub fn constructors<C>(self, constructors: C) -> ContractSpecBuilder<F, Valid>
     where
-        C: IntoIterator<Item = ConstructorSpec>,
+        C: IntoIterator<Item = ConstructorSpec<F>>,
     {
         debug_assert!(self.spec.constructors.is_empty());
         ContractSpecBuilder {
@@ -140,11 +145,14 @@ impl ContractSpecBuilder<Invalid> {
     }
 }
 
-impl<S> ContractSpecBuilder<S> {
+impl<F, S> ContractSpecBuilder<F, S>
+where
+    F: Form,
+{
     /// Sets the messages of the contract specification.
     pub fn messages<M>(self, messages: M) -> Self
     where
-        M: IntoIterator<Item = MessageSpec>,
+        M: IntoIterator<Item = MessageSpec<F>>,
     {
         debug_assert!(self.spec.messages.is_empty());
         Self {
@@ -159,7 +167,7 @@ impl<S> ContractSpecBuilder<S> {
     /// Sets the events of the contract specification.
     pub fn events<E>(self, events: E) -> Self
     where
-        E: IntoIterator<Item = EventSpec>,
+        E: IntoIterator<Item = EventSpec<F>>,
     {
         debug_assert!(self.spec.events.is_empty());
         Self {
@@ -174,7 +182,7 @@ impl<S> ContractSpecBuilder<S> {
     /// Sets the documentation of the contract specification.
     pub fn docs<D>(self, docs: D) -> Self
     where
-        D: IntoIterator<Item = &'static str>,
+        D: IntoIterator<Item = <F as Form>::String>,
     {
         debug_assert!(self.spec.docs.is_empty());
         Self {
@@ -187,9 +195,12 @@ impl<S> ContractSpecBuilder<S> {
     }
 }
 
-impl ContractSpecBuilder<Valid> {
+impl<F> ContractSpecBuilder<F, Valid>
+where
+    F: Form,
+{
     /// Finalizes construction of the contract specification.
-    pub fn done(self) -> ContractSpec {
+    pub fn done(self) -> ContractSpec<F> {
         assert!(
             !self.spec.constructors.is_empty(),
             "must have at least one constructor"
@@ -202,9 +213,12 @@ impl ContractSpecBuilder<Valid> {
     }
 }
 
-impl ContractSpec {
+impl<F> ContractSpec<F>
+where
+    F: Form,
+{
     /// Creates a new contract specification.
-    pub fn new() -> ContractSpecBuilder {
+    pub fn new() -> ContractSpecBuilder<F, Invalid> {
         ContractSpecBuilder {
             spec: Self {
                 constructors: Vec::new(),
@@ -243,7 +257,7 @@ impl IntoPortable for ConstructorSpec {
 
     fn into_portable(self, registry: &mut Registry) -> Self::Output {
         ConstructorSpec {
-            label: self.label.into_portable(registry),
+            label: self.label.to_string(),
             selector: self.selector,
             payable: self.payable,
             args: self
@@ -251,7 +265,7 @@ impl IntoPortable for ConstructorSpec {
                 .into_iter()
                 .map(|arg| arg.into_portable(registry))
                 .collect::<Vec<_>>(),
-            docs: registry.map_into_portable(self.docs),
+            docs: self.docs.into_iter().map(|s| s.into()).collect(),
         }
     }
 }
@@ -296,16 +310,20 @@ where
 /// compile-time instead of at run-time. This is useful to better
 /// debug code-gen macros.
 #[must_use]
-pub struct ConstructorSpecBuilder<Selector, IsPayable> {
-    spec: ConstructorSpec,
+pub struct ConstructorSpecBuilder<F: Form, Selector, IsPayable> {
+    spec: ConstructorSpec<F>,
     marker: PhantomData<fn() -> (Selector, IsPayable)>,
 }
 
-impl ConstructorSpec {
+impl<F> ConstructorSpec<F>
+where
+    F: Form,
+{
     /// Creates a new constructor spec builder.
     pub fn from_label(
-        label: &'static str,
-    ) -> ConstructorSpecBuilder<Missing<state::Selector>, Missing<state::IsPayable>> {
+        label: <F as Form>::String,
+    ) -> ConstructorSpecBuilder<F, Missing<state::Selector>, Missing<state::IsPayable>>
+    {
         ConstructorSpecBuilder {
             spec: Self {
                 label,
@@ -319,12 +337,15 @@ impl ConstructorSpec {
     }
 }
 
-impl<P> ConstructorSpecBuilder<Missing<state::Selector>, P> {
+impl<F, P> ConstructorSpecBuilder<F, Missing<state::Selector>, P>
+where
+    F: Form,
+{
     /// Sets the function selector of the message.
     pub fn selector(
         self,
         selector: [u8; 4],
-    ) -> ConstructorSpecBuilder<state::Selector, P> {
+    ) -> ConstructorSpecBuilder<F, state::Selector, P> {
         ConstructorSpecBuilder {
             spec: ConstructorSpec {
                 selector: selector.into(),
@@ -335,12 +356,15 @@ impl<P> ConstructorSpecBuilder<Missing<state::Selector>, P> {
     }
 }
 
-impl<S> ConstructorSpecBuilder<S, Missing<state::IsPayable>> {
+impl<F, S> ConstructorSpecBuilder<F, S, Missing<state::IsPayable>>
+where
+    F: Form,
+{
     /// Sets if the constructor is payable, thus accepting value for the caller.
     pub fn payable(
         self,
         is_payable: bool,
-    ) -> ConstructorSpecBuilder<S, state::IsPayable> {
+    ) -> ConstructorSpecBuilder<F, S, state::IsPayable> {
         ConstructorSpecBuilder {
             spec: ConstructorSpec {
                 payable: is_payable,
@@ -351,11 +375,14 @@ impl<S> ConstructorSpecBuilder<S, Missing<state::IsPayable>> {
     }
 }
 
-impl<S, P> ConstructorSpecBuilder<S, P> {
+impl<F, S, P> ConstructorSpecBuilder<F, S, P>
+where
+    F: Form,
+{
     /// Sets the input arguments of the message specification.
     pub fn args<A>(self, args: A) -> Self
     where
-        A: IntoIterator<Item = MessageParamSpec>,
+        A: IntoIterator<Item = MessageParamSpec<F>>,
     {
         let mut this = self;
         debug_assert!(this.spec.args.is_empty());
@@ -364,23 +391,27 @@ impl<S, P> ConstructorSpecBuilder<S, P> {
     }
 
     /// Sets the documentation of the message specification.
-    pub fn docs<D>(self, docs: D) -> Self
+    pub fn docs<'a, D>(self, docs: D) -> Self
     where
-        D: IntoIterator<Item = &'static str>,
+        D: IntoIterator<Item = &'a str>,
+        F::String: From<&'a str>,
     {
         let mut this = self;
         debug_assert!(this.spec.docs.is_empty());
         this.spec.docs = docs
             .into_iter()
-            .map(trim_extra_whitespace)
+            .map(|s| trim_extra_whitespace(s).into())
             .collect::<Vec<_>>();
         this
     }
 }
 
-impl ConstructorSpecBuilder<state::Selector, state::IsPayable> {
+impl<F> ConstructorSpecBuilder<F, state::Selector, state::IsPayable>
+where
+    F: Form,
+{
     /// Finishes construction of the constructor.
-    pub fn done(self) -> ConstructorSpec {
+    pub fn done(self) -> ConstructorSpec<F> {
         self.spec
     }
 }
@@ -430,11 +461,15 @@ mod state {
     pub struct Returns;
 }
 
-impl MessageSpec {
+impl<F> MessageSpec<F>
+where
+    F: Form,
+{
     /// Creates a new message spec builder.
     pub fn from_label(
-        label: &'static str,
+        label: <F as Form>::String,
     ) -> MessageSpecBuilder<
+        F,
         Missing<state::Selector>,
         Missing<state::Mutates>,
         Missing<state::IsPayable>,
@@ -507,17 +542,23 @@ where
 /// debug code-gen macros.
 #[allow(clippy::type_complexity)]
 #[must_use]
-pub struct MessageSpecBuilder<Selector, Mutates, IsPayable, Returns> {
-    spec: MessageSpec,
+pub struct MessageSpecBuilder<F, Selector, Mutates, IsPayable, Returns>
+where
+    F: Form,
+{
+    spec: MessageSpec<F>,
     marker: PhantomData<fn() -> (Selector, Mutates, IsPayable, Returns)>,
 }
 
-impl<M, P, R> MessageSpecBuilder<Missing<state::Selector>, M, P, R> {
+impl<F, M, P, R> MessageSpecBuilder<F, Missing<state::Selector>, M, P, R>
+where
+    F: Form,
+{
     /// Sets the function selector of the message.
     pub fn selector(
         self,
         selector: [u8; 4],
-    ) -> MessageSpecBuilder<state::Selector, M, P, R> {
+    ) -> MessageSpecBuilder<F, state::Selector, M, P, R> {
         MessageSpecBuilder {
             spec: MessageSpec {
                 selector: selector.into(),
@@ -528,9 +569,15 @@ impl<M, P, R> MessageSpecBuilder<Missing<state::Selector>, M, P, R> {
     }
 }
 
-impl<S, P, R> MessageSpecBuilder<S, Missing<state::Mutates>, P, R> {
+impl<F, S, P, R> MessageSpecBuilder<F, S, Missing<state::Mutates>, P, R>
+where
+    F: Form,
+{
     /// Sets if the message is mutable, thus taking `&mut self` or not thus taking `&self`.
-    pub fn mutates(self, mutates: bool) -> MessageSpecBuilder<S, state::Mutates, P, R> {
+    pub fn mutates(
+        self,
+        mutates: bool,
+    ) -> MessageSpecBuilder<F, S, state::Mutates, P, R> {
         MessageSpecBuilder {
             spec: MessageSpec {
                 mutates,
@@ -541,12 +588,15 @@ impl<S, P, R> MessageSpecBuilder<S, Missing<state::Mutates>, P, R> {
     }
 }
 
-impl<S, M, R> MessageSpecBuilder<S, M, Missing<state::IsPayable>, R> {
+impl<F, S, M, R> MessageSpecBuilder<F, S, M, Missing<state::IsPayable>, R>
+where
+    F: Form,
+{
     /// Sets if the message is payable, thus accepting value for the caller.
     pub fn payable(
         self,
         is_payable: bool,
-    ) -> MessageSpecBuilder<S, M, state::IsPayable, R> {
+    ) -> MessageSpecBuilder<F, S, M, state::IsPayable, R> {
         MessageSpecBuilder {
             spec: MessageSpec {
                 payable: is_payable,
@@ -557,12 +607,15 @@ impl<S, M, R> MessageSpecBuilder<S, M, Missing<state::IsPayable>, R> {
     }
 }
 
-impl<M, S, P> MessageSpecBuilder<S, M, P, Missing<state::Returns>> {
+impl<F, M, S, P> MessageSpecBuilder<F, S, M, P, Missing<state::Returns>>
+where
+    F: Form,
+{
     /// Sets the return type of the message.
     pub fn returns(
         self,
-        return_type: ReturnTypeSpec,
-    ) -> MessageSpecBuilder<S, M, P, state::Returns> {
+        return_type: ReturnTypeSpec<F>,
+    ) -> MessageSpecBuilder<F, S, M, P, state::Returns> {
         MessageSpecBuilder {
             spec: MessageSpec {
                 return_type,
@@ -573,11 +626,14 @@ impl<M, S, P> MessageSpecBuilder<S, M, P, Missing<state::Returns>> {
     }
 }
 
-impl<S, M, P, R> MessageSpecBuilder<S, M, P, R> {
+impl<F, S, M, P, R> MessageSpecBuilder<F, S, M, P, R>
+where
+    F: Form,
+{
     /// Sets the input arguments of the message specification.
     pub fn args<A>(self, args: A) -> Self
     where
-        A: IntoIterator<Item = MessageParamSpec>,
+        A: IntoIterator<Item = MessageParamSpec<F>>,
     {
         let mut this = self;
         debug_assert!(this.spec.args.is_empty());
@@ -588,23 +644,28 @@ impl<S, M, P, R> MessageSpecBuilder<S, M, P, R> {
     /// Sets the documentation of the message specification.
     pub fn docs<D>(self, docs: D) -> Self
     where
-        D: IntoIterator<Item = &'static str>,
+        D: IntoIterator<Item = <F as Form>::String>,
     {
         let mut this = self;
         debug_assert!(this.spec.docs.is_empty());
-        this.spec.docs = docs
-            .into_iter()
-            .map(trim_extra_whitespace)
-            .collect::<Vec<_>>();
+        this.spec.docs = docs.into_iter().collect::<Vec<_>>();
         this
     }
 }
 
-impl
-    MessageSpecBuilder<state::Selector, state::Mutates, state::IsPayable, state::Returns>
+impl<F>
+    MessageSpecBuilder<
+        F,
+        state::Selector,
+        state::Mutates,
+        state::IsPayable,
+        state::Returns,
+    >
+where
+    F: Form,
 {
     /// Finishes construction of the message.
-    pub fn done(self) -> MessageSpec {
+    pub fn done(self) -> MessageSpec<F> {
         self.spec
     }
 }
@@ -614,7 +675,7 @@ impl IntoPortable for MessageSpec {
 
     fn into_portable(self, registry: &mut Registry) -> Self::Output {
         MessageSpec {
-            label: self.label.into_portable(registry),
+            label: self.label.to_string(),
             selector: self.selector,
             mutates: self.mutates,
             payable: self.payable,
@@ -624,7 +685,7 @@ impl IntoPortable for MessageSpec {
                 .map(|arg| arg.into_portable(registry))
                 .collect::<Vec<_>>(),
             return_type: self.return_type.into_portable(registry),
-            docs: registry.map_into_portable(self.docs),
+            docs: self.docs.into_iter().map(|s| s.into()).collect(),
         }
     }
 }
@@ -646,15 +707,21 @@ pub struct EventSpec<F: Form = MetaForm> {
 
 /// An event specification builder.
 #[must_use]
-pub struct EventSpecBuilder {
-    spec: EventSpec,
+pub struct EventSpecBuilder<F>
+where
+    F: Form,
+{
+    spec: EventSpec<F>,
 }
 
-impl EventSpecBuilder {
+impl<F> EventSpecBuilder<F>
+where
+    F: Form,
+{
     /// Sets the input arguments of the event specification.
     pub fn args<A>(self, args: A) -> Self
     where
-        A: IntoIterator<Item = EventParamSpec>,
+        A: IntoIterator<Item = EventParamSpec<F>>,
     {
         let mut this = self;
         debug_assert!(this.spec.args.is_empty());
@@ -665,7 +732,7 @@ impl EventSpecBuilder {
     /// Sets the input arguments of the event specification.
     pub fn docs<D>(self, docs: D) -> Self
     where
-        D: IntoIterator<Item = &'static str>,
+        D: IntoIterator<Item = <F as Form>::String>,
     {
         let mut this = self;
         debug_assert!(this.spec.docs.is_empty());
@@ -674,7 +741,7 @@ impl EventSpecBuilder {
     }
 
     /// Finalizes building the event specification.
-    pub fn done(self) -> EventSpec {
+    pub fn done(self) -> EventSpec<F> {
         self.spec
     }
 }
@@ -684,20 +751,23 @@ impl IntoPortable for EventSpec {
 
     fn into_portable(self, registry: &mut Registry) -> Self::Output {
         EventSpec {
-            label: self.label.into_portable(registry),
+            label: self.label.to_string(),
             args: self
                 .args
                 .into_iter()
                 .map(|arg| arg.into_portable(registry))
                 .collect::<Vec<_>>(),
-            docs: registry.map_into_portable(self.docs),
+            docs: self.docs.into_iter().map(|s| s.into()).collect(),
         }
     }
 }
 
-impl EventSpec {
+impl<F> EventSpec<F>
+where
+    F: Form,
+{
     /// Creates a new event specification builder.
-    pub fn new(label: &'static str) -> EventSpecBuilder {
+    pub fn new(label: <F as Form>::String) -> EventSpecBuilder<F> {
         EventSpecBuilder {
             spec: Self {
                 label,
@@ -753,6 +823,14 @@ impl<'de> serde::Deserialize<'de> for Selector {
 }
 
 impl Selector {
+    /// Create a new custom selector.
+    pub fn new<T>(bytes: T) -> Self
+    where
+        T: Into<[u8; 4]>,
+    {
+        Self(bytes.into())
+    }
+
     /// Returns the underlying selector bytes.
     pub fn to_bytes(&self) -> &[u8] {
         &self.0
@@ -809,6 +887,21 @@ pub struct TypeSpec<F: Form = MetaForm> {
     display_name: DisplayName<F>,
 }
 
+impl Default for TypeSpec<MetaForm> {
+    fn default() -> Self {
+        TypeSpec::of_type::<()>()
+    }
+}
+
+impl Default for TypeSpec<PortableForm> {
+    fn default() -> Self {
+        Self {
+            ty: u32::default().into(),
+            display_name: Default::default(),
+        }
+    }
+}
+
 impl IntoPortable for TypeSpec {
     type Output = TypeSpec<PortableForm>;
 
@@ -864,7 +957,13 @@ impl TypeSpec {
     }
 
     /// Creates a new type specification without a display name.
-    pub fn new<T>() -> Self
+    ///
+    /// Example:
+    /// ```no_run
+    /// # use ink_metadata::{TypeSpec, ReturnTypeSpec};
+    /// ReturnTypeSpec::new(TypeSpec::of_type::<i32>()); // return type of `i32`
+    /// ```
+    pub fn of_type<T>() -> Self
     where
         T: TypeInfo + 'static,
     {
@@ -888,6 +987,11 @@ where
     pub fn display_name(&self) -> &DisplayName<F> {
         &self.display_name
     }
+
+    /// Creates a new type specification for a given type and display name.
+    pub fn new(ty: <F as Form>::Type, display_name: DisplayName<F>) -> Self {
+        Self { ty, display_name }
+    }
 }
 
 /// Describes a pair of parameter label and type.
@@ -913,35 +1017,33 @@ impl IntoPortable for EventParamSpec {
 
     fn into_portable(self, registry: &mut Registry) -> Self::Output {
         EventParamSpec {
-            label: self.label.into_portable(registry),
+            label: self.label.to_string(),
             indexed: self.indexed,
             ty: self.ty.into_portable(registry),
-            docs: registry.map_into_portable(self.docs),
+            docs: self.docs.into_iter().map(|s| s.into()).collect(),
         }
     }
 }
 
-impl EventParamSpec {
+impl<F> EventParamSpec<F>
+where
+    F: Form,
+    TypeSpec<F>: Default,
+{
     /// Creates a new event parameter specification builder.
-    pub fn new(label: &'static str) -> EventParamSpecBuilder {
+    pub fn new(label: F::String) -> EventParamSpecBuilder<F> {
         EventParamSpecBuilder {
             spec: Self {
                 label,
                 // By default event parameters are not indexed.
                 indexed: false,
                 // We initialize every parameter type as `()`.
-                ty: TypeSpec::new::<()>(),
+                ty: Default::default(),
                 // We start with empty docs.
                 docs: vec![],
             },
         }
     }
-}
-
-impl<F> EventParamSpec<F>
-where
-    F: Form,
-{
     /// Returns the label of the parameter.
     pub fn label(&self) -> &F::String {
         &self.label
@@ -965,14 +1067,20 @@ where
 
 /// Used to construct an event parameter specification.
 #[must_use]
-pub struct EventParamSpecBuilder {
+pub struct EventParamSpecBuilder<F>
+where
+    F: Form,
+{
     /// The built-up event parameter specification.
-    spec: EventParamSpec,
+    spec: EventParamSpec<F>,
 }
 
-impl EventParamSpecBuilder {
+impl<F> EventParamSpecBuilder<F>
+where
+    F: Form,
+{
     /// Sets the type of the event parameter.
-    pub fn of_type(self, spec: TypeSpec) -> Self {
+    pub fn of_type(self, spec: TypeSpec<F>) -> Self {
         let mut this = self;
         this.spec.ty = spec;
         this
@@ -988,7 +1096,7 @@ impl EventParamSpecBuilder {
     /// Sets the documentation of the event parameter.
     pub fn docs<D>(self, docs: D) -> Self
     where
-        D: IntoIterator<Item = &'static str>,
+        D: IntoIterator<Item = <F as Form>::String>,
     {
         debug_assert!(self.spec.docs.is_empty());
         Self {
@@ -1000,7 +1108,7 @@ impl EventParamSpecBuilder {
     }
 
     /// Finishes constructing the event parameter spec.
-    pub fn done(self) -> EventParamSpec {
+    pub fn done(self) -> EventParamSpec<F> {
         self.spec
     }
 }
@@ -1012,6 +1120,7 @@ impl EventParamSpecBuilder {
     serialize = "F::Type: Serialize, F::String: Serialize",
     deserialize = "F::Type: DeserializeOwned, F::String: DeserializeOwned"
 ))]
+#[must_use]
 pub struct ReturnTypeSpec<F: Form = MetaForm> {
     #[serde(rename = "type")]
     opt_type: Option<TypeSpec<F>>,
@@ -1029,31 +1138,27 @@ impl IntoPortable for ReturnTypeSpec {
     }
 }
 
-impl ReturnTypeSpec {
+impl<F> ReturnTypeSpec<F>
+where
+    F: Form,
+{
     /// Creates a new return type specification from the given type or `None`.
     ///
     /// # Examples
     ///
     /// ```no_run
     /// # use ink_metadata::{TypeSpec, ReturnTypeSpec};
-    /// ReturnTypeSpec::new(None); // no return type;
-    /// ReturnTypeSpec::new(TypeSpec::new::<i32>()); // return type of `i32`
+    /// <ReturnTypeSpec<scale_info::form::MetaForm>>::new(None); // no return type;
     /// ```
-    #[must_use]
     pub fn new<T>(ty: T) -> Self
     where
-        T: Into<Option<TypeSpec>>,
+        T: Into<Option<TypeSpec<F>>>,
     {
         Self {
             opt_type: ty.into(),
         }
     }
-}
 
-impl<F> ReturnTypeSpec<F>
-where
-    F: Form,
-{
     /// Returns the optional return type
     pub fn opt_type(&self) -> Option<&TypeSpec<F>> {
         self.opt_type.as_ref()
@@ -1079,29 +1184,28 @@ impl IntoPortable for MessageParamSpec {
 
     fn into_portable(self, registry: &mut Registry) -> Self::Output {
         MessageParamSpec {
-            label: self.label.into_portable(registry),
+            label: self.label.to_string(),
             ty: self.ty.into_portable(registry),
         }
     }
 }
 
-impl MessageParamSpec {
+impl<F> MessageParamSpec<F>
+where
+    F: Form,
+    TypeSpec<F>: Default,
+{
     /// Constructs a new message parameter specification via builder.
-    pub fn new(label: &'static str) -> MessageParamSpecBuilder {
+    pub fn new(label: F::String) -> MessageParamSpecBuilder<F> {
         MessageParamSpecBuilder {
             spec: Self {
                 label,
                 // Uses `()` type by default.
-                ty: TypeSpec::new::<()>(),
+                ty: TypeSpec::default(),
             },
         }
     }
-}
 
-impl<F> MessageParamSpec<F>
-where
-    F: Form,
-{
     /// Returns the label of the parameter.
     pub fn label(&self) -> &F::String {
         &self.label
@@ -1115,21 +1219,24 @@ where
 
 /// Used to construct a message parameter specification.
 #[must_use]
-pub struct MessageParamSpecBuilder {
+pub struct MessageParamSpecBuilder<F: Form> {
     /// The to-be-constructed message parameter specification.
-    spec: MessageParamSpec,
+    spec: MessageParamSpec<F>,
 }
 
-impl MessageParamSpecBuilder {
+impl<F> MessageParamSpecBuilder<F>
+where
+    F: Form,
+{
     /// Sets the type of the message parameter.
-    pub fn of_type(self, ty: TypeSpec) -> Self {
+    pub fn of_type(self, ty: TypeSpec<F>) -> Self {
         let mut this = self;
         this.spec.ty = ty;
         this
     }
 
     /// Finishes construction of the message parameter.
-    pub fn done(self) -> MessageParamSpec {
+    pub fn done(self) -> MessageParamSpec<F> {
         self.spec
     }
 }
diff --git a/crates/metadata/src/tests.rs b/crates/metadata/src/tests.rs
index 6f782407261..43b2634531b 100644
--- a/crates/metadata/src/tests.rs
+++ b/crates/metadata/src/tests.rs
@@ -63,13 +63,11 @@ fn spec_contract_json() {
                         vec!["i32"].into_iter().map(AsRef::as_ref),
                     ))
                     .done()])
-                .docs(Vec::new())
                 .done(),
             ConstructorSpec::from_label("default")
                 .selector([2u8, 34u8, 255u8, 24u8])
                 .payable(Default::default())
                 .args(Vec::new())
-                .docs(Vec::new())
                 .done(),
         ])
         .messages(vec![
@@ -82,7 +80,6 @@ fn spec_contract_json() {
                         vec!["i32"].into_iter().map(AsRef::as_ref),
                     ))
                     .done()])
-                .docs(Vec::new())
                 .returns(ReturnTypeSpec::new(None))
                 .done(),
             MessageSpec::from_label("get")
@@ -90,14 +87,12 @@ fn spec_contract_json() {
                 .mutates(false)
                 .payable(false)
                 .args(Vec::new())
-                .docs(Vec::new())
                 .returns(ReturnTypeSpec::new(TypeSpec::with_name_segs::<i32, _>(
                     vec!["i32"].into_iter().map(AsRef::as_ref),
                 )))
                 .done(),
         ])
         .events(Vec::new())
-        .docs(Vec::new())
         .done();
 
     let mut registry = Registry::new();
diff --git a/crates/storage/traits/src/layout/impls.rs b/crates/storage/traits/src/layout/impls.rs
index bc2d2f71b4f..0513780ec77 100644
--- a/crates/storage/traits/src/layout/impls.rs
+++ b/crates/storage/traits/src/layout/impls.rs
@@ -48,7 +48,7 @@ macro_rules! impl_storage_layout_for_primitives {
         $(
             impl StorageLayout for $name {
                 fn layout(key: &Key) -> Layout {
-                    Layout::Leaf(LeafLayout::new::<$name>(LayoutKey::from(key)))
+                    Layout::Leaf(LeafLayout::from_key::<$name>(LayoutKey::from(key)))
                 }
             }
         )*
@@ -228,7 +228,7 @@ where
     T: TypeInfo + 'static + Packed,
 {
     fn layout(key: &Key) -> Layout {
-        Layout::Leaf(LeafLayout::new::<Self>(LayoutKey::from(key)))
+        Layout::Leaf(LeafLayout::from_key::<Self>(LayoutKey::from(key)))
     }
 }
 
@@ -238,7 +238,7 @@ where
     V: TypeInfo + 'static + Packed,
 {
     fn layout(key: &Key) -> Layout {
-        Layout::Leaf(LeafLayout::new::<Self>(LayoutKey::from(key)))
+        Layout::Leaf(LeafLayout::from_key::<Self>(LayoutKey::from(key)))
     }
 }
 
@@ -247,7 +247,7 @@ where
     T: TypeInfo + 'static + Packed,
 {
     fn layout(key: &Key) -> Layout {
-        Layout::Leaf(LeafLayout::new::<Self>(LayoutKey::from(key)))
+        Layout::Leaf(LeafLayout::from_key::<Self>(LayoutKey::from(key)))
     }
 }
 
@@ -256,6 +256,6 @@ where
     T: TypeInfo + 'static + Packed,
 {
     fn layout(key: &Key) -> Layout {
-        Layout::Leaf(LeafLayout::new::<Self>(LayoutKey::from(key)))
+        Layout::Leaf(LeafLayout::from_key::<Self>(LayoutKey::from(key)))
     }
 }