Improve deterministic contract creation. Add convenient RGB20 contract builder

src/interface/builder.rs

@@ -25,18 +25,19 @@ use amplify::confinement::{Confined, TinyOrdMap, TinyOrdSet, U16};
 use amplify::{confinement, Wrapper};
 use invoice::{Allocation, Amount};
 use rgb::{
-    AltLayer1, AltLayer1Set, AssetTag, Assign, AssignmentType, Assignments, BlindingFactor,
-    ContractId, DataState, ExposedSeal, FungibleType, Genesis, GenesisSeal, GlobalState, GraphSeal,
-    Input, Opout, RevealedAttach, RevealedData, RevealedValue, StateSchema, SubSchema, Transition,
-    TransitionType, TypedAssigns,
+    validation, AltLayer1, AltLayer1Set, AssetTag, Assign, AssignmentType, Assignments,
+    BlindingFactor, ContractId, DataState, ExposedSeal, FungibleType, Genesis, GenesisSeal,
+    GlobalState, GraphSeal, Input, Opout, RevealedAttach, RevealedData, RevealedValue, StateSchema,
+    SubSchema, Transition, TransitionType, TypedAssigns,
 };
 use strict_encoding::{FieldName, SerializeError, StrictSerialize, TypeName};
 use strict_types::decode;
 
 use crate::containers::{BuilderSeal, Contract};
 use crate::interface::contract::AttachedState;
+use crate::interface::resolver::DumbResolver;
 use crate::interface::{Iface, IfaceImpl, IfacePair, TransitionIface};
-use crate::persistence::PresistedState;
+use crate::persistence::PersistedState;
 
 #[derive(Clone, Eq, PartialEq, Debug, Display, Error, From)]
 #[display(doc_comments)]
@@ -97,6 +98,10 @@ pub enum BuilderError {
     #[from]
     #[display(inner)]
     Confinement(confinement::Error),
+
+    #[from]
+    #[display(inner)]
+    ContractInconsistency(validation::Status),
 }
 
 #[derive(Clone, Debug)]
@@ -151,6 +156,11 @@ impl ContractBuilder {
         Ok(self)
     }
 
+    #[inline]
+    pub fn asset_tag(&self, name: impl Into<FieldName>) -> Result<AssetTag, BuilderError> {
+        self.builder.asset_tag(name)
+    }
+
     #[inline]
     pub fn add_asset_tag(
         mut self,
@@ -171,13 +181,13 @@ impl ContractBuilder {
         Ok(self)
     }
 
-    pub fn add_owned_state_raw(
+    pub fn add_owned_state_det(
         mut self,
-        type_id: AssignmentType,
+        name: impl Into<FieldName>,
         seal: impl Into<BuilderSeal<GenesisSeal>>,
-        state: PresistedState,
+        state: PersistedState,
     ) -> Result<Self, BuilderError> {
-        self.builder = self.builder.add_owned_state_raw(type_id, seal, state)?;
+        self.builder = self.builder.add_owned_state_det(name, seal, state)?;
         Ok(self)
     }
 
@@ -257,20 +267,27 @@ impl ContractBuilder {
             valencies: none!(),
         };
 
-        // TODO: Validate against schema
-
         let mut contract = Contract::new(schema, genesis, asset_tags);
         contract.ifaces = tiny_bmap! { iface_pair.iface_id() => iface_pair };
 
-        Ok(contract)
+        let verified_contract =
+            contract
+                .validate(&mut DumbResolver, self.testnet)
+                .map_err(|consignment| {
+                    consignment
+                        .into_validation_status()
+                        .expect("status always present upon validation")
+                })?;
+
+        Ok(verified_contract)
     }
 }
 
 #[derive(Clone, Debug)]
 pub struct TransitionBuilder {
     builder: OperationBuilder<GraphSeal>,
     transition_type: TransitionType,
-    inputs: TinyOrdMap<Input, PresistedState>,
+    inputs: TinyOrdMap<Input, PersistedState>,
 }
 
 impl TransitionBuilder {
@@ -323,6 +340,11 @@ impl TransitionBuilder {
 
     pub fn transition_type(&self) -> TransitionType { self.transition_type }
 
+    #[inline]
+    pub fn asset_tag(&self, name: impl Into<FieldName>) -> Result<AssetTag, BuilderError> {
+        self.builder.asset_tag(name)
+    }
+
     #[inline]
     pub fn add_asset_tag(
         mut self,
@@ -355,7 +377,7 @@ impl TransitionBuilder {
         Ok(self)
     }
 
-    pub fn add_input(mut self, opout: Opout, state: PresistedState) -> Result<Self, BuilderError> {
+    pub fn add_input(mut self, opout: Opout, state: PersistedState) -> Result<Self, BuilderError> {
         self.inputs.insert(Input::with(opout), state)?;
         Ok(self)
     }
@@ -374,13 +396,23 @@ impl TransitionBuilder {
             .assignments_type(name, Some(self.transition_type))
     }
 
+    pub fn add_owned_state_det(
+        mut self,
+        name: impl Into<FieldName>,
+        seal: impl Into<BuilderSeal<GraphSeal>>,
+        state: PersistedState,
+    ) -> Result<Self, BuilderError> {
+        self.builder = self.builder.add_owned_state_det(name, seal, state)?;
+        Ok(self)
+    }
+
     pub fn add_owned_state_raw(
         mut self,
         type_id: AssignmentType,
         seal: impl Into<BuilderSeal<GraphSeal>>,
-        state: PresistedState,
+        state: PersistedState,
     ) -> Result<Self, BuilderError> {
-        if matches!(state, PresistedState::Amount(_, _, tag) if self.builder.asset_tag(type_id)? != tag)
+        if matches!(state, PersistedState::Amount(_, _, tag) if self.builder.asset_tag_raw(type_id)? != tag)
         {
             return Err(BuilderError::AssetTagInvalid(type_id));
         }
@@ -415,7 +447,7 @@ impl TransitionBuilder {
         value: impl Into<Amount>,
         blinding: BlindingFactor,
     ) -> Result<Self, BuilderError> {
-        let tag = self.builder.asset_tag(type_id)?;
+        let tag = self.builder.asset_tag_raw(type_id)?;
         let state = RevealedValue::with_blinding(value.into(), blinding, tag);
         self.builder = self.builder.add_fungible_state_raw(type_id, seal, state)?;
         Ok(self)
@@ -432,7 +464,7 @@ impl TransitionBuilder {
             .builder
             .assignments_type(&name, None)
             .ok_or(BuilderError::AssignmentNotFound(name.clone()))?;
-        let tag = self.builder.asset_tag(type_id)?;
+        let tag = self.builder.asset_tag_raw(type_id)?;
 
         self.builder =
             self.builder
@@ -581,8 +613,16 @@ impl<Seal: ExposedSeal> OperationBuilder<Seal> {
             .expect("schema should match interface: must be checked by the constructor")
     }
 
+    pub fn asset_tag(&self, name: impl Into<FieldName>) -> Result<AssetTag, BuilderError> {
+        let name = name.into();
+        let type_id = self
+            .assignments_type(&name, None)
+            .ok_or(BuilderError::AssignmentNotFound(name.clone()))?;
+        self.asset_tag_raw(type_id)
+    }
+
     #[inline]
-    pub fn asset_tag(&self, type_id: AssignmentType) -> Result<AssetTag, BuilderError> {
+    fn asset_tag_raw(&self, type_id: AssignmentType) -> Result<AssetTag, BuilderError> {
         self.asset_tags
             .get(&type_id)
             .ok_or(BuilderError::AssetTagMissed(type_id))
@@ -652,23 +692,42 @@ impl<Seal: ExposedSeal> OperationBuilder<Seal> {
         Ok(self)
     }
 
+    fn add_owned_state_det(
+        self,
+        name: impl Into<FieldName>,
+        seal: impl Into<BuilderSeal<Seal>>,
+        state: PersistedState,
+    ) -> Result<Self, BuilderError> {
+        let name = name.into();
+        let type_id = self
+            .assignments_type(&name, None)
+            .ok_or(BuilderError::AssignmentNotFound(name.clone()))?;
+        self.add_owned_state_raw(type_id, seal, state)
+    }
+
     fn add_owned_state_raw(
         self,
         type_id: AssignmentType,
         seal: impl Into<BuilderSeal<Seal>>,
-        state: PresistedState,
+        state: PersistedState,
     ) -> Result<Self, BuilderError> {
         match state {
-            PresistedState::Void => self.add_rights_raw(type_id, seal),
-            PresistedState::Amount(value, blinding, tag) => self.add_fungible_state_raw(
-                type_id,
-                seal,
-                RevealedValue::with_blinding(value, blinding, tag),
-            ),
-            PresistedState::Data(data, salt) => {
+            PersistedState::Void => self.add_rights_raw(type_id, seal),
+            PersistedState::Amount(value, blinding, tag) => {
+                if self.asset_tag_raw(type_id)? != tag {
+                    return Err(BuilderError::AssetTagInvalid(type_id));
+                }
+
+                self.add_fungible_state_raw(
+                    type_id,
+                    seal,
+                    RevealedValue::with_blinding(value, blinding, tag),
+                )
+            }
+            PersistedState::Data(data, salt) => {
                 self.add_data_raw(type_id, seal, RevealedData::with_salt(data, salt))
             }
-            PresistedState::Attachment(attach, salt) => self.add_attachment_raw(
+            PersistedState::Attachment(attach, salt) => self.add_attachment_raw(
                 type_id,
                 seal,
                 RevealedAttach::with_salt(attach.id, attach.media_type, salt),
@@ -844,7 +903,7 @@ impl<Seal: ExposedSeal> OperationBuilder<Seal> {
 
     fn complete(
         self,
-        inputs: Option<&TinyOrdMap<Input, PresistedState>>,
+        inputs: Option<&TinyOrdMap<Input, PersistedState>>,
     ) -> (SubSchema, IfacePair, GlobalState, Assignments<Seal>, TinyOrdMap<AssignmentType, AssetTag>)
     {
         let owned_state = self.fungible.into_iter().map(|(id, vec)| {
@@ -871,7 +930,7 @@ impl<Seal: ExposedSeal> OperationBuilder<Seal> {
                         i.iter()
                             .filter(|(out, _)| out.prev_out.ty == id)
                             .map(|(_, ts)| match ts {
-                                PresistedState::Amount(_, blinding, _) => *blinding,
+                                PersistedState::Amount(_, blinding, _) => *blinding,
                                 _ => panic!("previous state has invalid type"),
                             })
                             .collect::<Vec<_>>()

src/interface/iimpl.rs

@@ -300,3 +300,8 @@ impl IfacePair {
         self.iimpl.transition_type(name)
     }
 }
+
+pub trait ContractClass {
+    fn schema() -> SubSchema;
+    fn main_iface_impl() -> IfaceImpl;
+}

src/interface/mod.rs

@@ -32,6 +32,7 @@ pub mod rgb21;
 pub mod rgb25;
 mod suppl;
 mod filters;
+pub(crate) mod resolver;
 
 pub use builder::{BuilderError, ContractBuilder, TransitionBuilder};
 pub use contract::{
@@ -43,7 +44,7 @@ pub use iface::{
     ArgMap, ArgSpec, AssignIface, ExtensionIface, GenesisIface, GlobalIface, Iface, IfaceId,
     OwnedIface, Req, TransitionIface, ValencyIface,
 };
-pub use iimpl::{IfaceImpl, IfacePair, ImplId, NamedField, NamedType, SchemaIfaces};
+pub use iimpl::{ContractClass, IfaceImpl, IfacePair, ImplId, NamedField, NamedType, SchemaIfaces};
 pub use rgb20::{rgb20, rgb20_stl, AmountChange, Rgb20, LIB_ID_RGB20, LIB_NAME_RGB20};
 pub use rgb21::{rgb21, rgb21_stl, Rgb21, LIB_ID_RGB21, LIB_NAME_RGB21};
 pub use rgb25::{rgb25, rgb25_stl, Rgb25, LIB_ID_RGB25, LIB_NAME_RGB25};

src/interface/resolver.rs

@@ -0,0 +1,43 @@
+// RGB standard library for working with smart contracts on Bitcoin & Lightning
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Written in 2019-2023 by
+//     Dr Maxim Orlovsky <[email protected]>
+//
+// Copyright (C) 2019-2023 LNP/BP Standards Association. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::convert::Infallible;
+
+use strict_encoding::StrictDumb;
+
+use crate::resolvers::ResolveHeight;
+use crate::validation::{ResolveWitness, WitnessResolverError};
+use crate::{WitnessAnchor, WitnessId, XAnchor, XPubWitness};
+
+pub(crate) struct DumbResolver;
+
+impl ResolveWitness for DumbResolver {
+    fn resolve_pub_witness(&self, _: WitnessId) -> Result<XPubWitness, WitnessResolverError> {
+        Ok(XPubWitness::strict_dumb())
+    }
+}
+
+impl ResolveHeight for DumbResolver {
+    type Error = Infallible;
+    fn resolve_anchor(&mut self, _: &XAnchor) -> Result<WitnessAnchor, Self::Error> {
+        Ok(WitnessAnchor::strict_dumb())
+    }
+}