Assignment interfaces for rgb20

src/interface/iimpl.rs

@@ -292,16 +292,32 @@ impl IfacePair {
     pub fn with(iface: Iface, iimpl: IfaceImpl) -> IfacePair { IfacePair { iface, iimpl } }
 
     pub fn iface_id(&self) -> IfaceId { self.iface.iface_id() }
+
     pub fn impl_id(&self) -> ImplId { self.iimpl.impl_id() }
+
     pub fn global_type(&self, name: &FieldName) -> Option<GlobalStateType> {
         self.iimpl.global_type(name)
     }
+
+    pub fn global_name(&self, global_type: &GlobalStateType) -> Option<&FieldName> {
+        self.iimpl.global_name(global_type.to_owned())
+    }
+
     pub fn assignments_type(&self, name: &FieldName) -> Option<AssignmentType> {
         self.iimpl.assignments_type(name)
     }
+
+    pub fn assignment_name(&self, assignment_type: &AssignmentType) -> Option<&FieldName> {
+        self.iimpl.assignment_name(assignment_type.to_owned())
+    }
+
     pub fn transition_type(&self, name: &TypeName) -> Option<TransitionType> {
         self.iimpl.transition_type(name)
     }
+
+    pub fn transition_name(&self, transition_type: &TransitionType) -> Option<&TypeName> {
+        self.iimpl.transition_name(transition_type.to_owned())
+    }
 }
 
 pub trait IssuerClass {

src/interface/rgb20.rs

@@ -31,8 +31,8 @@ use strict_types::{CompileError, LibBuilder, TypeLib};
 
 use super::{
     AssignIface, BuilderError, ContractBuilder, GenesisIface, GlobalIface, Iface, IfaceClass,
-    IfaceOp, IssuerClass, OwnedIface, Req, SchemaIssuer, StateChange, TransitionIface, VerNo,
-    WitnessFilter,
+    IfaceOp, IssuerClass, OwnedIface, Req, RightsAllocation, SchemaIssuer, StateChange,
+    TransitionIface, VerNo, WitnessFilter,
 };
 use crate::containers::Contract;
 use crate::interface::builder::TxOutpoint;
@@ -378,6 +378,42 @@ impl Rgb20 {
             .expect("RGB20 interface requires `assetOwner` state")
     }
 
+    pub fn inflation_allowance_allocations<'c>(
+        &'c self,
+        filter: impl OutpointFilter + 'c,
+    ) -> impl Iterator<Item = FungibleAllocation> + 'c {
+        self.0
+            .fungible("inflationAllowance", filter)
+            .expect("RGB20 interface requires `inflationAllowance` state")
+    }
+
+    pub fn update_right<'c>(
+        &'c self,
+        filter: impl OutpointFilter + 'c,
+    ) -> impl Iterator<Item = RightsAllocation> + 'c {
+        self.0
+            .rights("updateRight", filter)
+            .expect("RGB20 interface requires `updateRight` state")
+    }
+
+    pub fn burn_epoch<'c>(
+        &'c self,
+        filter: impl OutpointFilter + 'c,
+    ) -> impl Iterator<Item = RightsAllocation> + 'c {
+        self.0
+            .rights("burnEpoch", filter)
+            .expect("RGB20 interface requires `burnEpoch` state")
+    }
+
+    pub fn burn_right<'c>(
+        &'c self,
+        filter: impl OutpointFilter + 'c,
+    ) -> impl Iterator<Item = RightsAllocation> + 'c {
+        self.0
+            .rights("burnRight", filter)
+            .expect("RGB20 interface requires `updateRight` state")
+    }
+
     pub fn contract_data(&self) -> ContractData {
         let strict_val = &self
             .0

src/interface/rgb21.rs

@@ -124,6 +124,18 @@ pub struct EngravingData {
     pub content: EmbeddedMedia,
 }
 
+impl EngravingData {
+    pub fn from_strict_val_unchecked(value: &StrictVal) -> Self {
+        let index = TokenIndex(value.unwrap_struct("index").unwrap_num().unwrap_uint());
+        let content = EmbeddedMedia::from_strict_val_unchecked(value.unwrap_struct("content"));
+
+        Self {
+            applied_to: index,
+            content,
+        }
+    }
+}
+
 #[derive(Clone, Eq, PartialEq, Hash, Debug)]
 #[derive(StrictType, StrictDumb, StrictEncode, StrictDecode)]
 #[strict_type(lib = LIB_NAME_RGB21)]
@@ -532,6 +544,14 @@ impl Rgb21 {
         Timestamp::from_strict_val_unchecked(strict_val)
     }
 
+    pub fn engarving_data(&self) -> EngravingData {
+        let strict_val = &self
+            .0
+            .global("engravings")
+            .expect("RGB21 interface requires global state `engravings`")[0];
+        EngravingData::from_strict_val_unchecked(strict_val)
+    }
+
     pub fn allocations<'c>(
         &'c self,
         filter: impl OutpointFilter + 'c,