From 45f98d4d4644ab5e0944db1ff8f1f1e8e3d6e3af Mon Sep 17 00:00:00 2001 From: Dr Maxim Orlovsky Date: Fri, 14 Jul 2023 19:46:43 +0200 Subject: [PATCH 1/5] containers: add optional witness tx data to terminals. Closes #87 --- std/src/containers/bindle.rs | 10 +- std/src/containers/consignment.rs | 13 +- std/src/containers/seal.rs | 7 + std/src/containers/transfer.rs | 12 +- std/src/containers/util.rs | 22 +- std/src/persistence/inventory.rs | 6 +- std/src/persistence/stock.rs | 6 +- std/src/stl/stl.rs | 3 +- stl/RGBStd@0.1.0.sta | 334 ++++++++++++++++-------------- stl/RGBStd@0.1.0.stl | Bin 13262 -> 13858 bytes stl/RGBStd@0.1.0.sty | 25 ++- 11 files changed, 244 insertions(+), 194 deletions(-) diff --git a/std/src/containers/bindle.rs b/std/src/containers/bindle.rs index 363454fe..7335bfcf 100644 --- a/std/src/containers/bindle.rs +++ b/std/src/containers/bindle.rs @@ -33,7 +33,7 @@ pub use _fs::*; use amplify::confinement::{Confined, TinyVec, U24}; use baid58::Baid58ParseError; use base64::Engine; -use rgb::{ContractId, Schema, SchemaId, SchemaRoot}; +use rgb::{BundleId, ContractId, Schema, SchemaId, SchemaRoot}; use strict_encoding::{ StrictDecode, StrictDeserialize, StrictDumb, StrictEncode, StrictSerialize, StrictType, }; @@ -81,8 +81,8 @@ impl BindleContent for Contract { bmap! { "Version" => self.version.to_string(), "Terminals" => self.terminals - .iter() - .map(|t| t.seal.to_string()) + .keys() + .map(BundleId::to_string) .collect::>() .join(",\n "), } @@ -99,8 +99,8 @@ impl BindleContent for Transfer { "Version" => self.version.to_string(), "ContractId" => self.contract_id().to_string(), "Terminals" => self.terminals - .iter() - .map(|t| t.seal.to_string()) + .keys() + .map(BundleId::to_string) .collect::>() .join(",\n "), } diff --git a/std/src/containers/consignment.rs b/std/src/containers/consignment.rs index 46966d7e..e1ed428a 100644 --- a/std/src/containers/consignment.rs +++ b/std/src/containers/consignment.rs @@ -22,9 +22,7 @@ use std::collections::{BTreeMap, BTreeSet}; use std::{iter, slice}; -use amplify::confinement::{ - LargeVec, MediumBlob, SmallOrdMap, SmallOrdSet, TinyOrdMap, TinyOrdSet, -}; +use amplify::confinement::{LargeVec, MediumBlob, SmallOrdMap, TinyOrdMap, TinyOrdSet}; use commit_verify::Conceal; use rgb::validation::{AnchoredBundle, ConsignmentApi}; use rgb::{ @@ -93,7 +91,7 @@ pub struct Consignment { pub genesis: Genesis, /// Set of seals which are history terminals. - pub terminals: SmallOrdSet, + pub terminals: SmallOrdMap, /// Data on all anchored state transitions contained in the consignments. pub bundles: LargeVec, @@ -279,7 +277,12 @@ impl ConsignmentApi for Consignment { fn terminals(&self) -> BTreeSet<(BundleId, SecretSeal)> { self.terminals .iter() - .map(|terminal| (terminal.bundle_id, terminal.seal.conceal())) + .flat_map(|(bundle_id, terminal)| { + terminal + .seals + .iter() + .map(|seal| (*bundle_id, seal.conceal())) + }) .collect() } diff --git a/std/src/containers/seal.rs b/std/src/containers/seal.rs index 5a55c8e4..1fb19bb0 100644 --- a/std/src/containers/seal.rs +++ b/std/src/containers/seal.rs @@ -156,6 +156,13 @@ impl TerminalSeal { pub fn new_vout(method: CloseMethod, vout: impl Into) -> TerminalSeal { TerminalSeal::WitnessVout(VoutSeal::new(method, vout)) } + + pub fn secret_seal(&self) -> Option { + match self { + TerminalSeal::ConcealedUtxo(seal) => Some(*seal), + TerminalSeal::WitnessVout(_) => None, + } + } } impl Conceal for TerminalSeal { diff --git a/std/src/containers/transfer.rs b/std/src/containers/transfer.rs index fd9a7331..5c84e990 100644 --- a/std/src/containers/transfer.rs +++ b/std/src/containers/transfer.rs @@ -22,12 +22,13 @@ use std::io; use std::str::FromStr; +use amplify::confinement::SmallOrdSet; use amplify::{Bytes32, RawArray}; use baid58::{Baid58ParseError, FromBaid58, ToBaid58}; use commit_verify::{CommitEncode, CommitmentId, Conceal}; use strict_encoding::{StrictEncode, StrictWriter}; -use crate::containers::Transfer; +use crate::containers::{TerminalSeal, Transfer}; use crate::LIB_NAME_RGB_STD; /// Transfer identifier. @@ -64,9 +65,12 @@ impl CommitEncode for Transfer { let mut writer = StrictWriter::with(usize::MAX, e); writer = self.transfer.strict_encode(writer)?; writer = self.contract_id().strict_encode(writer)?; - for terminal in &self.terminals { - writer = terminal.seal.conceal().strict_encode(writer)?; - writer = terminal.bundle_id.strict_encode(writer)?; + for (bundle_id, terminal) in &self.terminals { + writer = bundle_id.strict_encode(writer)?; + let seals = + SmallOrdSet::try_from_iter(terminal.seals.iter().map(TerminalSeal::conceal)) + .expect("same size iterator"); + writer = seals.strict_encode(writer)?; } for attach_id in self.attachments.keys() { writer = attach_id.strict_encode(writer)?; diff --git a/std/src/containers/util.rs b/std/src/containers/util.rs index adc236fa..66a6dfb9 100644 --- a/std/src/containers/util.rs +++ b/std/src/containers/util.rs @@ -19,12 +19,13 @@ // See the License for the specific language governing permissions and // limitations under the License. -use rgb::BundleId; +use amplify::confinement::SmallOrdSet; +use bp::Tx; use super::TerminalSeal; use crate::LIB_NAME_RGB_STD; -#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug)] +#[derive(Clone, Eq, PartialEq, Debug)] #[derive(StrictType, StrictDumb, StrictEncode, StrictDecode)] #[strict_type(lib = LIB_NAME_RGB_STD)] #[cfg_attr( @@ -33,12 +34,23 @@ use crate::LIB_NAME_RGB_STD; serde(crate = "serde_crate", rename_all = "camelCase") )] pub struct Terminal { - pub bundle_id: BundleId, - pub seal: TerminalSeal, + pub seals: SmallOrdSet, + pub tx: Option, } impl Terminal { - pub fn with(bundle_id: BundleId, seal: TerminalSeal) -> Self { Terminal { bundle_id, seal } } + pub fn new(seal: TerminalSeal) -> Self { + Terminal { + seals: small_bset![seal], + tx: None, + } + } + pub fn with(seal: TerminalSeal, tx: Tx) -> Self { + Terminal { + seals: small_bset![seal], + tx: Some(tx), + } + } } #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, Display, Default)] diff --git a/std/src/persistence/inventory.rs b/std/src/persistence/inventory.rs index 7bf24f60..0786e595 100644 --- a/std/src/persistence/inventory.rs +++ b/std/src/persistence/inventory.rs @@ -507,7 +507,7 @@ pub trait Inventory: Deref { // outpoints let mut anchored_bundles = BTreeMap::::new(); let mut transitions = BTreeMap::::new(); - let mut terminals = BTreeSet::::new(); + let mut terminals = BTreeMap::::new(); for opout in opouts { if opout.op == contract_id { continue; // we skip genesis since it will be present anywhere @@ -523,13 +523,13 @@ pub trait Inventory: Deref { for index in 0..typed_assignments.len_u16() { let seal = typed_assignments.to_confidential_seals()[index as usize]; if terminal_seals.contains(&seal) { - terminals.insert(Terminal::with(bundle_id, seal.into())); + terminals.insert(bundle_id, Terminal::new(seal.into())); } else if opout.no == index && opout.ty == *type_id { if let Some(seal) = typed_assignments .revealed_seal_at(index) .expect("index exists") { - terminals.insert(Terminal::with(bundle_id, seal.into())); + terminals.insert(bundle_id, Terminal::new(seal.into())); } else { return Err(ConsignerError::ConcealedPublicState(opout)); } diff --git a/std/src/persistence/stock.rs b/std/src/persistence/stock.rs index 5c48e073..d502c27f 100644 --- a/std/src/persistence/stock.rs +++ b/std/src/persistence/stock.rs @@ -154,14 +154,14 @@ impl Stock { } // clone needed due to borrow checker - for terminal in consignment.terminals.clone() { - if let TerminalSeal::ConcealedUtxo(secret) = terminal.seal { + for (bundle_id, terminal) in consignment.terminals.clone() { + for secret in terminal.seals.iter().filter_map(TerminalSeal::secret_seal) { if let Some(seal) = self .seal_secrets .iter() .find(|s| s.to_concealed_seal() == secret) { - consignment.reveal_bundle_seal(terminal.bundle_id, *seal); + consignment.reveal_bundle_seal(bundle_id, *seal); } } } diff --git a/std/src/stl/stl.rs b/std/src/stl/stl.rs index be483f0c..90272286 100644 --- a/std/src/stl/stl.rs +++ b/std/src/stl/stl.rs @@ -41,7 +41,8 @@ pub const LIB_ID_RGB_CONTRACT: &str = "price_canvas_oliver_9Te5P6nq3oaDHMgttLEbkojbeQPTqqZLhjxZ3my1F8aJ"; /// Strict types id for the library representing of RGB StdLib data types. -pub const LIB_ID_RGB_STD: &str = "patent_iris_torch_Firwvn75qng8cm4n7iHXXiFDsG1V476vYGqdfwwFRT1b"; +pub const LIB_ID_RGB_STD: &str = + "joel_penguin_service_BmH4kCeEWYJSWVEC2rscH6SiFCyZQN178zngNof4RZxH"; fn _rgb_std_stl() -> Result { LibBuilder::new(libname!(LIB_NAME_RGB_STD), tiny_bset! { diff --git a/stl/RGBStd@0.1.0.sta b/stl/RGBStd@0.1.0.sta index 6c65ac84..97167f1e 100644 --- a/stl/RGBStd@0.1.0.sta +++ b/stl/RGBStd@0.1.0.sta @@ -1,5 +1,5 @@ -----BEGIN STRICT TYPE LIB----- -Id: patent_iris_torch_Firwvn75qng8cm4n7iHXXiFDsG1V476vYGqdfwwFRT1b +Id: joel_penguin_service_BmH4kCeEWYJSWVEC2rscH6SiFCyZQN178zngNof4RZxH Name: RGBStd Dependencies: CommitVerify@melody_arctic_labor_ZtHaBzu9ojbDahaGKEXe5v9DfSDxLERbLkEB23R6Q6V, @@ -28,14 +28,23 @@ vZW7u8v14cUliUXSEXbaHtTcjMUxJWUOQmxpbmRTZWFsVHhQdHKqSsRo4n6UttYD Kpadulb7XWWBXAl6UARwJe2IswOUvwVQcm9vZrHlODkUCji+8G8az74cYKVv4eH0 fXgIKHm/0frTECHdBVR4UHRy0lIwfH1xkDX3MH7oKCXsG4EroYfdnZhJi0qNFvpu 1UMLQ2xvc2VNZXRob2Th0W5XqD5OSJpAa5BMLe+pMQAZmEa0NmHOOFai1y4aahFB -bmNob3JNZXJrbGVQcm9vZgdCaXRjb2luCAAh4z5Dxapc8iknU6M4wWftO2OcTdnO -vamPNGkXuslDdQRWb3V0Jav1uRIUF7qjOdRfexV1p3FL4Xp1GF3QMTV61Mkt6YYL -U2NyaXB0Qnl0ZXMxu67ohIl3xbAHMXIxzZL2MLYpLc2Jf9y63sW6xOl/2QtUYXBO -b2RlSGFzaFLaKwUtrKJOsk2RwiF9oJF9z15N/Idknyeh2hkURQmTBUNoYWluX6zZ -beU/TsUU2bGNZ4DaCqvrLSYL/Tcto8B6pF05n00KTGVhZlNjcmlwdKOCQvPL19HQ -oRLajeFgL1bU+G8OxMR2xcBoWUxLBGVWBFR4aWS2MwmpGL+2kg1uyFikJIcjRlpp -P3JDB7//Hdc6c4FOyQdMZWFmVmVy3/gAPIH+R/xUI7HSxuIPDd+qZr3M8310E8kf -ZdoAPIgKSW50ZXJuYWxQawxDb21taXRWZXJpZnkCAC/uzx5E0qEpuYoUOEdLOXGV +bmNob3JNZXJrbGVQcm9vZgdCaXRjb2luEwABGW2FKcj22kRNFU6NnIy9ng+NiQJa +O7CRIcY9UrAehwVTZXFObxlHLRfYYgenDyExqVihaKVuKtZTP5xmTBl32lz5/mKG +BFR4SW4h4z5Dxapc8iknU6M4wWftO2OcTdnOvamPNGkXuslDdQRWb3V0Jav1uRIU +F7qjOdRfexV1p3FL4Xp1GF3QMTV61Mkt6YYLU2NyaXB0Qnl0ZXMpHE1sV7Pq+hEK +gzSbYw8gYZUm8fzJ/CoxG/QoNvu+EAJUeDG7ruiEiXfFsAcxcjHNkvYwtiktzYl/ +3LrexbrE6X/ZC1RhcE5vZGVIYXNoNdodFTkgbrvd3KTDPYcx6vKbp9p03z3IgiAc +Tha1uRwITG9ja1RpbWU4dQSxS3wORm1HnhdHfSR0JH/4A2TsPUuq9zog90F0awlT +aWdTY3JpcHRS2isFLayiTrJNkcIhfaCRfc9eTfyHZJ8nodoZFEUJkwVDaGFpbl+s +2W3lP07FFNmxjWeA2gqr6y0mC/03LaPAeqRdOZ9NCkxlYWZTY3JpcHRzd0NwNpMg +Sc0olQiqcXzjgp2yRS5V6E7U/C48zS4AnQdXaXRuZXNzkDtkcHmEjxsmUyrkzsam +iUSgU1i48IHLJrO7+C2eO/MFVHhPdXSX9dcGQq4qM5IlO6hOHc7Ek+O/PtNxsYdz +hjVOzIiCawRTYXRzo4JC88vX0dChEtqN4WAvVtT4bw7ExHbFwGhZTEsEZVYEVHhp +ZKh8xnlkZ+VX10TlyWI64AzLldkaDS8D33TAdRJPvseeBVR4VmVytjMJqRi/tpIN +bshYpCSHI0ZaaT9yQwe//x3XOnOBTskHTGVhZlZlcr78HvxmpRn9ZFJqOhOHQOfx +EC0Lvv86wUZO8/dAdnRcDFNjcmlwdFB1Ymtled/4ADyB/kf8VCOx0sbiDw3fqma9 +zPN9dBPJH2XaADyICkludGVybmFsUGvoakDNXCX5veKE/2mlETKnQSshVb0OVhLB +v+OElWDFBghPdXRwb2ludAxDb21taXRWZXJpZnkCAC/uzx5E0qEpuYoUOEdLOXGV KygcogGS1RMm+LI2YF5nC01lcmtsZVByb29mVY03B/hFhlOA7sxBVSTopJlgUdOU gkPxlPfxkVcj6eYKTWVya2xlTm9kZQNSR0I4AAN7k7U9GoUuB1kBJXfNtkHwCK1O 5wBYYYO1wEq94AJcCEJ1bmRsZUlkBL6stxncmFA15Te4XCQG2v3hZZxP6sFNidDm @@ -132,161 +141,164 @@ pVfY5QAtdcabxbU/YqNxAb7MEtJmO2J6XwXH2PKa1m0q21GJK1umyeRh/eExiDXF AAAAAAAAAAD/AAAAAAAAAAtzdXBwbGVtZW50cwAJAcEKD4o0jKPLZIcLZ+8rQS7R Fu4Bzepaxt6Fsq8NxdhqAAAAAAAAAAD/AAAAAAAAAAdnZW5lc2lzAjZguc4fzD4O gXD5kwTwcHB9lQZs9kIaXDWnirptiFCofgrTLZIN4UnOVbx619Sx8P2CV8xefXmG -Pj1yrD2cytgJdGVybWluYWxzAAkBWIck86EQdvqB4uxyZrl0TEq6xURIFY4CKZLV -6DeCp34AAAAAAAAAAP//AAAAAAAAB2J1bmRsZXMACAI2YLnOH8w+DoFw+ZME8HBw -fZUGbPZCGlw1p4q6bYhQqCEqNH06TF1QpALSHMf9bCqf4kiRXKEzRSlsv18ikwtN -AAAAAAAAAAD/////AAAAAApleHRlbnNpb25zAAgCNmC5zh/MPg6BcPmTBPBwcH2V -Bmz2QhpcNaeKum2IUKisO/RoJXmUy/wFsf7EI1qYCdOyvFhI+RoPo+JMl2zETAAA -AAAAAAAA/////wAAAAALYXR0YWNobWVudHMACgI2YLnOH8w+DoFw+ZME8HBwfZUG -bPZCGlw1p4q6bYhQqIRxDZMsTvTDtwhLaYuwh3ApfjlkJH9Fkdjag23Rfbo4AAgA -AEAAAAAAAAAAAP///wAAAAAAAAAAAAAAAAD//wAAAAAAAApzaWduYXR1cmVzAAoB -4tQVUBHRhrraowmoTEpBSrkt5YEzfMrAWvP0fMTo6SEBQer6ZIklzzHJKUeAHMvX -pudkaKqysjjjvN5rIu0lfy8AAAAAAAAAAP8AAAAAAAAAD0NvbnNpZ25tZW50dHJ1 -ZQYLB3ZlcnNpb24BRPY8tH9R/F5WLLb6e3tTNdbE1yQZTdABqu4ZrLNuV7kIdHJh -bnNmZXICe4SAPJ764hElp3wsObxw0v3o+UOuDf2c9OaC7cdmynBhhiLRe67wZgLf -53XJgOCza2666AkNgHX3UTvsS5P2TQZzY2hlbWECNmC5zh/MPg6BcPmTBPBwcH2V -Bmz2QhpcNaeKum2IUKhcjeDvLxT2DN3w0GSSpUX8ghZPF/lqrbHeKmhzqOjjtwZp -ZmFjZXMACgE7ysCBAwjhK6tbIWiHhOO2c6VX2OUALXXGm8W1P2KjcQG+zBLSZjti -el8Fx9jymtZtKttRiStbpsnkYf3hMYg1xQAAAAAAAAAA/wAAAAAAAAALc3VwcGxl -bWVudHMACQHBCg+KNIyjy2SHC2fvK0Eu0RbuAc3qWsbehbKvDcXYagAAAAAAAAAA -/wAAAAAAAAAHZ2VuZXNpcwI2YLnOH8w+DoFw+ZME8HBwfZUGbPZCGlw1p4q6bYhQ -qH4K0y2SDeFJzlW8etfUsfD9glfMXn15hj49cqw9nMrYCXRlcm1pbmFscwAJAViH -JPOhEHb6geLscma5dExKusVESBWOAimS1eg3gqd+AAAAAAAAAAD//wAAAAAAAAdi -dW5kbGVzAAgCNmC5zh/MPg6BcPmTBPBwcH2VBmz2QhpcNaeKum2IUKghKjR9Okxd -UKQC0hzH/Wwqn+JIkVyhM0UpbL9fIpMLTQAAAAAAAAAA/////wAAAAAKZXh0ZW5z -aW9ucwAIAjZguc4fzD4OgXD5kwTwcHB9lQZs9kIaXDWnirptiFCorDv0aCV5lMv8 -BbH+xCNamAnTsrxYSPkaD6PiTJdsxEwAAAAAAAAAAP////8AAAAAC2F0dGFjaG1l -bnRzAAoCNmC5zh/MPg6BcPmTBPBwcH2VBmz2QhpcNaeKum2IUKiEcQ2TLE70w7cI -S2mLsIdwKX45ZCR/RZHY2oNt0X26OAAIAABAAAAAAAAAAAD///8AAAAAAAAAAAAA -AAAA//8AAAAAAAAKc2lnbmF0dXJlcwAKAeLUFVAR0Ya62qMJqExKQUq5LeWBM3zK -wFrz9HzE6OkhAUHq+mSJJc8xySlHgBzL16bnZGiqsrI447zeayLtJX8vAAAAAAAA -AAD/AAAAAAAAAAxDb250YWluZXJWZXIDAQJ2MQEJQ29udGVudElkBAUABnNjaGVt -YQAFAQI2YLnOH8w+DoFw+ZME8HBwfZUGbPZCGlw1p4q6bYhQqJRS09sDq6uoUZ+n -9j7QFOvUTX0xP/z+APpdJHpUBJAQAQdnZW5lc2lzAAUBAjZguc4fzD4OgXD5kwTw -cHB9lQZs9kIaXDWnirptiFConwgsSTrIAqK6xd3cCyJ8IK+U1GjESM8aWiHgvcL1 -OjICBWlmYWNlAAUBATvKwIEDCOErq1shaIeE47ZzpVfY5QAtdcabxbU/YqNxAwlp -ZmFjZUltcGwABQEBVsgPeLzGQhY620b4Xmfo0Cdql9CjvFEvCz0eRNjZqPsEBXN1 -cHBsAAUBAWcyh8AIcOsVmkbh9056/xhzweIRt6cpYYNiU7wwX4CVC0NvbnRlbnRT -aWdzBQEACQEZp5j6CUWbr5l5fYU3E8UGP6LV1wu7LVgNvqQg9bH50AEAAAAAAAAA -CgAAAAAAAAANQ29udHJhY3RTdXBwbAYGCmNvbnRyYWN0SWQCNmC5zh/MPg6BcPmT -BPBwcH2VBmz2QhpcNaeKum2IUKifCCxJOsgCorrF3dwLInwgr5TUaMRIzxpaIeC9 -wvU6MgZ0aWNrZXIBoluKuav9BesZm6VAH26Iobbwzb7wC8WcglAEkdyd4HUIbWVk -aWFLaXQACAABAAAAAAAAAAD/AAAAAAAAAAtnbG9iYWxTdGF0ZQAKAAACAbuDlJ38 -cOBEVBFHtjpdJwRs4kDcLVFYe0lE7mjTF6HIAAAAAAAAAAD/AAAAAAAAAApvd25l -ZFN0YXRlAAoAAAIBu4OUnfxw4ERUEUe2Ol0nBGziQNwtUVh7SUTuaNMXocgAAAAA -AAAAAP8AAAAAAAAACmV4dGVuc2lvbnMACgAAAgAIAABAAAAAAAAAAAD//wAAAAAA -AAAAAAAAAAAA/wAAAAAAAAAORXh0ZW5zaW9uSWZhY2UGBghtZXRhZGF0YQAEAgAE -bm9uZQAAAAEEc29tZQAFAQJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dB -yGsEoxSeppUAFmef7wK0qyT15reKZMjZ0L1l/NejWE6NB2dsb2JhbHMACgJDNAOU -2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByKgU7Ciw7VXt7q5ReaTn5Z9As/lV -FhBum8Euchq/flYcAfWu/DyXROeU6GFKi0S1vsaJnIwSRgAlLBsWcK95KHCTAAAA -AAAAAAD/AAAAAAAAAAdyZWRlZW1zAAoCQzQDlNgbMOJSKJAmHvNv+fioOVGR9Qtp +Pj1yrD2cytgJdGVybWluYWxzAAoCNmC5zh/MPg6BcPmTBPBwcH2VBmz2QhpcNaeK +um2IUKgDe5O1PRqFLgdZASV3zbZB8AitTucAWGGDtcBKveACXAEO2Yn6B13f7euc +cXhraQW4vMMFTAC/rQQXuFw8tf71aQAAAAAAAAAA//8AAAAAAAAHYnVuZGxlcwAI +AjZguc4fzD4OgXD5kwTwcHB9lQZs9kIaXDWnirptiFCoISo0fTpMXVCkAtIcx/1s +Kp/iSJFcoTNFKWy/XyKTC00AAAAAAAAAAP////8AAAAACmV4dGVuc2lvbnMACAI2 +YLnOH8w+DoFw+ZME8HBwfZUGbPZCGlw1p4q6bYhQqKw79GgleZTL/AWx/sQjWpgJ +07K8WEj5Gg+j4kyXbMRMAAAAAAAAAAD/////AAAAAAthdHRhY2htZW50cwAKAjZg +uc4fzD4OgXD5kwTwcHB9lQZs9kIaXDWnirptiFCohHENkyxO9MO3CEtpi7CHcCl+ +OWQkf0WR2NqDbdF9ujgACAAAQAAAAAAAAAAA////AAAAAAAAAAAAAAAAAP//AAAA +AAAACnNpZ25hdHVyZXMACgHi1BVQEdGGutqjCahMSkFKuS3lgTN8ysBa8/R8xOjp +IQFB6vpkiSXPMckpR4Acy9em52RoqrKyOOO83msi7SV/LwAAAAAAAAAA/wAAAAAA +AAAPQ29uc2lnbm1lbnR0cnVlBgsHdmVyc2lvbgFE9jy0f1H8XlYstvp7e1M11sTX +JBlN0AGq7hmss25XuQh0cmFuc2ZlcgJ7hIA8nvriESWnfCw5vHDS/ej5Q64N/Zz0 +5oLtx2bKcGGGItF7rvBmAt/ndcmA4LNrbrroCQ2AdfdRO+xLk/ZNBnNjaGVtYQI2 +YLnOH8w+DoFw+ZME8HBwfZUGbPZCGlw1p4q6bYhQqFyN4O8vFPYM3fDQZJKlRfyC +Fk8X+Wqtsd4qaHOo6OO3BmlmYWNlcwAKATvKwIEDCOErq1shaIeE47ZzpVfY5QAt +dcabxbU/YqNxAb7MEtJmO2J6XwXH2PKa1m0q21GJK1umyeRh/eExiDXFAAAAAAAA +AAD/AAAAAAAAAAtzdXBwbGVtZW50cwAJAcEKD4o0jKPLZIcLZ+8rQS7RFu4Bzepa +xt6Fsq8NxdhqAAAAAAAAAAD/AAAAAAAAAAdnZW5lc2lzAjZguc4fzD4OgXD5kwTw +cHB9lQZs9kIaXDWnirptiFCofgrTLZIN4UnOVbx619Sx8P2CV8xefXmGPj1yrD2c +ytgJdGVybWluYWxzAAoCNmC5zh/MPg6BcPmTBPBwcH2VBmz2QhpcNaeKum2IUKgD +e5O1PRqFLgdZASV3zbZB8AitTucAWGGDtcBKveACXAEO2Yn6B13f7euccXhraQW4 +vMMFTAC/rQQXuFw8tf71aQAAAAAAAAAA//8AAAAAAAAHYnVuZGxlcwAIAjZguc4f +zD4OgXD5kwTwcHB9lQZs9kIaXDWnirptiFCoISo0fTpMXVCkAtIcx/1sKp/iSJFc +oTNFKWy/XyKTC00AAAAAAAAAAP////8AAAAACmV4dGVuc2lvbnMACAI2YLnOH8w+ +DoFw+ZME8HBwfZUGbPZCGlw1p4q6bYhQqKw79GgleZTL/AWx/sQjWpgJ07K8WEj5 +Gg+j4kyXbMRMAAAAAAAAAAD/////AAAAAAthdHRhY2htZW50cwAKAjZguc4fzD4O +gXD5kwTwcHB9lQZs9kIaXDWnirptiFCohHENkyxO9MO3CEtpi7CHcCl+OWQkf0WR +2NqDbdF9ujgACAAAQAAAAAAAAAAA////AAAAAAAAAAAAAAAAAP//AAAAAAAACnNp +Z25hdHVyZXMACgHi1BVQEdGGutqjCahMSkFKuS3lgTN8ysBa8/R8xOjpIQFB6vpk +iSXPMckpR4Acy9em52RoqrKyOOO83msi7SV/LwAAAAAAAAAA/wAAAAAAAAAMQ29u +dGFpbmVyVmVyAwECdjEBCUNvbnRlbnRJZAQFAAZzY2hlbWEABQECNmC5zh/MPg6B +cPmTBPBwcH2VBmz2QhpcNaeKum2IUKiUUtPbA6urqFGfp/Y+0BTr1E19MT/8/gD6 +XSR6VASQEAEHZ2VuZXNpcwAFAQI2YLnOH8w+DoFw+ZME8HBwfZUGbPZCGlw1p4q6 +bYhQqJ8ILEk6yAKiusXd3AsifCCvlNRoxEjPGloh4L3C9ToyAgVpZmFjZQAFAQE7 +ysCBAwjhK6tbIWiHhOO2c6VX2OUALXXGm8W1P2KjcQMJaWZhY2VJbXBsAAUBAVbI +D3i8xkIWOttG+F5n6NAnapfQo7xRLws9HkTY2aj7BAVzdXBwbAAFAQFnMofACHDr +FZpG4fdOev8Yc8HiEbenKWGDYlO8MF+AlQtDb250ZW50U2lncwUBAAkBGaeY+glF +m6+ZeX2FNxPFBj+i1dcLuy1YDb6kIPWx+dABAAAAAAAAAAoAAAAAAAAADUNvbnRy +YWN0U3VwcGwGBgpjb250cmFjdElkAjZguc4fzD4OgXD5kwTwcHB9lQZs9kIaXDWn +irptiFConwgsSTrIAqK6xd3cCyJ8IK+U1GjESM8aWiHgvcL1OjIGdGlja2VyAaJb +irmr/QXrGZulQB9uiKG28M2+8AvFnIJQBJHcneB1CG1lZGlhS2l0AAgAAQAAAAAA +AAAA/wAAAAAAAAALZ2xvYmFsU3RhdGUACgAAAgG7g5Sd/HDgRFQRR7Y6XScEbOJA +3C1RWHtJRO5o0xehyAAAAAAAAAAA/wAAAAAAAAAKb3duZWRTdGF0ZQAKAAACAbuD +lJ38cOBEVBFHtjpdJwRs4kDcLVFYe0lE7mjTF6HIAAAAAAAAAAD/AAAAAAAAAApl +eHRlbnNpb25zAAoAAAIACAAAQAAAAAAAAAAA//8AAAAAAAAAAAAAAAAAAP8AAAAA +AAAADkV4dGVuc2lvbklmYWNlBgYIbWV0YWRhdGEABAIABG5vbmUAAAABBHNvbWUA +BQECQzQDlNgbMOJSKJAmHvNv+fioOVGR9QtpXiMqHrO3QchrBKMUnqaVABZnn+8C +tKsk9ea3imTI2dC9ZfzXo1hOjQdnbG9iYWxzAAoCQzQDlNgbMOJSKJAmHvNv+fio +OVGR9QtpXiMqHrO3QcioFOwosO1V7e6uUXmk5+WfQLP5VRYQbpvBLnIav35WHAH1 +rvw8l0TnlOhhSotEtb7GiZyMEkYAJSwbFnCveShwkwAAAAAAAAAA/wAAAAAAAAAH +cmVkZWVtcwAKAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HIqBTsKLDt +Ve3urlF5pOfln0Cz+VUWEG6bwS5yGr9+VhwB9a78PJdE55ToYUqLRLW+xomcjBJG +ACUsGxZwr3kocJMAAAAAAAAAAP8AAAAAAAAAC2Fzc2lnbm1lbnRzAAoCQzQDlNgb +MOJSKJAmHvNv+fioOVGR9QtpXiMqHrO3QcioFOwosO1V7e6uUXmk5+WfQLP5VRYQ +bpvBLnIav35WHAH1rvw8l0TnlOhhSotEtb7GiZyMEkYAJSwbFnCveShwkwAAAAAA +AAAA/wAAAAAAAAAJdmFsZW5jaWVzAAoCQzQDlNgbMOJSKJAmHvNv+fioOVGR9Qtp XiMqHrO3QcioFOwosO1V7e6uUXmk5+WfQLP5VRYQbpvBLnIav35WHAH1rvw8l0Tn -lOhhSotEtb7GiZyMEkYAJSwbFnCveShwkwAAAAAAAAAA/wAAAAAAAAALYXNzaWdu -bWVudHMACgJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByKgU7Ciw7VXt -7q5ReaTn5Z9As/lVFhBum8Euchq/flYcAfWu/DyXROeU6GFKi0S1vsaJnIwSRgAl -LBsWcK95KHCTAAAAAAAAAAD/AAAAAAAAAAl2YWxlbmNpZXMACgJDNAOU2Bsw4lIo -kCYe82/5+Kg5UZH1C2leIyoes7dByKgU7Ciw7VXt7q5ReaTn5Z9As/lVFhBum8Eu -chq/flYcAfWu/DyXROeU6GFKi0S1vsaJnIwSRgAlLBsWcK95KHCTAAAAAAAAAAD/ -AAAAAAAAAAZlcnJvcnMACQAAAQAAAAAAAAAA/wAAAAAAAAAMR2VuZXNpc0lmYWNl -BgUIbWV0YWRhdGEABAIABG5vbmUAAAABBHNvbWUABQECQzQDlNgbMOJSKJAmHvNv -+fioOVGR9QtpXiMqHrO3QchrBKMUnqaVABZnn+8CtKsk9ea3imTI2dC9ZfzXo1hO -jQZnbG9iYWwACgJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByKgU7Ciw +lOhhSotEtb7GiZyMEkYAJSwbFnCveShwkwAAAAAAAAAA/wAAAAAAAAAGZXJyb3Jz +AAkAAAEAAAAAAAAAAP8AAAAAAAAADEdlbmVzaXNJZmFjZQYFCG1ldGFkYXRhAAQC +AARub25lAAAAAQRzb21lAAUBAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6z +t0HIawSjFJ6mlQAWZ5/vArSrJPXmt4pkyNnQvWX816NYTo0GZ2xvYmFsAAoCQzQD +lNgbMOJSKJAmHvNv+fioOVGR9QtpXiMqHrO3QcioFOwosO1V7e6uUXmk5+WfQLP5 +VRYQbpvBLnIav35WHAH1rvw8l0TnlOhhSotEtb7GiZyMEkYAJSwbFnCveShwkwAA +AAAAAAAA/wAAAAAAAAALYXNzaWdubWVudHMACgJDNAOU2Bsw4lIokCYe82/5+Kg5 +UZH1C2leIyoes7dByKgU7Ciw7VXt7q5ReaTn5Z9As/lVFhBum8Euchq/flYcAfWu +/DyXROeU6GFKi0S1vsaJnIwSRgAlLBsWcK95KHCTAAAAAAAAAAD/AAAAAAAAAAl2 +YWxlbmNpZXMACgJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByKgU7Ciw 7VXt7q5ReaTn5Z9As/lVFhBum8Euchq/flYcAfWu/DyXROeU6GFKi0S1vsaJnIwS -RgAlLBsWcK95KHCTAAAAAAAAAAD/AAAAAAAAAAthc3NpZ25tZW50cwAKAkM0A5TY -GzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HIqBTsKLDtVe3urlF5pOfln0Cz+VUW -EG6bwS5yGr9+VhwB9a78PJdE55ToYUqLRLW+xomcjBJGACUsGxZwr3kocJMAAAAA -AAAAAP8AAAAAAAAACXZhbGVuY2llcwAKAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfUL -aV4jKh6zt0HIqBTsKLDtVe3urlF5pOfln0Cz+VUWEG6bwS5yGr9+VhwB9a78PJdE -55ToYUqLRLW+xomcjBJGACUsGxZwr3kocJMAAAAAAAAAAP8AAAAAAAAABmVycm9y -cwAJAAABAAAAAAAAAAD/AAAAAAAAAAtHbG9iYWxJZmFjZQYDBXNlbUlkAAQCAARu -b25lAAAAAQRzb21lAAUBAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HI -awSjFJ6mlQAWZ5/vArSrJPXmt4pkyNnQvWX816NYTo0IcmVxdWlyZWQCe4SAPJ76 -4hElp3wsObxw0v3o+UOuDf2c9OaC7cdmynBhhiLRe67wZgLf53XJgOCza2666AkN -gHX3UTvsS5P2TQhtdWx0aXBsZQJ7hIA8nvriESWnfCw5vHDS/ej5Q64N/Zz05oLt -x2bKcGGGItF7rvBmAt/ndcmA4LNrbrroCQ2AdfdRO+xLk/ZNB0lkU3VpdGUDAwNw -Z3AAA3NzaAEDc3NpAghJZGVudGl0eQYEBG5hbWUACAABAAAAAAAAAAD/AAAAAAAA -AAVlbWFpbAAIAnuEgDye+uIRJad8LDm8cNL96PlDrg39nPTmgu3HZspwFE2uyDLm -xDeSeyVeuZtCiofZDVCozNBNchG1t7xfZs4AAAAAAAAAAP8AAAAAAAAABXN1aXRl -AcHe/BfMlJcORZvmPXqP+SIExjLYtYH2rGZl6TkJSDK8AnBrAAgAAEAAAAAAAAAA -AP8AAAAAAAAABUlmYWNlBgoHdmVyc2lvbgEXJdoGd30hx2TYb8sCetTOFVpjFilo -/+b4112WUO0f4QRuYW1lAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HI -DRQjZfKkr8YbU23UZ1VyZiuwcqOQD8mLAGaK2DGA4rALZ2xvYmFsU3RhdGUACgJD +RgAlLBsWcK95KHCTAAAAAAAAAAD/AAAAAAAAAAZlcnJvcnMACQAAAQAAAAAAAAAA +/wAAAAAAAAALR2xvYmFsSWZhY2UGAwVzZW1JZAAEAgAEbm9uZQAAAAEEc29tZQAF +AQJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByGsEoxSeppUAFmef7wK0 +qyT15reKZMjZ0L1l/NejWE6NCHJlcXVpcmVkAnuEgDye+uIRJad8LDm8cNL96PlD +rg39nPTmgu3HZspwYYYi0Xuu8GYC3+d1yYDgs2tuuugJDYB191E77EuT9k0IbXVs +dGlwbGUCe4SAPJ764hElp3wsObxw0v3o+UOuDf2c9OaC7cdmynBhhiLRe67wZgLf +53XJgOCza2666AkNgHX3UTvsS5P2TQdJZFN1aXRlAwMDcGdwAANzc2gBA3NzaQII +SWRlbnRpdHkGBARuYW1lAAgAAQAAAAAAAAAA/wAAAAAAAAAFZW1haWwACAJ7hIA8 +nvriESWnfCw5vHDS/ej5Q64N/Zz05oLtx2bKcBRNrsgy5sQ3knslXrmbQoqH2Q1Q +qMzQTXIRtbe8X2bOAAAAAAAAAAD/AAAAAAAAAAVzdWl0ZQHB3vwXzJSXDkWb5j16 +j/kiBMYy2LWB9qxmZek5CUgyvAJwawAIAABAAAAAAAAAAAD/AAAAAAAAAAVJZmFj +ZQYKB3ZlcnNpb24BFyXaBnd9Icdk2G/LAnrUzhVaYxYpaP/m+NddllDtH+EEbmFt +ZQJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByA0UI2XypK/GG1Nt1GdV +cmYrsHKjkA/JiwBmitgxgOKwC2dsb2JhbFN0YXRlAAoCQzQDlNgbMOJSKJAmHvNv ++fioOVGR9QtpXiMqHrO3QcioFOwosO1V7e6uUXmk5+WfQLP5VRYQbpvBLnIav35W +HAHKCOaQnxy0lIfsbXwcxJPd0yNGNxgiUrUm0TQ/4g7JhAAAAAAAAAAA/wAAAAAA +AAALYXNzaWdubWVudHMACgJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dB +yKgU7Ciw7VXt7q5ReaTn5Z9As/lVFhBum8Euchq/flYcAUupyIip1OMravmn/LM5 +DMcRN83BtBlsAJmxmqCck/ozAAAAAAAAAAD/AAAAAAAAAAl2YWxlbmNpZXMACgJD NAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByKgU7Ciw7VXt7q5ReaTn5Z9A -s/lVFhBum8Euchq/flYcAcoI5pCfHLSUh+xtfBzEk93TI0Y3GCJStSbRND/iDsmE -AAAAAAAAAAD/AAAAAAAAAAthc3NpZ25tZW50cwAKAkM0A5TYGzDiUiiQJh7zb/n4 -qDlRkfULaV4jKh6zt0HIqBTsKLDtVe3urlF5pOfln0Cz+VUWEG6bwS5yGr9+VhwB -S6nIiKnU4ytq+af8szkMxxE3zcG0GWwAmbGaoJyT+jMAAAAAAAAAAP8AAAAAAAAA -CXZhbGVuY2llcwAKAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HIqBTs -KLDtVe3urlF5pOfln0Cz+VUWEG6bwS5yGr9+VhwBqq11iMtoJ1mNLHFTjCXyKZV6 -6rkLuP/RN4TWMUoIjSwAAAAAAAAAAP8AAAAAAAAAB2dlbmVzaXMBI2m9apJ2YSo1 -rKZjVvMvpxSI9jfj/aC17DjNTXMWgKYLdHJhbnNpdGlvbnMACgJDNAOU2Bsw4lIo -kCYe82/5+Kg5UZH1C2leIyoes7dByA0UI2XypK/GG1Nt1GdVcmYrsHKjkA/JiwBm -itgxgOKwAXnPEuNGQcOIMK6IgfLLLX56AabuUMUihcdRH05m9qyKAAAAAAAAAAD/ -AAAAAAAAAApleHRlbnNpb25zAAoCQzQDlNgbMOJSKJAmHvNv+fioOVGR9QtpXiMq -HrO3QcgNFCNl8qSvxhtTbdRnVXJmK7Byo5APyYsAZorYMYDisAFcBGiXdNdaYhkp -TOPvNyvZJF60HggJ5qVS4Dh9IbhgdgAAAAAAAAAA/wAAAAAAAAAJZXJyb3JUeXBl -AkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HIawSjFJ6mlQAWZ5/vArSr -JPXmt4pkyNnQvWX816NYTo0QZGVmYXVsdE9wZXJhdGlvbgAEAgAEbm9uZQAAAAEE -c29tZQAFAQJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByA0UI2XypK/G -G1Nt1GdVcmYrsHKjkA/JiwBmitgxgOKwB0lmYWNlSWQFAQAHAABAIAAJSWZhY2VJ -bXBsBggHdmVyc2lvbgEXJdoGd30hx2TYb8sCetTOFVpjFilo/+b4112WUO0f4Qhz -Y2hlbWFJZAI2YLnOH8w+DoFw+ZME8HBwfZUGbPZCGlw1p4q6bYhQqJRS09sDq6uo -UZ+n9j7QFOvUTX0xP/z+APpdJHpUBJAQB2lmYWNlSWQBO8rAgQMI4SurWyFoh4Tj -tnOlV9jlAC11xpvFtT9io3ELZ2xvYmFsU3RhdGUACQFANDEFra9ZSQmCILC31RCC -6jFxfWnCKUBIG0oO/yxtlQAAAAAAAAAA/wAAAAAAAAALYXNzaWdubWVudHMACQFA -NDEFra9ZSQmCILC31RCC6jFxfWnCKUBIG0oO/yxtlQAAAAAAAAAA/wAAAAAAAAAJ -dmFsZW5jaWVzAAkBQDQxBa2vWUkJgiCwt9UQguoxcX1pwilASBtKDv8sbZUAAAAA -AAAAAP8AAAAAAAAAC3RyYW5zaXRpb25zAAkBeJhTpqsZdcZ0aKfhHSCYe1P+w4mM -Sc6kES67hRLEYiYAAAAAAAAAAP8AAAAAAAAACmV4dGVuc2lvbnMACQFANDEFra9Z -SQmCILC31RCC6jFxfWnCKUBIG0oO/yxtlQAAAAAAAAAA/wAAAAAAAAAJSWZhY2VQ -YWlyBgIFaWZhY2UBPy0gDnBInwBrxZiAbBrQKdnuUQm9MkAxwmSwNv3AItIFaWlt -cGwBx05MzAZpIy2Fdw9ffKqcWnh5+hnzPHbp9UsNgmR8SjkGSW1wbElkBQEABwAA -QCAADU5hbWVkRmllbGR1MTYGAgJpZAAAAgRuYW1lAkM0A5TYGzDiUiiQJh7zb/n4 -qDlRkfULaV4jKh6zt0HIqBTsKLDtVe3urlF5pOfln0Cz+VUWEG6bwS5yGr9+VhwM -TmFtZWRUeXBldTE2BgICaWQAAAIEbmFtZQJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1 -C2leIyoes7dByA0UI2XypK/GG1Nt1GdVcmYrsHKjkA/JiwBmitgxgOKwCk93bmVk -SWZhY2UEBgADYW55AAAAAQZyaWdodHMAAAACBmFtb3VudAAAAAMHYW55RGF0YQAA -AAQJYW55QXR0YWNoAAAABQRkYXRhAAUBAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfUL -aV4jKh6zt0HIawSjFJ6mlQAWZ5/vArSrJPXmt4pkyNnQvWX816NYTo0PT3duZWRT -dGF0ZVN1cHBsBgIHbWVhbmluZwAIAAEAAAAAAAAAAP8AAAAAAAAACHZlbG9jaXR5 -AQoN6hoNUJh61HLXnCHMgn+gy1eqeEUykvJBTDOHSAkAB1N1cHBsSWQFAQAHAABA -IAAIVGVybWluYWwGAghidW5kbGVJZAI2YLnOH8w+DoFw+ZME8HBwfZUGbPZCGlw1 -p4q6bYhQqAN7k7U9GoUuB1kBJXfNtkHwCK1O5wBYYYO1wEq94AJcBHNlYWwBeZ8e -DDj3bH7mQm2w+A7b+I0e6YVeEakB5Q+bKZwLBVEMVGVybWluYWxTZWFsBAIADWNv -bmNlYWxlZFV0eG8ABQECFwZOaYm8ANN+QATAdalw1SQOh8fRNH4sG25uxi7AoTdo -Geu81bMYq5ezmKVLNmXd2qcGb+jpJOcDYKmUs70GTgELd2l0bmVzc1ZvdXQABQEB -rfgBQ3QMS696dYeLgRAHBlmBXB0olcAUwEFDuoad69MLVGlja2VyU3VwcGwEAwAG -YWJzZW50AAAAAQZnbG9iYWwABQIAAAICQzQDlNgbMOJSKJAmHvNv+fioOVGR9Qtp -XiMqHrO3QcjampqqKfXsUiaPC1MLDos0/MSt5LN7q24BvQ1EDWFpIAIFb3duZWQA -BQIAAAICQzQDlNgbMOJSKJAmHvNv+fioOVGR9QtpXiMqHrO3QcjampqqKfXsUiaP -C1MLDos0/MSt5LN7q24BvQ1EDWFpIA9UcmFuc2l0aW9uSWZhY2UGCAhvcHRpb25h -bAJ7hIA8nvriESWnfCw5vHDS/ej5Q64N/Zz05oLtx2bKcGGGItF7rvBmAt/ndcmA -4LNrbrroCQ2AdfdRO+xLk/ZNCG1ldGFkYXRhAAQCAARub25lAAAAAQRzb21lAAUB -AkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HIawSjFJ6mlQAWZ5/vArSr -JPXmt4pkyNnQvWX816NYTo0HZ2xvYmFscwAKAkM0A5TYGzDiUiiQJh7zb/n4qDlR -kfULaV4jKh6zt0HIqBTsKLDtVe3urlF5pOfln0Cz+VUWEG6bwS5yGr9+VhwB9a78 -PJdE55ToYUqLRLW+xomcjBJGACUsGxZwr3kocJMAAAAAAAAAAP8AAAAAAAAABmlu -cHV0cwAKAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HIqBTsKLDtVe3u -rlF5pOfln0Cz+VUWEG6bwS5yGr9+VhwB9a78PJdE55ToYUqLRLW+xomcjBJGACUs -GxZwr3kocJMAAAAAAAAAAP8AAAAAAAAAC2Fzc2lnbm1lbnRzAAoCQzQDlNgbMOJS -KJAmHvNv+fioOVGR9QtpXiMqHrO3QcioFOwosO1V7e6uUXmk5+WfQLP5VRYQbpvB -LnIav35WHAH1rvw8l0TnlOhhSotEtb7GiZyMEkYAJSwbFnCveShwkwAAAAAAAAAA -/wAAAAAAAAAJdmFsZW5jaWVzAAoCQzQDlNgbMOJSKJAmHvNv+fioOVGR9QtpXiMq -HrO3QcioFOwosO1V7e6uUXmk5+WfQLP5VRYQbpvBLnIav35WHAH1rvw8l0TnlOhh -SotEtb7GiZyMEkYAJSwbFnCveShwkwAAAAAAAAAA/wAAAAAAAAAGZXJyb3JzAAkA -AAEAAAAAAAAAAP8AAAAAAAAAEWRlZmF1bHRBc3NpZ25tZW50AAQCAARub25lAAAA -AQRzb21lAAUBAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HIqBTsKLDt -Ve3urlF5pOfln0Cz+VUWEG6bwS5yGr9+VhwMVmFsZW5jeUlmYWNlBgIIcmVxdWly -ZWQCe4SAPJ764hElp3wsObxw0v3o+UOuDf2c9OaC7cdmynBhhiLRe67wZgLf53XJ -gOCza2666AkNgHX3UTvsS5P2TQhtdWx0aXBsZQJ7hIA8nvriESWnfCw5vHDS/ej5 -Q64N/Zz05oLtx2bKcGGGItF7rvBmAt/ndcmA4LNrbrroCQ2AdfdRO+xLk/ZNDFZl -bG9jaXR5SGludAMGC3Vuc3BlY2lmaWVkAAZzZWxkb20PCGVwaXNvZGljHwdyZWd1 -bGFyPwhmcmVxdWVudH8NaGlnaEZyZXF1ZW5jef8FVmVyTm8DAQJ2MQAIVm91dFNl -YWwGAwZtZXRob2QCFwZOaYm8ANN+QATAdalw1SQOh8fRNH4sG25uxi7AoTfSUjB8 -fXGQNfcwfugoJewbgSuhh92dmEmLSo0W+m7VQwR2b3V0Ak5OhPRwFsnl0mJ8v8P0 -NrLdbNTRubBEW/9e74J2cndXIeM+Q8WqXPIpJ1OjOMFn7TtjnE3Zzr2pjzRpF7rJ -Q3UIYmxpbmRpbmcAAAg= +s/lVFhBum8Euchq/flYcAaqtdYjLaCdZjSxxU4wl8imVeuq5C7j/0TeE1jFKCI0s +AAAAAAAAAAD/AAAAAAAAAAdnZW5lc2lzASNpvWqSdmEqNaymY1bzL6cUiPY34/2g +tew4zU1zFoCmC3RyYW5zaXRpb25zAAoCQzQDlNgbMOJSKJAmHvNv+fioOVGR9Qtp +XiMqHrO3QcgNFCNl8qSvxhtTbdRnVXJmK7Byo5APyYsAZorYMYDisAF5zxLjRkHD +iDCuiIHyyy1+egGm7lDFIoXHUR9OZvasigAAAAAAAAAA/wAAAAAAAAAKZXh0ZW5z +aW9ucwAKAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HIDRQjZfKkr8Yb +U23UZ1VyZiuwcqOQD8mLAGaK2DGA4rABXARol3TXWmIZKUzj7zcr2SRetB4ICeal +UuA4fSG4YHYAAAAAAAAAAP8AAAAAAAAACWVycm9yVHlwZQJDNAOU2Bsw4lIokCYe +82/5+Kg5UZH1C2leIyoes7dByGsEoxSeppUAFmef7wK0qyT15reKZMjZ0L1l/Nej +WE6NEGRlZmF1bHRPcGVyYXRpb24ABAIABG5vbmUAAAABBHNvbWUABQECQzQDlNgb +MOJSKJAmHvNv+fioOVGR9QtpXiMqHrO3QcgNFCNl8qSvxhtTbdRnVXJmK7Byo5AP +yYsAZorYMYDisAdJZmFjZUlkBQEABwAAQCAACUlmYWNlSW1wbAYIB3ZlcnNpb24B +FyXaBnd9Icdk2G/LAnrUzhVaYxYpaP/m+NddllDtH+EIc2NoZW1hSWQCNmC5zh/M +Pg6BcPmTBPBwcH2VBmz2QhpcNaeKum2IUKiUUtPbA6urqFGfp/Y+0BTr1E19MT/8 +/gD6XSR6VASQEAdpZmFjZUlkATvKwIEDCOErq1shaIeE47ZzpVfY5QAtdcabxbU/ +YqNxC2dsb2JhbFN0YXRlAAkBQDQxBa2vWUkJgiCwt9UQguoxcX1pwilASBtKDv8s +bZUAAAAAAAAAAP8AAAAAAAAAC2Fzc2lnbm1lbnRzAAkBQDQxBa2vWUkJgiCwt9UQ +guoxcX1pwilASBtKDv8sbZUAAAAAAAAAAP8AAAAAAAAACXZhbGVuY2llcwAJAUA0 +MQWtr1lJCYIgsLfVEILqMXF9acIpQEgbSg7/LG2VAAAAAAAAAAD/AAAAAAAAAAt0 +cmFuc2l0aW9ucwAJAXiYU6arGXXGdGin4R0gmHtT/sOJjEnOpBEuu4USxGImAAAA +AAAAAAD/AAAAAAAAAApleHRlbnNpb25zAAkBQDQxBa2vWUkJgiCwt9UQguoxcX1p +wilASBtKDv8sbZUAAAAAAAAAAP8AAAAAAAAACUlmYWNlUGFpcgYCBWlmYWNlAT8t +IA5wSJ8Aa8WYgGwa0CnZ7lEJvTJAMcJksDb9wCLSBWlpbXBsAcdOTMwGaSMthXcP +X3yqnFp4efoZ8zx26fVLDYJkfEo5BkltcGxJZAUBAAcAAEAgAA1OYW1lZEZpZWxk +dTE2BgICaWQAAAIEbmFtZQJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dB +yKgU7Ciw7VXt7q5ReaTn5Z9As/lVFhBum8Euchq/flYcDE5hbWVkVHlwZXUxNgYC +AmlkAAACBG5hbWUCQzQDlNgbMOJSKJAmHvNv+fioOVGR9QtpXiMqHrO3QcgNFCNl +8qSvxhtTbdRnVXJmK7Byo5APyYsAZorYMYDisApPd25lZElmYWNlBAYAA2FueQAA +AAEGcmlnaHRzAAAAAgZhbW91bnQAAAADB2FueURhdGEAAAAECWFueUF0dGFjaAAA +AAUEZGF0YQAFAQJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByGsEoxSe +ppUAFmef7wK0qyT15reKZMjZ0L1l/NejWE6ND093bmVkU3RhdGVTdXBwbAYCB21l +YW5pbmcACAABAAAAAAAAAAD/AAAAAAAAAAh2ZWxvY2l0eQEKDeoaDVCYetRy15wh +zIJ/oMtXqnhFMpLyQUwzh0gJAAdTdXBwbElkBQEABwAAQCAACFRlcm1pbmFsBgIF +c2VhbHMACQF5nx4MOPdsfuZCbbD4Dtv4jR7phV4RqQHlD5spnAsFUQAAAAAAAAAA +//8AAAAAAAACdHgABAIABG5vbmUAAAABBHNvbWUABQECTk6E9HAWyeXSYny/w/Q2 +st1s1NG5sERb/17vgnZyd1cpHE1sV7Pq+hEKgzSbYw8gYZUm8fzJ/CoxG/QoNvu+ +EAxUZXJtaW5hbFNlYWwEAgANY29uY2VhbGVkVXR4bwAFAQIXBk5pibwA035ABMB1 +qXDVJA6Hx9E0fiwbbm7GLsChN2gZ67zVsxirl7OYpUs2Zd3apwZv6Okk5wNgqZSz +vQZOAQt3aXRuZXNzVm91dAAFAQGt+AFDdAxLr3p1h4uBEAcGWYFcHSiVwBTAQUO6 +hp3r0wtUaWNrZXJTdXBwbAQDAAZhYnNlbnQAAAABBmdsb2JhbAAFAgAAAgJDNAOU +2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByNqamqop9exSJo8LUwsOizT8xK3k +s3urbgG9DUQNYWkgAgVvd25lZAAFAgAAAgJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1 +C2leIyoes7dByNqamqop9exSJo8LUwsOizT8xK3ks3urbgG9DUQNYWkgD1RyYW5z +aXRpb25JZmFjZQYICG9wdGlvbmFsAnuEgDye+uIRJad8LDm8cNL96PlDrg39nPTm +gu3HZspwYYYi0Xuu8GYC3+d1yYDgs2tuuugJDYB191E77EuT9k0IbWV0YWRhdGEA +BAIABG5vbmUAAAABBHNvbWUABQECQzQDlNgbMOJSKJAmHvNv+fioOVGR9QtpXiMq +HrO3QchrBKMUnqaVABZnn+8CtKsk9ea3imTI2dC9ZfzXo1hOjQdnbG9iYWxzAAoC +QzQDlNgbMOJSKJAmHvNv+fioOVGR9QtpXiMqHrO3QcioFOwosO1V7e6uUXmk5+Wf +QLP5VRYQbpvBLnIav35WHAH1rvw8l0TnlOhhSotEtb7GiZyMEkYAJSwbFnCveShw +kwAAAAAAAAAA/wAAAAAAAAAGaW5wdXRzAAoCQzQDlNgbMOJSKJAmHvNv+fioOVGR +9QtpXiMqHrO3QcioFOwosO1V7e6uUXmk5+WfQLP5VRYQbpvBLnIav35WHAH1rvw8 +l0TnlOhhSotEtb7GiZyMEkYAJSwbFnCveShwkwAAAAAAAAAA/wAAAAAAAAALYXNz +aWdubWVudHMACgJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByKgU7Ciw +7VXt7q5ReaTn5Z9As/lVFhBum8Euchq/flYcAfWu/DyXROeU6GFKi0S1vsaJnIwS +RgAlLBsWcK95KHCTAAAAAAAAAAD/AAAAAAAAAAl2YWxlbmNpZXMACgJDNAOU2Bsw +4lIokCYe82/5+Kg5UZH1C2leIyoes7dByKgU7Ciw7VXt7q5ReaTn5Z9As/lVFhBu +m8Euchq/flYcAfWu/DyXROeU6GFKi0S1vsaJnIwSRgAlLBsWcK95KHCTAAAAAAAA +AAD/AAAAAAAAAAZlcnJvcnMACQAAAQAAAAAAAAAA/wAAAAAAAAARZGVmYXVsdEFz +c2lnbm1lbnQABAIABG5vbmUAAAABBHNvbWUABQECQzQDlNgbMOJSKJAmHvNv+fio +OVGR9QtpXiMqHrO3QcioFOwosO1V7e6uUXmk5+WfQLP5VRYQbpvBLnIav35WHAxW +YWxlbmN5SWZhY2UGAghyZXF1aXJlZAJ7hIA8nvriESWnfCw5vHDS/ej5Q64N/Zz0 +5oLtx2bKcGGGItF7rvBmAt/ndcmA4LNrbrroCQ2AdfdRO+xLk/ZNCG11bHRpcGxl +AnuEgDye+uIRJad8LDm8cNL96PlDrg39nPTmgu3HZspwYYYi0Xuu8GYC3+d1yYDg +s2tuuugJDYB191E77EuT9k0MVmVsb2NpdHlIaW50AwYLdW5zcGVjaWZpZWQABnNl +bGRvbQ8IZXBpc29kaWMfB3JlZ3VsYXI/CGZyZXF1ZW50fw1oaWdoRnJlcXVlbmN5 +/wVWZXJObwMBAnYxAAhWb3V0U2VhbAYDBm1ldGhvZAIXBk5pibwA035ABMB1qXDV +JA6Hx9E0fiwbbm7GLsChN9JSMHx9cZA19zB+6Cgl7BuBK6GH3Z2YSYtKjRb6btVD +BHZvdXQCTk6E9HAWyeXSYny/w/Q2st1s1NG5sERb/17vgnZyd1ch4z5Dxapc8ikn +U6M4wWftO2OcTdnOvamPNGkXuslDdQhibGluZGluZwAACA== -----END STRICT TYPE LIB----- diff --git a/stl/RGBStd@0.1.0.stl b/stl/RGBStd@0.1.0.stl index d95536a74b386f37366275795b9676b651f3d49a..fce88f7aa062bac282a947ef3e5133596acc9a7f 100644 GIT binary patch delta 688 zcmX??z9?ry1+%X(1EXYatLBMsw_JQh{d(v0?48Ho+sPDVyG7gAIb7tF+cw$wXuX$c;-#6Vh&W+l=008-~8&A zAXl@=>|}n0#Hnf@|D61zWhnhc!|eAy0j7|O$)}lhf=zG9idrh8fIDpPB$j{6x*?fS-Scs8p@D1v3)|!{l$K3X`8Q8&0-l(V4u1C2(>LtLo(AtQwPL*t9nnuo(*}aWY1< zt9)K4Q1+|w(VL>Qoh3eAyN ^ ..0xff IfacePair} , supplements {ContractSuppl ^ ..0xff} , genesis RGB.Genesis {- SidePeoplePrivate09V1wj2QXbzHckbywWoHpmNysNKwU5ZNjAFFAm1wscuvo -} - , terminals {Terminal} + , terminals {RGB.BundleId -> Terminal} , bundles [RGB.AnchoredBundle {- AugustInfoEnigma03ETnGBHVsVniah6iRG7ofhk5BUmpvVwfVAVawoPXxaJQ -} ^ ..0xffffffff] , extensions [RGB.Extension {- PythonCastroEarth0CbL9bmsun7ik6S6scQdeLtBh7XS7oHMqJvV1tt4sUykw -} ^ ..0xffffffff] , attachments {RGB.AttachId -> [Byte ^ ..0xffffff]} , signatures {ContentId -> ^ ..0xff ContentSigs} --- AvenueSagaCamilla0B1Zkh6ZYFkJKmGwV9149bCwraDKypho3r2W5C7ddmHCP +-- BraveSparkRadar08oS1qHELsxasDN12CfLg7qXmf6vmHLfi4QZG8AtpcUF1 data Consignmenttrue :: version ContainerVer , transfer Std.Bool {- FashionSharpRodeo07ZhBHGSJm9ixmm8Z9vCX7i5Ga7j5xrW8t11nsb1Cgpnx -} , schema RGB.SchemaSchema {- HotelKarlBarbara07EHzDDj8E6STpb7ahNW1NdW7477NKCjmpQvXWJKr14dL -} , ifaces {IfaceId -> ^ ..0xff IfacePair} , supplements {ContractSuppl ^ ..0xff} , genesis RGB.Genesis {- SidePeoplePrivate09V1wj2QXbzHckbywWoHpmNysNKwU5ZNjAFFAm1wscuvo -} - , terminals {Terminal} + , terminals {RGB.BundleId -> Terminal} , bundles [RGB.AnchoredBundle {- AugustInfoEnigma03ETnGBHVsVniah6iRG7ofhk5BUmpvVwfVAVawoPXxaJQ -} ^ ..0xffffffff] , extensions [RGB.Extension {- PythonCastroEarth0CbL9bmsun7ik6S6scQdeLtBh7XS7oHMqJvV1tt4sUykw -} ^ ..0xffffffff] , attachments {RGB.AttachId -> [Byte ^ ..0xffffff]} @@ -250,8 +261,8 @@ data OwnedIface :: any () data OwnedStateSuppl :: meaning [Unicode ^ ..0xff], velocity VelocityHint -- JudoOliverAppear07wqgZas6f6Y7jWyDzLNxCeGEM8NXppB1f1gZNvNHJD72 data SupplId :: [Byte ^ 32] --- ModemGalleryCombat0855o8czxvHnWUC5EKkVJmNRGHW32c7y42FT39c358Umz -data Terminal :: bundleId RGB.BundleId {- RocketStockProtect0EbWt9bmnjLpAu1LCN78snx734kHLNVUxyb5YxNr8tjd -}, seal TerminalSeal +-- FormatMeteorQuarter0GuyF1LFJXz4QXx6ZCLMb4oUQx2EJUns6pEcF1QA89Bjq +data Terminal :: seals {TerminalSeal}, tx Bitcoin.Tx {- NirvanaIndexValue03mUkHyR4gPvDPa1XwwGoUQzEFKx8ESnf79L2QNxG1YjZ -}? -- InfantNoiseDynasty0JAifr7qtesSzZCMJ4Hymyb755CV1i7xxRPRNu6TKrUB7 data TerminalSeal :: concealedUtxo BPCore.SecretSeal {- VocalWinterMango081NKrdc9pBoBjsKaGBVN9wXLG4tKjkK4f8DLj7TNMZxh -} | witnessVout VoutSeal From 678c3a0007da1b157221b1488e7df9a0c342e97b Mon Sep 17 00:00:00 2001 From: Dr Maxim Orlovsky Date: Fri, 14 Jul 2023 20:18:56 +0200 Subject: [PATCH 2/5] containers: reserve place for value mapping scripts in iface impl Makes #78 backwards-compatible --- std/src/interface/iimpl.rs | 26 ++++++-- std/src/lib.rs | 2 + std/src/reserved.rs | 110 ++++++++++++++++++++++++++++++++++ std/src/stl/stl.rs | 3 +- stl/RGBStd@0.1.0.sta | 118 +++++++++++++++++++------------------ stl/RGBStd@0.1.0.stl | Bin 13858 -> 14039 bytes stl/RGBStd@0.1.0.sty | 19 ++++-- 7 files changed, 209 insertions(+), 69 deletions(-) create mode 100644 std/src/reserved.rs diff --git a/std/src/interface/iimpl.rs b/std/src/interface/iimpl.rs index baea9e84..900e1c32 100644 --- a/std/src/interface/iimpl.rs +++ b/std/src/interface/iimpl.rs @@ -26,7 +26,7 @@ use amplify::{Bytes32, RawArray}; use baid58::{Baid58ParseError, FromBaid58, ToBaid58}; use commit_verify::{CommitStrategy, CommitmentId}; use rgb::{ - AssignmentType, ExtensionType, GlobalStateType, SchemaId, SchemaTypeIndex, SubSchema, + AssignmentType, ExtensionType, GlobalStateType, SchemaId, SchemaTypeIndex, Script, SubSchema, TransitionType, ValencyType, }; use strict_encoding::{FieldName, TypeName}; @@ -36,7 +36,7 @@ use strict_types::encoding::{ use crate::interface::iface::IfaceId; use crate::interface::{Iface, VerNo}; -use crate::LIB_NAME_RGB_STD; +use crate::{ReservedBytes, LIB_NAME_RGB_STD}; /// Interface identifier. /// @@ -89,6 +89,9 @@ impl FromStr for ImplId { pub struct NamedField { pub id: T, pub name: FieldName, + /// Reserved bytes for storing information about value transformation + /// procedures + pub reserved: ReservedBytes<0u8, 4usize>, } impl PartialEq for NamedField @@ -98,7 +101,13 @@ where T: SchemaTypeIndex } impl NamedField { - pub fn with(id: T, name: FieldName) -> NamedField { NamedField { id, name } } + pub fn with(id: T, name: FieldName) -> NamedField { + NamedField { + id, + name, + reserved: default!(), + } + } } /// Maps operation numeric type id to a human-readable name. @@ -116,6 +125,8 @@ impl NamedField { pub struct NamedType { pub id: T, pub name: TypeName, + /// Reserved bytes for storing information about adaptor procedures + pub reserved: ReservedBytes<0, 4>, } impl PartialEq for NamedType @@ -125,7 +136,13 @@ where T: SchemaTypeIndex } impl NamedType { - pub fn with(id: T, name: TypeName) -> NamedType { NamedType { id, name } } + pub fn with(id: T, name: TypeName) -> NamedType { + NamedType { + id, + name, + reserved: default!(), + } + } } #[derive(Clone, Eq, PartialEq, Debug)] @@ -158,6 +175,7 @@ pub struct IfaceImpl { pub version: VerNo, pub schema_id: SchemaId, pub iface_id: IfaceId, + pub script: Script, pub global_state: TinyOrdSet>, pub assignments: TinyOrdSet>, pub valencies: TinyOrdSet>, diff --git a/std/src/lib.rs b/std/src/lib.rs index e954cb12..9289446a 100644 --- a/std/src/lib.rs +++ b/std/src/lib.rs @@ -84,6 +84,8 @@ pub mod containers; pub mod persistence; pub mod resolvers; pub mod accessors; +mod reserved; pub use bp::{Chain, Outpoint, Txid}; +use reserved::ReservedBytes; pub use stl::{LIB_NAME_RGB_CONTRACT, LIB_NAME_RGB_STD}; diff --git a/std/src/reserved.rs b/std/src/reserved.rs new file mode 100644 index 00000000..d3953831 --- /dev/null +++ b/std/src/reserved.rs @@ -0,0 +1,110 @@ +// 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 +// +// 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 amplify::hex::ToHex; +use amplify::Wrapper; +use strict_encoding::{DecodeError, StrictDecode, TypedRead}; + +use crate::LIB_NAME_RGB_STD; + +#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug)] +#[derive(StrictType, StrictEncode)] +#[strict_type(lib = LIB_NAME_RGB_STD)] +pub struct ReservedBytes([u8; LEN]); + +impl Wrapper for ReservedBytes { + type Inner = [u8; LEN]; + fn from_inner(inner: Self::Inner) -> Self { Self::from(inner) } + fn as_inner(&self) -> &Self::Inner { &self.0 } + fn into_inner(self) -> Self::Inner { self.0 } +} + +impl From<[u8; LEN]> for ReservedBytes { + fn from(value: [u8; LEN]) -> Self { + assert_eq!(value, [VAL; LEN]); + Self(value) + } +} + +impl Default for ReservedBytes { + fn default() -> Self { ReservedBytes([VAL; LEN]) } +} + +impl StrictDecode for ReservedBytes { + fn strict_decode(reader: &mut impl TypedRead) -> Result { + let me = reader.read_newtype::()?; + if me.0 != [VAL; LEN] { + return Err(DecodeError::DataIntegrityError(format!( + "reserved bytes required to have value [{VAL}; {LEN}] while {} was found", + me.0.to_hex() + ))); + } else { + Ok(me) + } + } +} + +#[cfg(feature = "serde")] +mod _serde { + use std::fmt; + + use serde_crate::de::Visitor; + use serde_crate::{de, Deserialize, Deserializer, Serialize, Serializer}; + + use super::*; + + impl Serialize for ReservedBytes { + fn serialize(&self, serializer: S) -> Result + where S: Serializer { + // Doing nothing + serializer.serialize_unit() + } + } + + impl<'de, const VAL: u8, const LEN: usize> Deserialize<'de> for ReservedBytes { + fn deserialize(deserializer: D) -> Result + where D: Deserializer<'de> { + #[derive(Default)] + pub struct UntaggedUnitVisitor; + + impl<'de> Visitor<'de> for UntaggedUnitVisitor { + type Value = (); + + fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + write!(formatter, "reserved unit") + } + + fn visit_none(self) -> Result<(), E> + where E: de::Error { + Ok(()) + } + + fn visit_unit(self) -> Result<(), E> + where E: de::Error { + Ok(()) + } + } + + let _: () = deserializer.deserialize_unit(UntaggedUnitVisitor::default())?; + Ok(default!()) + } + } +} diff --git a/std/src/stl/stl.rs b/std/src/stl/stl.rs index 90272286..354f8b84 100644 --- a/std/src/stl/stl.rs +++ b/std/src/stl/stl.rs @@ -41,8 +41,7 @@ pub const LIB_ID_RGB_CONTRACT: &str = "price_canvas_oliver_9Te5P6nq3oaDHMgttLEbkojbeQPTqqZLhjxZ3my1F8aJ"; /// Strict types id for the library representing of RGB StdLib data types. -pub const LIB_ID_RGB_STD: &str = - "joel_penguin_service_BmH4kCeEWYJSWVEC2rscH6SiFCyZQN178zngNof4RZxH"; +pub const LIB_ID_RGB_STD: &str = "transit_fish_igor_E1JiPWTEmHkBEJsEfy12zScfUznkiPKe7UkgA7NEh89v"; fn _rgb_std_stl() -> Result { LibBuilder::new(libname!(LIB_NAME_RGB_STD), tiny_bset! { diff --git a/stl/RGBStd@0.1.0.sta b/stl/RGBStd@0.1.0.sta index 97167f1e..60b06b19 100644 --- a/stl/RGBStd@0.1.0.sta +++ b/stl/RGBStd@0.1.0.sta @@ -1,5 +1,5 @@ -----BEGIN STRICT TYPE LIB----- -Id: joel_penguin_service_BmH4kCeEWYJSWVEC2rscH6SiFCyZQN178zngNof4RZxH +Id: transit_fish_igor_E1JiPWTEmHkBEJsEfy12zScfUznkiPKe7UkgA7NEh89v Name: RGBStd Dependencies: CommitVerify@melody_arctic_labor_ZtHaBzu9ojbDahaGKEXe5v9DfSDxLERbLkEB23R6Q6V, @@ -121,7 +121,7 @@ ZGVudIHTLCTXw+gy2cNi/cj0j5CdP4covDJOTeRMoeGJmxkGBlNpemluZ6gU7Ciw 7VXt7q5ReaTn5Z9As/lVFhBum8Euchq/flYcCUZpZWxkTmFtZcShkIbP+jC31l3c agcNx6ffoklMIJwage5+Oalex38SB0tleVN0ZXDampqqKfXsUiaPC1MLDos0/MSt 5LN7q24BvQ1EDWFpIARQYXRo20nblg5FA0FMs2uJwqVmkfs3IAVPeyHjHJTBHu9g -tlYEU3RlcCAAB0FyZ1NwZWMGAgRuYW1lAAQCAARub25lAAAAAQRzb21lAAUBAkM0 +tlYEU3RlcCEAB0FyZ1NwZWMGAgRuYW1lAAQCAARub25lAAAAAQRzb21lAAUBAkM0 A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HIqBTsKLDtVe3urlF5pOfln0Cz +VUWEG6bwS5yGr9+VhwDcmVxAjZguc4fzD4OgXD5kwTwcHB9lQZs9kIaXDWnirpt iFCoNsE0ofqggROn3TCAPF6w8sL92hSw1aPWk8Nung8yqnkLQXNzaWduSWZhY2UG @@ -137,7 +137,7 @@ e1M11sTXJBlN0AGq7hmss25XuQh0cmFuc2ZlcgJ7hIA8nvriESWnfCw5vHDS/ej5 Q64N/Zz05oLtx2bKcGGGItF7rvBmAt/ndcmA4LNrbrroCQ2AdfdRO+xLk/ZNBnNj aGVtYQI2YLnOH8w+DoFw+ZME8HBwfZUGbPZCGlw1p4q6bYhQqFyN4O8vFPYM3fDQ ZJKlRfyCFk8X+Wqtsd4qaHOo6OO3BmlmYWNlcwAKATvKwIEDCOErq1shaIeE47Zz -pVfY5QAtdcabxbU/YqNxAb7MEtJmO2J6XwXH2PKa1m0q21GJK1umyeRh/eExiDXF +pVfY5QAtdcabxbU/YqNxAXuXPhRLwTcTYhHv/CvTf1qFkY2hRBT+aQ5sT1xzoj/c AAAAAAAAAAD/AAAAAAAAAAtzdXBwbGVtZW50cwAJAcEKD4o0jKPLZIcLZ+8rQS7R Fu4Bzepaxt6Fsq8NxdhqAAAAAAAAAAD/AAAAAAAAAAdnZW5lc2lzAjZguc4fzD4O gXD5kwTwcHB9lQZs9kIaXDWnirptiFCofgrTLZIN4UnOVbx619Sx8P2CV8xefXmG @@ -157,7 +157,7 @@ JBlN0AGq7hmss25XuQh0cmFuc2ZlcgJ7hIA8nvriESWnfCw5vHDS/ej5Q64N/Zz0 5oLtx2bKcGGGItF7rvBmAt/ndcmA4LNrbrroCQ2AdfdRO+xLk/ZNBnNjaGVtYQI2 YLnOH8w+DoFw+ZME8HBwfZUGbPZCGlw1p4q6bYhQqFyN4O8vFPYM3fDQZJKlRfyC Fk8X+Wqtsd4qaHOo6OO3BmlmYWNlcwAKATvKwIEDCOErq1shaIeE47ZzpVfY5QAt -dcabxbU/YqNxAb7MEtJmO2J6XwXH2PKa1m0q21GJK1umyeRh/eExiDXFAAAAAAAA +dcabxbU/YqNxAXuXPhRLwTcTYhHv/CvTf1qFkY2hRBT+aQ5sT1xzoj/cAAAAAAAA AAD/AAAAAAAAAAtzdXBwbGVtZW50cwAJAcEKD4o0jKPLZIcLZ+8rQS7RFu4Bzepa xt6Fsq8NxdhqAAAAAAAAAAD/AAAAAAAAAAdnZW5lc2lzAjZguc4fzD4OgXD5kwTw cHB9lQZs9kIaXDWnirptiFCofgrTLZIN4UnOVbx619Sx8P2CV8xefXmGPj1yrD2c @@ -241,64 +241,68 @@ UuA4fSG4YHYAAAAAAAAAAP8AAAAAAAAACWVycm9yVHlwZQJDNAOU2Bsw4lIokCYe 82/5+Kg5UZH1C2leIyoes7dByGsEoxSeppUAFmef7wK0qyT15reKZMjZ0L1l/Nej WE6NEGRlZmF1bHRPcGVyYXRpb24ABAIABG5vbmUAAAABBHNvbWUABQECQzQDlNgb MOJSKJAmHvNv+fioOVGR9QtpXiMqHrO3QcgNFCNl8qSvxhtTbdRnVXJmK7Byo5AP -yYsAZorYMYDisAdJZmFjZUlkBQEABwAAQCAACUlmYWNlSW1wbAYIB3ZlcnNpb24B +yYsAZorYMYDisAdJZmFjZUlkBQEABwAAQCAACUlmYWNlSW1wbAYJB3ZlcnNpb24B FyXaBnd9Icdk2G/LAnrUzhVaYxYpaP/m+NddllDtH+EIc2NoZW1hSWQCNmC5zh/M Pg6BcPmTBPBwcH2VBmz2QhpcNaeKum2IUKiUUtPbA6urqFGfp/Y+0BTr1E19MT/8 /gD6XSR6VASQEAdpZmFjZUlkATvKwIEDCOErq1shaIeE47ZzpVfY5QAtdcabxbU/ -YqNxC2dsb2JhbFN0YXRlAAkBQDQxBa2vWUkJgiCwt9UQguoxcX1pwilASBtKDv8s -bZUAAAAAAAAAAP8AAAAAAAAAC2Fzc2lnbm1lbnRzAAkBQDQxBa2vWUkJgiCwt9UQ -guoxcX1pwilASBtKDv8sbZUAAAAAAAAAAP8AAAAAAAAACXZhbGVuY2llcwAJAUA0 -MQWtr1lJCYIgsLfVEILqMXF9acIpQEgbSg7/LG2VAAAAAAAAAAD/AAAAAAAAAAt0 -cmFuc2l0aW9ucwAJAXiYU6arGXXGdGin4R0gmHtT/sOJjEnOpBEuu4USxGImAAAA -AAAAAAD/AAAAAAAAAApleHRlbnNpb25zAAkBQDQxBa2vWUkJgiCwt9UQguoxcX1p -wilASBtKDv8sbZUAAAAAAAAAAP8AAAAAAAAACUlmYWNlUGFpcgYCBWlmYWNlAT8t -IA5wSJ8Aa8WYgGwa0CnZ7lEJvTJAMcJksDb9wCLSBWlpbXBsAcdOTMwGaSMthXcP -X3yqnFp4efoZ8zx26fVLDYJkfEo5BkltcGxJZAUBAAcAAEAgAA1OYW1lZEZpZWxk -dTE2BgICaWQAAAIEbmFtZQJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dB -yKgU7Ciw7VXt7q5ReaTn5Z9As/lVFhBum8Euchq/flYcDE5hbWVkVHlwZXUxNgYC -AmlkAAACBG5hbWUCQzQDlNgbMOJSKJAmHvNv+fioOVGR9QtpXiMqHrO3QcgNFCNl -8qSvxhtTbdRnVXJmK7Byo5APyYsAZorYMYDisApPd25lZElmYWNlBAYAA2FueQAA -AAEGcmlnaHRzAAAAAgZhbW91bnQAAAADB2FueURhdGEAAAAECWFueUF0dGFjaAAA -AAUEZGF0YQAFAQJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByGsEoxSe -ppUAFmef7wK0qyT15reKZMjZ0L1l/NejWE6ND093bmVkU3RhdGVTdXBwbAYCB21l -YW5pbmcACAABAAAAAAAAAAD/AAAAAAAAAAh2ZWxvY2l0eQEKDeoaDVCYetRy15wh -zIJ/oMtXqnhFMpLyQUwzh0gJAAdTdXBwbElkBQEABwAAQCAACFRlcm1pbmFsBgIF -c2VhbHMACQF5nx4MOPdsfuZCbbD4Dtv4jR7phV4RqQHlD5spnAsFUQAAAAAAAAAA -//8AAAAAAAACdHgABAIABG5vbmUAAAABBHNvbWUABQECTk6E9HAWyeXSYny/w/Q2 -st1s1NG5sERb/17vgnZyd1cpHE1sV7Pq+hEKgzSbYw8gYZUm8fzJ/CoxG/QoNvu+ -EAxUZXJtaW5hbFNlYWwEAgANY29uY2VhbGVkVXR4bwAFAQIXBk5pibwA035ABMB1 -qXDVJA6Hx9E0fiwbbm7GLsChN2gZ67zVsxirl7OYpUs2Zd3apwZv6Okk5wNgqZSz -vQZOAQt3aXRuZXNzVm91dAAFAQGt+AFDdAxLr3p1h4uBEAcGWYFcHSiVwBTAQUO6 -hp3r0wtUaWNrZXJTdXBwbAQDAAZhYnNlbnQAAAABBmdsb2JhbAAFAgAAAgJDNAOU -2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByNqamqop9exSJo8LUwsOizT8xK3k -s3urbgG9DUQNYWkgAgVvd25lZAAFAgAAAgJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1 -C2leIyoes7dByNqamqop9exSJo8LUwsOizT8xK3ks3urbgG9DUQNYWkgD1RyYW5z -aXRpb25JZmFjZQYICG9wdGlvbmFsAnuEgDye+uIRJad8LDm8cNL96PlDrg39nPTm -gu3HZspwYYYi0Xuu8GYC3+d1yYDgs2tuuugJDYB191E77EuT9k0IbWV0YWRhdGEA -BAIABG5vbmUAAAABBHNvbWUABQECQzQDlNgbMOJSKJAmHvNv+fioOVGR9QtpXiMq -HrO3QchrBKMUnqaVABZnn+8CtKsk9ea3imTI2dC9ZfzXo1hOjQdnbG9iYWxzAAoC +YqNxBnNjcmlwdAI2YLnOH8w+DoFw+ZME8HBwfZUGbPZCGlw1p4q6bYhQqMYYY3tn +TQy0vKnAQ11/MmKDmHhzdCdD0TflRPu6EtBMC2dsb2JhbFN0YXRlAAkBWZ7tup4H +Tq1L68fK4XeVoJPQp10tciLuYXVXq51QP0QAAAAAAAAAAP8AAAAAAAAAC2Fzc2ln +bm1lbnRzAAkBWZ7tup4HTq1L68fK4XeVoJPQp10tciLuYXVXq51QP0QAAAAAAAAA +AP8AAAAAAAAACXZhbGVuY2llcwAJAVme7bqeB06tS+vHyuF3laCT0KddLXIi7mF1 +V6udUD9EAAAAAAAAAAD/AAAAAAAAAAt0cmFuc2l0aW9ucwAJAW/01QyDWhrgxJ5r +m/LSqgPKo+NsZvd8cwXIOdds9kexAAAAAAAAAAD/AAAAAAAAAApleHRlbnNpb25z +AAkBWZ7tup4HTq1L68fK4XeVoJPQp10tciLuYXVXq51QP0QAAAAAAAAAAP8AAAAA +AAAACUlmYWNlUGFpcgYCBWlmYWNlAT8tIA5wSJ8Aa8WYgGwa0CnZ7lEJvTJAMcJk +sDb9wCLSBWlpbXBsAWdqdsw4S3x7w9cmZ0pmzmGtGuHNnGw0Lo+L6SUF22UABklt +cGxJZAUBAAcAAEAgAA1OYW1lZEZpZWxkdTE2BgMCaWQAAAIEbmFtZQJDNAOU2Bsw +4lIokCYe82/5+Kg5UZH1C2leIyoes7dByKgU7Ciw7VXt7q5ReaTn5Z9As/lVFhBu +m8Euchq/flYcCHJlc2VydmVkAT+XOjKLmMYC/yYZn0at0bWQZwQSbO1IvYTZXKgJ +DdHMDE5hbWVkVHlwZXUxNgYDAmlkAAACBG5hbWUCQzQDlNgbMOJSKJAmHvNv+fio +OVGR9QtpXiMqHrO3QcgNFCNl8qSvxhtTbdRnVXJmK7Byo5APyYsAZorYMYDisAhy +ZXNlcnZlZAE/lzoyi5jGAv8mGZ9GrdG1kGcEEmztSL2E2VyoCQ3RzApPd25lZElm +YWNlBAYAA2FueQAAAAEGcmlnaHRzAAAAAgZhbW91bnQAAAADB2FueURhdGEAAAAE +CWFueUF0dGFjaAAAAAUEZGF0YQAFAQJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2le +Iyoes7dByGsEoxSeppUAFmef7wK0qyT15reKZMjZ0L1l/NejWE6ND093bmVkU3Rh +dGVTdXBwbAYCB21lYW5pbmcACAABAAAAAAAAAAD/AAAAAAAAAAh2ZWxvY2l0eQEK +DeoaDVCYetRy15whzIJ/oMtXqnhFMpLyQUwzh0gJAA9SZXNlcnZlZEJ5dGVzMDQF +AQAHAABABAAHU3VwcGxJZAUBAAcAAEAgAAhUZXJtaW5hbAYCBXNlYWxzAAkBeZ8e +DDj3bH7mQm2w+A7b+I0e6YVeEakB5Q+bKZwLBVEAAAAAAAAAAP//AAAAAAAAAnR4 +AAQCAARub25lAAAAAQRzb21lAAUBAk5OhPRwFsnl0mJ8v8P0NrLdbNTRubBEW/9e +74J2cndXKRxNbFez6voRCoM0m2MPIGGVJvH8yfwqMRv0KDb7vhAMVGVybWluYWxT +ZWFsBAIADWNvbmNlYWxlZFV0eG8ABQECFwZOaYm8ANN+QATAdalw1SQOh8fRNH4s +G25uxi7AoTdoGeu81bMYq5ezmKVLNmXd2qcGb+jpJOcDYKmUs70GTgELd2l0bmVz +c1ZvdXQABQEBrfgBQ3QMS696dYeLgRAHBlmBXB0olcAUwEFDuoad69MLVGlja2Vy +U3VwcGwEAwAGYWJzZW50AAAAAQZnbG9iYWwABQIAAAICQzQDlNgbMOJSKJAmHvNv ++fioOVGR9QtpXiMqHrO3QcjampqqKfXsUiaPC1MLDos0/MSt5LN7q24BvQ1EDWFp +IAIFb3duZWQABQIAAAICQzQDlNgbMOJSKJAmHvNv+fioOVGR9QtpXiMqHrO3Qcja +mpqqKfXsUiaPC1MLDos0/MSt5LN7q24BvQ1EDWFpIA9UcmFuc2l0aW9uSWZhY2UG +CAhvcHRpb25hbAJ7hIA8nvriESWnfCw5vHDS/ej5Q64N/Zz05oLtx2bKcGGGItF7 +rvBmAt/ndcmA4LNrbrroCQ2AdfdRO+xLk/ZNCG1ldGFkYXRhAAQCAARub25lAAAA +AQRzb21lAAUBAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HIawSjFJ6m +lQAWZ5/vArSrJPXmt4pkyNnQvWX816NYTo0HZ2xvYmFscwAKAkM0A5TYGzDiUiiQ +Jh7zb/n4qDlRkfULaV4jKh6zt0HIqBTsKLDtVe3urlF5pOfln0Cz+VUWEG6bwS5y +Gr9+VhwB9a78PJdE55ToYUqLRLW+xomcjBJGACUsGxZwr3kocJMAAAAAAAAAAP8A +AAAAAAAABmlucHV0cwAKAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6zt0HI +qBTsKLDtVe3urlF5pOfln0Cz+VUWEG6bwS5yGr9+VhwB9a78PJdE55ToYUqLRLW+ +xomcjBJGACUsGxZwr3kocJMAAAAAAAAAAP8AAAAAAAAAC2Fzc2lnbm1lbnRzAAoC QzQDlNgbMOJSKJAmHvNv+fioOVGR9QtpXiMqHrO3QcioFOwosO1V7e6uUXmk5+Wf QLP5VRYQbpvBLnIav35WHAH1rvw8l0TnlOhhSotEtb7GiZyMEkYAJSwbFnCveShw -kwAAAAAAAAAA/wAAAAAAAAAGaW5wdXRzAAoCQzQDlNgbMOJSKJAmHvNv+fioOVGR -9QtpXiMqHrO3QcioFOwosO1V7e6uUXmk5+WfQLP5VRYQbpvBLnIav35WHAH1rvw8 -l0TnlOhhSotEtb7GiZyMEkYAJSwbFnCveShwkwAAAAAAAAAA/wAAAAAAAAALYXNz -aWdubWVudHMACgJDNAOU2Bsw4lIokCYe82/5+Kg5UZH1C2leIyoes7dByKgU7Ciw -7VXt7q5ReaTn5Z9As/lVFhBum8Euchq/flYcAfWu/DyXROeU6GFKi0S1vsaJnIwS -RgAlLBsWcK95KHCTAAAAAAAAAAD/AAAAAAAAAAl2YWxlbmNpZXMACgJDNAOU2Bsw -4lIokCYe82/5+Kg5UZH1C2leIyoes7dByKgU7Ciw7VXt7q5ReaTn5Z9As/lVFhBu -m8Euchq/flYcAfWu/DyXROeU6GFKi0S1vsaJnIwSRgAlLBsWcK95KHCTAAAAAAAA -AAD/AAAAAAAAAAZlcnJvcnMACQAAAQAAAAAAAAAA/wAAAAAAAAARZGVmYXVsdEFz -c2lnbm1lbnQABAIABG5vbmUAAAABBHNvbWUABQECQzQDlNgbMOJSKJAmHvNv+fio -OVGR9QtpXiMqHrO3QcioFOwosO1V7e6uUXmk5+WfQLP5VRYQbpvBLnIav35WHAxW -YWxlbmN5SWZhY2UGAghyZXF1aXJlZAJ7hIA8nvriESWnfCw5vHDS/ej5Q64N/Zz0 -5oLtx2bKcGGGItF7rvBmAt/ndcmA4LNrbrroCQ2AdfdRO+xLk/ZNCG11bHRpcGxl -AnuEgDye+uIRJad8LDm8cNL96PlDrg39nPTmgu3HZspwYYYi0Xuu8GYC3+d1yYDg -s2tuuugJDYB191E77EuT9k0MVmVsb2NpdHlIaW50AwYLdW5zcGVjaWZpZWQABnNl -bGRvbQ8IZXBpc29kaWMfB3JlZ3VsYXI/CGZyZXF1ZW50fw1oaWdoRnJlcXVlbmN5 -/wVWZXJObwMBAnYxAAhWb3V0U2VhbAYDBm1ldGhvZAIXBk5pibwA035ABMB1qXDV -JA6Hx9E0fiwbbm7GLsChN9JSMHx9cZA19zB+6Cgl7BuBK6GH3Z2YSYtKjRb6btVD -BHZvdXQCTk6E9HAWyeXSYny/w/Q2st1s1NG5sERb/17vgnZyd1ch4z5Dxapc8ikn -U6M4wWftO2OcTdnOvamPNGkXuslDdQhibGluZGluZwAACA== +kwAAAAAAAAAA/wAAAAAAAAAJdmFsZW5jaWVzAAoCQzQDlNgbMOJSKJAmHvNv+fio +OVGR9QtpXiMqHrO3QcioFOwosO1V7e6uUXmk5+WfQLP5VRYQbpvBLnIav35WHAH1 +rvw8l0TnlOhhSotEtb7GiZyMEkYAJSwbFnCveShwkwAAAAAAAAAA/wAAAAAAAAAG +ZXJyb3JzAAkAAAEAAAAAAAAAAP8AAAAAAAAAEWRlZmF1bHRBc3NpZ25tZW50AAQC +AARub25lAAAAAQRzb21lAAUBAkM0A5TYGzDiUiiQJh7zb/n4qDlRkfULaV4jKh6z +t0HIqBTsKLDtVe3urlF5pOfln0Cz+VUWEG6bwS5yGr9+VhwMVmFsZW5jeUlmYWNl +BgIIcmVxdWlyZWQCe4SAPJ764hElp3wsObxw0v3o+UOuDf2c9OaC7cdmynBhhiLR +e67wZgLf53XJgOCza2666AkNgHX3UTvsS5P2TQhtdWx0aXBsZQJ7hIA8nvriESWn +fCw5vHDS/ej5Q64N/Zz05oLtx2bKcGGGItF7rvBmAt/ndcmA4LNrbrroCQ2AdfdR +O+xLk/ZNDFZlbG9jaXR5SGludAMGC3Vuc3BlY2lmaWVkAAZzZWxkb20PCGVwaXNv +ZGljHwdyZWd1bGFyPwhmcmVxdWVudH8NaGlnaEZyZXF1ZW5jef8FVmVyTm8DAQJ2 +MQAIVm91dFNlYWwGAwZtZXRob2QCFwZOaYm8ANN+QATAdalw1SQOh8fRNH4sG25u +xi7AoTfSUjB8fXGQNfcwfugoJewbgSuhh92dmEmLSo0W+m7VQwR2b3V0Ak5OhPRw +Fsnl0mJ8v8P0NrLdbNTRubBEW/9e74J2cndXIeM+Q8WqXPIpJ1OjOMFn7TtjnE3Z +zr2pjzRpF7rJQ3UIYmxpbmRpbmcAAAg= -----END STRICT TYPE LIB----- diff --git a/stl/RGBStd@0.1.0.stl b/stl/RGBStd@0.1.0.stl index fce88f7aa062bac282a947ef3e5133596acc9a7f..c77428f79cbacbd6bfba0ac3f4f68906af1e81b4 100644 GIT binary patch delta 505 zcmZ3Kb3J#%brD9z%{N3im=&t0+lhD|G#5@1eE&!La(z_m#NLH2BL6b^a{Ob87unz0 zBr%H^MT?j=$H+F0nLx_1pk^m&tu9vPwiKYt)fdAZXS;9eIWP zFIRb*qof`jnU_8L)1_6+rxriXN&8+?%zDD|dd@fZjg#Lg$Pi`88{goObl7qu8;KOY*N^;{i;CI zE5pLt%tM+E9@1WX|8;VwPF`p%t3-q{MH6Xal(Ff`D^$z~Ubb4Y^jJy8@`thtGpd9C z9q#P$JhwzpZ+ENEktDUr?-XQ+F{@eEOX0Ym&l$E%W!=_t{`i_zbD}CLe@T9}DSP?V zo3|;Y#>;Z@TU~iZrpdf|KKwj>iMgpMA(aKGrG{o~ATgcE`}7nhbLc Date: Fri, 14 Jul 2023 20:33:25 +0200 Subject: [PATCH 3/5] iface: add type system. Addresses #79 --- std/src/interface/iface.rs | 3 +- std/src/interface/rgb20.rs | 1 + std/src/interface/rgb21.rs | 1 + std/src/interface/rgb25.rs | 1 + std/src/stl/stl.rs | 2 +- std/tests/data/rgb20.rgba | 178 +++++++++++++++++++++++++++++- std/tests/data/rgb21.rgba | 219 ++++++++++++++++++++++++++++++++++++- std/tests/data/rgb25.rgba | 177 +++++++++++++++++++++++++++++- 8 files changed, 573 insertions(+), 9 deletions(-) diff --git a/std/src/interface/iface.rs b/std/src/interface/iface.rs index b324048c..13d6bc7b 100644 --- a/std/src/interface/iface.rs +++ b/std/src/interface/iface.rs @@ -31,7 +31,7 @@ use strict_encoding::{ FieldName, StrictDecode, StrictDeserialize, StrictDumb, StrictEncode, StrictSerialize, StrictType, TypeName, }; -use strict_types::SemId; +use strict_types::{SemId, TypeSystem}; use crate::interface::VerNo; use crate::LIB_NAME_RGB_STD; @@ -327,6 +327,7 @@ pub struct Iface { pub extensions: TinyOrdMap, pub error_type: SemId, pub default_operation: Option, + pub type_system: TypeSystem, } impl PartialEq for Iface { diff --git a/std/src/interface/rgb20.rs b/std/src/interface/rgb20.rs index 8aee590a..fed25e87 100644 --- a/std/src/interface/rgb20.rs +++ b/std/src/interface/rgb20.rs @@ -226,6 +226,7 @@ pub fn rgb20() -> Iface { extensions: none!(), error_type: types.get("RGB20.Error"), default_operation: Some(tn!("Transfer")), + type_system: types.type_system(), } } diff --git a/std/src/interface/rgb21.rs b/std/src/interface/rgb21.rs index 84a4aecd..696f7b41 100644 --- a/std/src/interface/rgb21.rs +++ b/std/src/interface/rgb21.rs @@ -399,6 +399,7 @@ pub fn rgb21() -> Iface { extensions: none!(), error_type: types.get("RGB21.Error"), default_operation: Some(tn!("Transfer")), + type_system: types.type_system(), } } diff --git a/std/src/interface/rgb25.rs b/std/src/interface/rgb25.rs index da96b629..7c0bb806 100644 --- a/std/src/interface/rgb25.rs +++ b/std/src/interface/rgb25.rs @@ -151,6 +151,7 @@ pub fn rgb25() -> Iface { extensions: none!(), error_type: types.get("RGB25.Error"), default_operation: Some(tn!("Transfer")), + type_system: types.type_system(), } } diff --git a/std/src/stl/stl.rs b/std/src/stl/stl.rs index 354f8b84..a3a863ff 100644 --- a/std/src/stl/stl.rs +++ b/std/src/stl/stl.rs @@ -41,7 +41,7 @@ pub const LIB_ID_RGB_CONTRACT: &str = "price_canvas_oliver_9Te5P6nq3oaDHMgttLEbkojbeQPTqqZLhjxZ3my1F8aJ"; /// Strict types id for the library representing of RGB StdLib data types. -pub const LIB_ID_RGB_STD: &str = "transit_fish_igor_E1JiPWTEmHkBEJsEfy12zScfUznkiPKe7UkgA7NEh89v"; +pub const LIB_ID_RGB_STD: &str = "inca_hand_city_7kuGjzCd8CYWU3XJd5LoCswYjXd7oPWqvXXC2PmpSA8r"; fn _rgb_std_stl() -> Result { LibBuilder::new(libname!(LIB_NAME_RGB_STD), tiny_bset! { diff --git a/std/tests/data/rgb20.rgba b/std/tests/data/rgb20.rgba index b376226a..a828f65d 100644 --- a/std/tests/data/rgb20.rgba +++ b/std/tests/data/rgb20.rgba @@ -1,5 +1,5 @@ -----BEGIN RGB INTERFACE----- -Id: 4CXiewut3xPYxYusN3PhwjawdLnMhZw7hpiVSJUcCHaU +Id: 9Lnb2L6MmCmuiRUqfbiwVtp3NErR6eR5kLX7q3NQDAXW Name: RGB20 AAVSR0IyMAYMYnVybmVkU3VwcGx5AYiMWGVjOvE7lbfNGo2K8trB3BQLl3JR2dTa @@ -27,7 +27,179 @@ AQ5yZXBsYWNlZFN1cHBseQABAAEAAQR1c2VkAQlidXJuUmlnaHQBAAEAAgtiZW5l ZmljaWFyeQEKYXNzZXRPd25lcgAA//8GZnV0dXJlAQlidXJuUmlnaHQAAAEAAAQB AgMFAQtiZW5lZmljaWFyeQhUcmFuc2ZlcgAAAAEIcHJldmlvdXMBCmFzc2V0T3du ZXIBAP//AQtiZW5lZmljaWFyeQEKYXNzZXRPd25lcgEA//8AAQIBC2JlbmVmaWNp -YXJ5AKGHno9Wvdb9jKMjuU854GBkOqaaOSGRlNYMTIp8ewHIAQhUcmFuc2Zlcg== - +YXJ5AKGHno9Wvdb9jKMjuU854GBkOqaaOSGRlNYMTIp8ewHIAQhUcmFuc2ZlckcA +AAEZbYUpyPbaRE0VTo2cjL2eD42JAlo7sJEhxj1SsB6HBQGlz/sydRMHfk8fyWBy +koJEoB6hjGza9ZjaC1c1rAde1wTmWH8s9ni/g1nkiHa9jlTtNm6OJzU5OGgO2daO +567uCByrv8PYJsC/0el3Coie+syLZxatAUo+7BC2WRUwIpBCAAAAAAAAAAD///// +AAAAAAtsUA2UJkRi+3HA6HR4A3aVtGRhWLnsUZ3W1H503FTzA18Fc3BhY2UgBGV4 +Y2whBnF1b3RlcyIEaGFzaCMGZG9sbGFyJAdwZXJjZW50JQlhbXBlcnNhbmQmCmFw +b3N0cm9waGUnCGJyYWNrZXRMKAhicmFja2V0UikIYXN0ZXJpc2sqBHBsdXMrBWNv +bW1hLAVtaW51cy0DZG90LgVzbGFzaC8EemVybzADb25lMQN0d28yBXRocmVlMwRm +b3VyNARmaXZlNQNzaXg2BXNldmVuNwVlaWdodDgEbmluZTkFY29sb246CXNlbWlD +b2xvbjsEbGVzczwFZXF1YWw9B2dyZWF0ZXI+CHF1ZXN0aW9uPwJhdEABQUEBQkIB +Q0MBREQBRUUBRkYBR0cBSEgBSUkBSkoBS0sBTEwBTU0BTk4BT08BUFABUVEBUlIB +U1MBVFQBVVUBVlYBV1cBWFgBWVkBWloKc3FCcmFja2V0TFsJYmFja1NsYXNoXApz +cUJyYWNrZXRSXQVjYXJldF4GbG9kYXNoXwhiYWNrdGlja2ABYWEBYmIBY2MBZGQB +ZWUBZmYBZ2cBaGgBaWkBamoBa2sBbGwBbW0Bbm4Bb28BcHABcXEBcnIBc3MBdHQB +dXUBdnYBd3cBeHgBeXkBenoJY0JyYWNrZXRMewRwaXBlfAljQnJhY2tldFJ9BXRp +bGRlfg7SGjsZhfj1Xxr/xyYdVR9rq0vyBs3ESP3Ll7fESAnNBgIEdXR4b+hqQM1c +Jfm94oT/aaURMqdBKyFVvQ5WEsG/44SVYMUGBXByb29m8rokgBaefTpI/QAwLR/f +gLnjEY8BolumdS19z4HvCDgUTa7IMubEN5J7JV65m0KKh9kNUKjM0E1yEbW3vF9m +zgOAA251bAADc29oAQNzdHgCA2V0eAMDZW90BANlbnEFA2FjawYDYmVsBwJicwgC +aHQJAmxmCgJ2dAsCZmYMAmNyDQJzbw4Cc2kPA2RsZRADZGMxEQNkYzISA2RjMxMD +ZGM0FARuYWNrFQNzeW4WA2V0YhcDY2FuGAJlbRkDc3ViGgNlc2MbAmZzHAJncx0C +cnMeAnVzHwVzcGFjZSAEZXhjbCEGcXVvdGVzIgRoYXNoIwZkb2xsYXIkB3BlcmNl +bnQlCWFtcGVyc2FuZCYKYXBvc3Ryb3BoZScIYnJhY2tldEwoCGJyYWNrZXRSKQhh +c3RlcmlzayoEcGx1cysFY29tbWEsBW1pbnVzLQNkb3QuBXNsYXNoLwR6ZXJvMANv +bmUxA3R3bzIFdGhyZWUzBGZvdXI0BGZpdmU1A3NpeDYFc2V2ZW43BWVpZ2h0OARu +aW5lOQVjb2xvbjoJc2VtaUNvbG9uOwRsZXNzPAVlcXVhbD0HZ3JlYXRlcj4IcXVl +c3Rpb24/AmF0QAFBQQFCQgFDQwFERAFFRQFGRgFHRwFISAFJSQFKSgFLSwFMTAFN +TQFOTgFPTwFQUAFRUQFSUgFTUwFUVAFVVQFWVgFXVwFYWAFZWQFaWgpzcUJyYWNr +ZXRMWwliYWNrU2xhc2hcCnNxQnJhY2tldFJdBWNhcmV0XgZsb2Rhc2hfCGJhY2t0 +aWNrYAFhYQFiYgFjYwFkZAFlZQFmZgFnZwFoaAFpaQFqagFrawFsbAFtbQFubgFv +bwFwcAFxcQFycgFzcwF0dAF1dQF2dgF3dwF4eAF5eQF6egljQnJhY2tldEx7BHBp +cGV8CWNCcmFja2V0Un0FdGlsZGV+A2RlbH8YGqHj7XS9UaPM22yyGAvUE/L4kcKK +dl8Woqjzui2rsQhgFcDnB2Sp9IrnHdRIyvQDW//r22Lv9w3IeUKG+JEPQQEAAAAA +AAAACAAAAAAAAAAYtwXhXbnrd3fB+dw0nvBu2R6UgC9Nqw/xeYaVCnOMfgUBjHml +whK+G4JeGb1Ufgkat4BgG7bnI/vzZlSRRg6liSkYy5RvEpPPGA6deNzGW8WbRy// +/q379Y2xmMyDKPZLAQUBVg2W96R5JLLD3wQOZGM5j9Zf1ZFlLClDQr+l+TkVUVQZ +Ry0X2GIHpw8hMalYoWilbirWUz+cZkwZd9pc+f5ihgYECnByZXZPdXRwdXToakDN +XCX5veKE/2mlETKnQSshVb0OVhLBv+OElWDFBglzaWdTY3JpcHQ4dQSxS3wORm1H +nhdHfSR0JH/4A2TsPUuq9zog90F0awhzZXF1ZW5jZQEZbYUpyPbaRE0VTo2cjL2e +D42JAlo7sJEhxj1SsB6HB3dpdG5lc3Nzd0NwNpMgSc0olQiqcXzjgp2yRS5V6E7U +/C48zS4AnRyrv8PYJsC/0el3Coie+syLZxatAUo+7BC2WRUwIpBCAEAdQgtl0EEa +UhgdiwLz2oOqmVV9gtOzuwebXlvMIDwz4wYCBXRlcm1zGMuUbxKTzxgOnXjcxlvF +m0cv//6t+/WNsZjMgyj2SwEFbWVkaWHg8AbVikZHmWNgiPc4zsudpLzn0BDuy2oe +jxp0SsMF+iHjPkPFqlzyKSdTozjBZ+07Y5xN2c69qY80aRe6yUN1BQGlz/sydRMH +fk8fyWBykoJEoB6hjGza9ZjaC1c1rAde1yLk4JbpvX1chvXh3113AWr+Occ82TSF +UJRAiYyoo3leAyAEdTVfMAAEdTVfMQEEdTVfMgIEdTVfMwMEdTVfNAQEdTVfNQUE +dTVfNgYEdTVfNwcEdTVfOAgEdTVfOQkFdTVfMTAKBXU1XzExCwV1NV8xMgwFdTVf +MTMNBXU1XzE0DgV1NV8xNQ8FdTVfMTYQBXU1XzE3EQV1NV8xOBIFdTVfMTkTBXU1 +XzIwFAV1NV8yMRUFdTVfMjIWBXU1XzIzFwV1NV8yNBgFdTVfMjUZBXU1XzI2GgV1 +NV8yNxsFdTVfMjgcBXU1XzI5HQV1NV8zMB4FdTVfMzEfJav1uRIUF7qjOdRfexV1 +p3FL4Xp1GF3QMTV61Mkt6YYFAQTmWH8s9ni/g1nkiHa9jlTtNm6OJzU5OGgO2daO +567uKRxNbFez6voRCoM0m2MPIGGVJvH8yfwqMRv0KDb7vhAGBAd2ZXJzaW9uqHzG +eWRn5VfXROXJYjrgDMuV2RoNLwPfdMB1Ek++x54GaW5wdXRzd8C41m6P0G6+VBoh +ooru+KjatfSazIIDFKpO243NfVQHb3V0cHV0c7KCraAWmeYs/GxKV4ZhUw29ypMs +pvbXT9prYVsrFgaLCGxvY2tUaW1lNdodFTkgbrvd3KTDPYcx6vKbp9p03z3IgiAc +Tha1uRwqW6qsUIn/CY0VC0gs/ti80BqRwNe0XTIhbtV2q3Hr3Qccq7/D2CbAv9Hp +dwqInvrMi2cWrQFKPuwQtlkVMCKQQiAALSUZOQcC2aNIS3niiee78qjK1/tdK8Cl ++Ecdum+jwDwDGgFBQQFCQgFDQwFERAFFRQFGRgFHRwFISAFJSQFKSgFLSwFMTAFN +TQFOTgFPTwFQUAFRUQFSUgFTUwFUVAFVVQFWVgFXVwFYWAFZWQFaWjGOyqByhwvZ +UjCpUVpqqhSYK6yeP7FeolKOsEBSJ6ehBgEKYnVyblByb29mc0ezUyBT+D/BrTq+ +iEU2IMtkfYbOXuTj3la1yThCPrnNM5hAho+cqmWs0IdNGgbrLuJhTNzVN/d2Fcg2 +y5phPZMDPwRkYXNoLQR6ZXJvMANvbmUxA3R3bzIFdGhyZWUzBGZvdXI0BGZpdmU1 +A3NpeDYFc2V2ZW43BWVpZ2h0OARuaW5lOQFBQQFCQgFDQwFERAFFRQFGRgFHRwFI +SAFJSQFKSgFLSwFMTAFNTQFOTgFPTwFQUAFRUQFSUgFTUwFUVAFVVQFWVgFXVwFY +WAFZWQFaWgFhYQFiYgFjYwFkZAFlZQFmZgFnZwFoaAFpaQFqagFrawFsbAFtbQFu +bgFvbwFwcAFxcQFycgFzcwF0dAF1dQF2dgF3dwF4eAF5eQF6ejXaHRU5IG673dyk +wz2HMerym6fadN89yIIgHE4WtbkcBQGlz/sydRMHfk8fyWBykoJEoB6hjGza9Zja +C1c1rAde1zh1BLFLfA5GbUeeF0d9JHQkf/gDZOw9S6r3OiD3QXRrBQElq/W5EhQX +uqM51F97FXWncUvhenUYXdAxNXrUyS3phjyK3Yk4NvjATAc9H0VNlSXPlqfXVXKW ++mY926rvqEOUAzQBQUEBQkIBQ0MBREQBRUUBRkYBR0cBSEgBSUkBSkoBS0sBTEwB +TU0BTk4BT08BUFABUVEBUlIBU1MBVFQBVVUBVlYBV1cBWFgBWVkBWloBYWEBYmIB +Y2MBZGQBZWUBZmYBZ2cBaGgBaWkBamoBa2sBbGwBbW0Bbm4Bb28BcHABcXEBcnIB +c3MBdHQBdXUBdnYBd3cBeHgBeXkBeno80aKdzK2bkXsmMF+JqKT7IRgwKk5zxawK +eA3mqwBecwMtBGV4Y2whBGhhc2gjBmRvbGxhciQDYW1wJgRwbHVzKwRkYXNoLQNk +b3QuBHplcm8wA29uZTEDdHdvMgV0aHJlZTMEZm91cjQEZml2ZTUDc2l4NgVzZXZl +bjcFZWlnaHQ4BG5pbmU5BWNhcmV0XgZsb2Rhc2hfAWFhAWJiAWNjAWRkAWVlAWZm +AWdnAWhoAWlpAWpqAWtrAWxsAW1tAW5uAW9vAXBwAXFxAXJyAXNzAXR0AXV1AXZ2 +AXd3AXh4AXl5AXp6Pytyt8SvGmMMttP/CIuvNRCT7kZbnn1HKmEAguRJ1+QFAWOq +IxTosUfIsoTfs5qeENGcqtX66oSOPLmEnZFn1jRKRbeAJYYBxSayO1tIYUYKkFDh +PzX7voMFqAARV+QBOIgEAgAEbm9uZdg/vuAvDeW0bPgP4R73/fBhx42XXTGt6e6i +vECZM55sAQRzb21lyv+PrrOKAKBONiFTj45h11qFpGXLCg5Iw1k+fqpsX8dGe6yB +ObH1E/03sx50RZ2GCrL2cDPamtRy5to9H/OKewYBCHJlc2VydmVzR7NTIFP4P8Gt +Or6IRTYgy2R9hs5e5OPeVrXJOEI+uc1Hs1MgU/g/wa06vohFNiDLZH2Gzl7k495W +tck4Qj65zQkO0ho7GYX49V8a/8cmHVUfa6tL8gbNxEj9y5e3xEgJzQAAAAAAAAAA +//8AAAAAAABQFBBfDEAmyhKrrjd94m+OPKBgjdNsSD7XD0cZXNM01AUBhN4DwH0d +R3u3bUCpR9JuHth9xE6vhnIN1NyKSARzc7NWDZb3pHkkssPfBA5kYzmP1l/VkWUs +KUNCv6X5ORVRVAj7qVhyGj0zVAazaMNvWoJ5CWDM4jn+vK/hibqYOdXaeAAAAAAA +AAAA//8AAAAAAABWHinQV9Q+AulObV2Zfw7qcWx1uxrjEvnBxlPa8wOUUAg80aKd +zK2bkXsmMF+JqKT7IRgwKk5zxawKeA3mqwBecwEAAAAAAAAAQAAAAAAAAABZbno6 +DqNlnhAw8YtNZaO5E+5YUAf8914Lts3BacHAOwUBZjLaZLv1vDzJ9SJFL1N3qDgE +zc2VAGvEZ6E5TMGitI9coUlYXeU07pGz46Awt+/UzbeavqkVLxAfN1m0xyEOHwAI +XQPEF42pjn4/OvND45l9dCAdEfQnMs++orBLjj/xXyIDEwtpbmRpdmlzaWJsZQAE +ZGVjaQEFY2VudGkCBW1pbGxpAwlkZWNpTWlsbGkECmNlbnRpTWlsbGkFBW1pY3Jv +BglkZWNpTWljcm8HCmNlbnRpTWljcm8IBG5hbm8JCGRlY2lOYW5vCgljZW50aU5h +bm8LBHBpY28MCGRlY2lQaWNvDQljZW50aVBpY28OBWZlbXRvDwlkZWNpRmVtdG8Q +CmNlbnRpRmVtdG8RBGF0dG8SYBXA5wdkqfSK5x3USMr0A1v/69ti7/cNyHlChviR +D0EDJAR6ZXJvMANvbmUxA3R3bzIFdGhyZWUzBGZvdXI0BGZpdmU1A3NpeDYFc2V2 +ZW43BWVpZ2h0OARuaW5lOQFBQQFCQgFDQwFERAFFRQFGRgFHRwFISAFJSQFKSgFL +SwFMTAFNTQFOTgFPTwFQUAFRUQFSUgFTUwFUVAFVVQFWVgFXVwFYWAFZWQFaWmGG +ItF7rvBmAt/ndcmA4LNrbrroCQ2AdfdRO+xLk/ZNAwIFZmFsc2UABHRydWUBY6oj +FOixR8iyhN+zmp4Q0Zyq1frqhI48uYSdkWfWNEoI+6lYcho9M1QGs2jDb1qCeQlg +zOI5/ryv4Ym6mDnV2ngBAAAAAAAAAP8AAAAAAAAAZjLaZLv1vDzJ9SJFL1N3qDgE +zc2VAGvEZ6E5TMGitI8ARGcdubdnF/nDazz5Uzdd7bKOJ4AJ0mKv+Goj34HUbT6h +BgMEdHlwZYx5pcISvhuCXhm9VH4JGreAYBu25yP782ZUkUYOpYkpB3N1YnR5cGWP +9i/grW/m/mqCXVtVeTyKyHKtLymY5Q6Tlfykijw7ZwdjaGFyc2V0j/Yv4K1v5v5q +gl1bVXk8ishyrS8pmOUOk5X8pIo8O2dyjqaKl950IPYqWWmwS4cmBL9F1t84lZx+ +JuenJJDkrQM/BHplcm8wA29uZTEDdHdvMgV0aHJlZTMEZm91cjQEZml2ZTUDc2l4 +NgVzZXZlbjcFZWlnaHQ4BG5pbmU5AUFBAUJCAUNDAUREAUVFAUZGAUdHAUhIAUlJ +AUpKAUtLAUxMAU1NAU5OAU9PAVBQAVFRAVJSAVNTAVRUAVVVAVZWAVdXAVhYAVlZ +AVpaBmxvZGFzaF8BYWEBYmIBY2MBZGQBZWUBZmYBZ2cBaGgBaWkBamoBa2sBbGwB +bW0Bbm4Bb28BcHABcXEBcnIBc3MBdHQBdXUBdnYBd3cBeHgBeXkBenpzd0NwNpMg +Sc0olQiqcXzjgp2yRS5V6E7U/C48zS4AnQUBx6Va1fbrKxQH2aI3Rc2B0aZ1wqjw +mXbno5rHd9dePbV3wLjWbo/Qbr5UGiGiiu74qNq19JrMggMUqk7bjc19VAgZRy0X +2GIHpw8hMalYoWilbirWUz+cZkwZd9pc+f5ihgAAAAAAAAAA/////wAAAACAV64H +9HuSOszFNh/PQNkpguhB91fdWbFte9vI6r6ZpQUBGBqh4+10vVGjzNtsshgL1BPy ++JHCinZfFqKo87otq7GE3gPAfR1He7dtQKlH0m4e2H3ETq+Gcg3U3IpIBHNzswgL +bFANlCZEYvtxwOh0eAN2lbRkYVi57FGd1tR+dNxU8wEAAAAAAAAAKAAAAAAAAACI +jFhlYzrxO5W3zRqNivLawdwUC5dyUdnU2vPHURyOhAUBXKFJWF3lNO6Rs+OgMLfv +1M23mr6pFS8QHzdZtMchDh+MeaXCEr4bgl4ZvVR+CRq3gGAbtucj+/NmVJFGDqWJ +KQUBVh4p0FfUPgLpTm1dmX8O6nFsdbsa4xL5wcZT2vMDlFCP9i/grW/m/mqCXVtV +eTyKyHKtLymY5Q6Tlfykijw7ZwQCAARub25l2D++4C8N5bRs+A/hHvf98GHHjZdd +Ma3p7qK8QJkznmwBBHNvbWUYtwXhXbnrd3fB+dw0nvBu2R6UgC9Nqw/xeYaVCnOM +fpA7ZHB5hI8bJlMq5M7GpolEoFNYuPCByyazu/gtnjvzBgIFdmFsdWWX9dcGQq4q +M5IlO6hOHc7Ek+O/PtNxsYdzhjVOzIiCawxzY3JpcHRQdWJrZXm+/B78ZqUZ/WRS +ajoTh0Dn8RAtC77/OsFGTvP3QHZ0XJf11wZCriozkiU7qE4dzsST478+03Gxh3OG +NU7MiIJrBQFcoUlYXeU07pGz46Awt+/UzbeavqkVLxAfN1m0xyEOH5liTbfkJpKZ +VJMu38jSZ6VSlwIpPNWrwFZObyJbM/rxBgIGbmFtaW5n3nx1PGvVZ3T4ckUwbKRj +QJcQzuAb7cqRIPyu75O/9YYJcHJlY2lzaW9uXQPEF42pjn4/OvND45l9dCAdEfQn +Ms++orBLjj/xXyKhMc/ld5RQAWjg2akfBwSTu0aoJ9782IfI1/p8Q3d58QMQBHU0 +XzAABHU0XzEBBHU0XzICBHU0XzMDBHU0XzQEBHU0XzUFBHU0XzYGBHU0XzcHBHU0 +XzgIBHU0XzkJBXU0XzEwCgV1NF8xMQsFdTRfMTIMBXU0XzEzDQV1NF8xNA4FdTRf +MTUPoYeej1a91v2MoyO5TzngYGQ6ppo5IZGU1gxMinx7AcgDBg5zdXBwbHlNaXNt +YXRjaAEPbm9uRXF1YWxBbW91bnRzAgxpbnZhbGlkUHJvb2YDFGluc3VmZmljaWVu +dFJlc2VydmVzBBRpbnN1ZmZpY2llbnRDb3ZlcmFnZQUVaXNzdWVFeGNlZWRzQWxs +b3dhbmNlBqOCQvPL19HQoRLajeFgL1bU+G8OxMR2xcBoWUxLBGVWBQEqW6qsUIn/ +CY0VC0gs/ti80BqRwNe0XTIhbtV2q3Hr3aXP+zJ1Ewd+Tx/JYHKSgkSgHqGMbNr1 +mNoLVzWsB17XAASmLjhKE1GEGDudprl5awbojHXGgDE53TkRSOoEmuPX4QMQBHpl +cm8wA29uZTEDdHdvMgV0aHJlZTMEZm91cjQEZml2ZTUDc2l4NgVzZXZlbjcFZWln +aHQ4BG5pbmU5A3RlbmEGZWxldmVuYgZ0d2VsdmVjCHRoaXJ0ZWVuZAhmb3VydGVl +bmUHZmlmdGVlbmaofMZ5ZGflV9dE5cliOuAMy5XZGg0vA990wHUST77HngUBZjLa +ZLv1vDzJ9SJFL1N3qDgEzc2VAGvEZ6E5TMGitI+ygq2gFpnmLPxsSleGYVMNvcqT +LKb210/aa2FbKxYGiwiQO2RweYSPGyZTKuTOxqaJRKBTWLjwgcsms7v4LZ478wAA +AAAAAAAA/////wAAAAC2H+dXTuCC66lhZl9mrrIJMJYSI5CWTSBkmye158h1FAYC +BHR5cGVnHbm3Zxf5w2s8+VM3Xe2yjieACdJir/hqI9+B1G0+oQZkaWdlc3QqW6qs +UIn/CY0VC0gs/ti80BqRwNe0XTIhbtV2q3Hr3bqg4/yrnVXRaLseJoNxU6/on4Oi +fgSYVU05Y/ZDH9P0Az4EemVybzADb25lMQN0d28yBXRocmVlMwRmb3VyNARmaXZl +NQNzaXg2BXNldmVuNwVlaWdodDgEbmluZTkBQUEBQkIBQ0MBREQBRUUBRkYBR0cB +SEgBSUkBSkoBS0sBTEwBTU0BTk4BT08BUFABUVEBUlIBU1MBVFQBVVUBVlYBV1cB +WFgBWVkBWloBYWEBYmIBY2MBZGQBZWUBZmYBZ2cBaGgBaWkBamoBa2sBbGwBbW0B +bm4Bb28BcHABcXEBcnIBc3MBdHQBdXUBdnYBd3cBeHgBeXkBenq8KJGxxmrF9eYQ +WaMgd9qoIzOhQ1vTRgizCwP8AX2VRQMKBHplcm8wA29uZTEDdHdvMgV0aHJlZTME +Zm91cjQEZml2ZTUDc2l4NgVzZXZlbjcFZWlnaHQ4BG5pbmU5vvwe/GalGf1kUmo6 +E4dA5/EQLQu+/zrBRk7z90B2dFwFASWr9bkSFBe6oznUX3sVdadxS+F6dRhd0DE1 +etTJLemGx6Va1fbrKxQH2aI3Rc2B0aZ1wqjwmXbno5rHd9dePbUIBOZYfyz2eL+D +WeSIdr2OVO02bo4nNTk4aA7Z1o7nru4AAAAAAAAAAP////8AAAAAyv+PrrOKAKBO +NiFTj45h11qFpGXLCg5Iw1k+fqpsX8cFAT8rcrfErxpjDLbT/wiLrzUQk+5GW559 +RyphAILkSdfk2D++4C8N5bRs+A/hHvf98GHHjZddMa3p7qK8QJkznmwAAN58dTxr +1Wd0+HJFMGykY0CXEM7gG+3KkSD8ru+Tv/WGBgMGdGlja2VygFeuB/R7kjrMxTYf +z0DZKYLoQfdX3VmxbXvbyOq+maUEbmFtZVAUEF8MQCbKEquuN33ib448oGCN02xI +PtcPRxlc0zTUB2RldGFpbHNFt4AlhgHFJrI7W0hhRgqQUOE/Nfu+gwWoABFX5AE4 +iODwBtWKRkeZY2CI9zjOy52kvOfQEO7Lah6PGnRKwwX6BAIABG5vbmXYP77gLw3l +tGz4D+Ee9/3wYceNl10xrenuorxAmTOebAEEc29tZeROugrVnh8GlR4UT+mKWsEV +m8tHfnBPYE4TfQIj9MOG5E66CtWeHwaVHhRP6YpawRWby0d+cE9gThN9AiP0w4YF +AbYf51dO4ILrqWFmX2ausgkwlhIjkJZNIGSbJ7XnyHUU6GpAzVwl+b3ihP9ppREy +p0ErIVW9DlYSwb/jhJVgxQYGAgR0eGlko4JC88vX0dChEtqN4WAvVtT4bw7ExHbF +wGhZTEsEZVYEdm91dCHjPkPFqlzyKSdTozjBZ+07Y5xN2c69qY80aRe6yUN17t7D +66oI+wEPL5bheg4Dmth/5gdxpzAfjF6ImV0FZ2sDEAR6ZXJvMANvbmUxA3R3bzIF +dGhyZWUzBGZvdXI0BGZpdmU1A3NpeDYFc2V2ZW43BWVpZ2h0OARuaW5lOQN0ZW5B +BmVsZXZlbkIGdHdlbHZlQwh0aGlydGVlbkQIZm91cnRlZW5FB2ZpZnRlZW5G8rok +gBaefTpI/QAwLR/fgLnjEY8BolumdS19z4HvCDgIHKu/w9gmwL/R6XcKiJ76zItn +Fq0BSj7sELZZFTAikEIAAAAAAAAAAP//AAAAAAAA+RcIBN2uBHn41a90qzvSAubq +QXLZqbk3BxUa23/EDKEDGgFhYQFiYgFjYwFkZAFlZQFmZgFnZwFoaAFpaQFqagFr +awFsbAFtbQFubgFvbwFwcAFxcQFycgFzcwF0dAF1dQF2dgF3dwF4eAF5eQF6evup +WHIaPTNUBrNow29agnkJYMziOf68r+GJupg51dp4AQ== -----END RGB INTERFACE----- diff --git a/std/tests/data/rgb21.rgba b/std/tests/data/rgb21.rgba index dfb71fc8..4280a8cf 100644 --- a/std/tests/data/rgb21.rgba +++ b/std/tests/data/rgb21.rgba @@ -1,5 +1,5 @@ -----BEGIN RGB INTERFACE----- -Id: 35ebeVG1p8u7xrK3WDUZpgaDn9ZXwQ51qttLH9hJzFZS +Id: 5pQ3Ef8Ad8kR3m2WyNAEV4WjS83UPZ4jwnrdhJKfAmRA Name: RGB21 AAVSR0IyMQYPYXR0YWNobWVudFR5cGVzAQhnVPQXicO5NRI0M9lZqkxUQRkLwpjh @@ -24,6 +24,221 @@ ZmljaWFyeQZSZW5hbWUBAAEDbmV3AQRzcGVjAQABAAEEdXNlZAELdXBkYXRlUmln aHQBAAEAAQZmdXR1cmUBC3VwZGF0ZVJpZ2h0AAABAAAAAQZmdXR1cmUIVHJhbnNm ZXIAAAABCHByZXZpb3VzAQphc3NldE93bmVyAQD//wELYmVuZWZpY2lhcnkBCmFz c2V0T3duZXIBAP//AAMBAgcBC2JlbmVmaWNpYXJ5AGuHzCBHak2qk1kLJWjbng7V -SrjEPI6Ti7cvThrX8eneAQhUcmFuc2Zlcg== +SrjEPI6Ti7cvThrX8eneAQhUcmFuc2ZlclsAAAEZbYUpyPbaRE0VTo2cjL2eD42J +Alo7sJEhxj1SsB6HBQGlz/sydRMHfk8fyWBykoJEoB6hjGza9ZjaC1c1rAde1wTm +WH8s9ni/g1nkiHa9jlTtNm6OJzU5OGgO2daO567uCByrv8PYJsC/0el3Coie+syL +ZxatAUo+7BC2WRUwIpBCAAAAAAAAAAD/////AAAAAAhnVPQXicO5NRI0M9lZqkxU +QRkLwpjhyNGn7ZK+jFaEBgICaWR38NB9zLO7UqSD3pDB6FKOoE4EDAQXglNBHIIe +ITePYwRuYW1ltuvM/0ufeTJZ8EsxT7dmEoCKl8UoXLc16+Oe2L+CBZQLbFANlCZE +YvtxwOh0eAN2lbRkYVi57FGd1tR+dNxU8wNfBXNwYWNlIARleGNsIQZxdW90ZXMi +BGhhc2gjBmRvbGxhciQHcGVyY2VudCUJYW1wZXJzYW5kJgphcG9zdHJvcGhlJwhi +cmFja2V0TCgIYnJhY2tldFIpCGFzdGVyaXNrKgRwbHVzKwVjb21tYSwFbWludXMt +A2RvdC4Fc2xhc2gvBHplcm8wA29uZTEDdHdvMgV0aHJlZTMEZm91cjQEZml2ZTUD +c2l4NgVzZXZlbjcFZWlnaHQ4BG5pbmU5BWNvbG9uOglzZW1pQ29sb247BGxlc3M8 +BWVxdWFsPQdncmVhdGVyPghxdWVzdGlvbj8CYXRAAUFBAUJCAUNDAUREAUVFAUZG +AUdHAUhIAUlJAUpKAUtLAUxMAU1NAU5OAU9PAVBQAVFRAVJSAVNTAVRUAVVVAVZW +AVdXAVhYAVlZAVpaCnNxQnJhY2tldExbCWJhY2tTbGFzaFwKc3FCcmFja2V0Ul0F +Y2FyZXReBmxvZGFzaF8IYmFja3RpY2tgAWFhAWJiAWNjAWRkAWVlAWZmAWdnAWho +AWlpAWpqAWtrAWxsAW1tAW5uAW9vAXBwAXFxAXJyAXNzAXR0AXV1AXZ2AXd3AXh4 +AXl5AXp6CWNCcmFja2V0THsEcGlwZXwJY0JyYWNrZXRSfQV0aWxkZX4O0ho7GYX4 +9V8a/8cmHVUfa6tL8gbNxEj9y5e3xEgJzQYCBHV0eG/oakDNXCX5veKE/2mlETKn +QSshVb0OVhLBv+OElWDFBgVwcm9vZvK6JIAWnn06SP0AMC0f34C54xGPAaJbpnUt +fc+B7wg4FAyzHVP0vZ5ICRubVX2CAyYvIsJsp7FohlKCWz+KsjoFAaXP+zJ1Ewd+ +Tx/JYHKSgkSgHqGMbNr1mNoLVzWsB17XFE2uyDLmxDeSeyVeuZtCiofZDVCozNBN +chG1t7xfZs4DgANudWwAA3NvaAEDc3R4AgNldHgDA2VvdAQDZW5xBQNhY2sGA2Jl +bAcCYnMIAmh0CQJsZgoCdnQLAmZmDAJjcg0Cc28OAnNpDwNkbGUQA2RjMREDZGMy +EgNkYzMTA2RjNBQEbmFjaxUDc3luFgNldGIXA2NhbhgCZW0ZA3N1YhoDZXNjGwJm +cxwCZ3MdAnJzHgJ1cx8Fc3BhY2UgBGV4Y2whBnF1b3RlcyIEaGFzaCMGZG9sbGFy +JAdwZXJjZW50JQlhbXBlcnNhbmQmCmFwb3N0cm9waGUnCGJyYWNrZXRMKAhicmFj +a2V0UikIYXN0ZXJpc2sqBHBsdXMrBWNvbW1hLAVtaW51cy0DZG90LgVzbGFzaC8E +emVybzADb25lMQN0d28yBXRocmVlMwRmb3VyNARmaXZlNQNzaXg2BXNldmVuNwVl +aWdodDgEbmluZTkFY29sb246CXNlbWlDb2xvbjsEbGVzczwFZXF1YWw9B2dyZWF0 +ZXI+CHF1ZXN0aW9uPwJhdEABQUEBQkIBQ0MBREQBRUUBRkYBR0cBSEgBSUkBSkoB +S0sBTEwBTU0BTk4BT08BUFABUVEBUlIBU1MBVFQBVVUBVlYBV1cBWFgBWVkBWloK +c3FCcmFja2V0TFsJYmFja1NsYXNoXApzcUJyYWNrZXRSXQVjYXJldF4GbG9kYXNo +XwhiYWNrdGlja2ABYWEBYmIBY2MBZGQBZWUBZmYBZ2cBaGgBaWkBamoBa2sBbGwB +bW0Bbm4Bb28BcHABcXEBcnIBc3MBdHQBdXUBdnYBd3cBeHgBeXkBenoJY0JyYWNr +ZXRMewRwaXBlfAljQnJhY2tldFJ9BXRpbGRlfgNkZWx/GBqh4+10vVGjzNtsshgL +1BPy+JHCinZfFqKo87otq7EIYBXA5wdkqfSK5x3USMr0A1v/69ti7/cNyHlChviR +D0EBAAAAAAAAAAgAAAAAAAAAGHDty+xkB5SzBDVsxVyQnn/9PeFS2Exz8oVeV4O7 +3VkFAmUBVkPkSIzz9xQ0AXnXJego8sBL/EHMOyf2BU/aN3MdGevmnRNwSOFZb8Hn +6VCvCmTBdl8p5BIkqy0r9OdgXHcYtwXhXbnrd3fB+dw0nvBu2R6UgC9Nqw/xeYaV +CnOMfgUBjHmlwhK+G4JeGb1Ufgkat4BgG7bnI/vzZlSRRg6liSkYy5RvEpPPGA6d +eNzGW8WbRy///q379Y2xmMyDKPZLAQUBVg2W96R5JLLD3wQOZGM5j9Zf1ZFlLClD +Qr+l+TkVUVQZRy0X2GIHpw8hMalYoWilbirWUz+cZkwZd9pc+f5ihgYECnByZXZP +dXRwdXToakDNXCX5veKE/2mlETKnQSshVb0OVhLBv+OElWDFBglzaWdTY3JpcHQ4 +dQSxS3wORm1HnhdHfSR0JH/4A2TsPUuq9zog90F0awhzZXF1ZW5jZQEZbYUpyPba +RE0VTo2cjL2eD42JAlo7sJEhxj1SsB6HB3dpdG5lc3Nzd0NwNpMgSc0olQiqcXzj +gp2yRS5V6E7U/C48zS4AnRnr5p0TcEjhWW/B5+lQrwpkwXZfKeQSJKstK/TnYFx3 +BQFcoUlYXeU07pGz46Awt+/UzbeavqkVLxAfN1m0xyEOHxoTz62ERvsVAxdYwt+m +oJ1YMYPqwa+gV+VQ1jak5QIbCAtsUA2UJkRi+3HA6HR4A3aVtGRhWLnsUZ3W1H50 +3FTzAQAAAAAAAAAUAAAAAAAAAByrv8PYJsC/0el3Coie+syLZxatAUo+7BC2WRUw +IpBCAEAdQgtl0EEaUhgdiwLz2oOqmVV9gtOzuwebXlvMIDwz4wYCBXRlcm1zGMuU +bxKTzxgOnXjcxlvFm0cv//6t+/WNsZjMgyj2SwEFbWVkaWHg8AbVikZHmWNgiPc4 +zsudpLzn0BDuy2oejxp0SsMF+iHjPkPFqlzyKSdTozjBZ+07Y5xN2c69qY80aRe6 +yUN1BQGlz/sydRMHfk8fyWBykoJEoB6hjGza9ZjaC1c1rAde1yLk4JbpvX1chvXh +3113AWr+Occ82TSFUJRAiYyoo3leAyAEdTVfMAAEdTVfMQEEdTVfMgIEdTVfMwME +dTVfNAQEdTVfNQUEdTVfNgYEdTVfNwcEdTVfOAgEdTVfOQkFdTVfMTAKBXU1XzEx +CwV1NV8xMgwFdTVfMTMNBXU1XzE0DgV1NV8xNQ8FdTVfMTYQBXU1XzE3EQV1NV8x +OBIFdTVfMTkTBXU1XzIwFAV1NV8yMRUFdTVfMjIWBXU1XzIzFwV1NV8yNBgFdTVf +MjUZBXU1XzI2GgV1NV8yNxsFdTVfMjgcBXU1XzI5HQV1NV8zMB4FdTVfMzEfJav1 +uRIUF7qjOdRfexV1p3FL4Xp1GF3QMTV61Mkt6YYFAQTmWH8s9ni/g1nkiHa9jlTt +Nm6OJzU5OGgO2daO567uKRxNbFez6voRCoM0m2MPIGGVJvH8yfwqMRv0KDb7vhAG +BAd2ZXJzaW9uqHzGeWRn5VfXROXJYjrgDMuV2RoNLwPfdMB1Ek++x54GaW5wdXRz +d8C41m6P0G6+VBohooru+KjatfSazIIDFKpO243NfVQHb3V0cHV0c7KCraAWmeYs +/GxKV4ZhUw29ypMspvbXT9prYVsrFgaLCGxvY2tUaW1lNdodFTkgbrvd3KTDPYcx +6vKbp9p03z3IgiAcTha1uRwqW6qsUIn/CY0VC0gs/ti80BqRwNe0XTIhbtV2q3Hr +3Qccq7/D2CbAv9HpdwqInvrMi2cWrQFKPuwQtlkVMCKQQiAAK9paYJDDqiMRYBlc +jeFnD3jbU/lf3Lc6f7wb4/+RqmMGAgR0eXBlZx25t2cX+cNrPPlTN13tso4ngAnS +Yq/4aiPfgdRtPqEEZGF0YfK6JIAWnn06SP0AMC0f34C54xGPAaJbpnUtfc+B7wg4 +LSUZOQcC2aNIS3niiee78qjK1/tdK8Cl+Ecdum+jwDwDGgFBQQFCQgFDQwFERAFF +RQFGRgFHRwFISAFJSQFKSgFLSwFMTAFNTQFOTgFPTwFQUAFRUQFSUgFTUwFUVAFV +VQFWVgFXVwFYWAFZWQFaWjGOyqByhwvZUjCpUVpqqhSYK6yeP7FeolKOsEBSJ6eh +BgEKYnVyblByb29mc0ezUyBT+D/BrTq+iEU2IMtkfYbOXuTj3la1yThCPrnNM5hA +ho+cqmWs0IdNGgbrLuJhTNzVN/d2Fcg2y5phPZMDPwRkYXNoLQR6ZXJvMANvbmUx +A3R3bzIFdGhyZWUzBGZvdXI0BGZpdmU1A3NpeDYFc2V2ZW43BWVpZ2h0OARuaW5l +OQFBQQFCQgFDQwFERAFFRQFGRgFHRwFISAFJSQFKSgFLSwFMTAFNTQFOTgFPTwFQ +UAFRUQFSUgFTUwFUVAFVVQFWVgFXVwFYWAFZWQFaWgFhYQFiYgFjYwFkZAFlZQFm +ZgFnZwFoaAFpaQFqagFrawFsbAFtbQFubgFvbwFwcAFxcQFycgFzcwF0dAF1dQF2 +dgF3dwF4eAF5eQF6ejXaHRU5IG673dykwz2HMerym6fadN89yIIgHE4WtbkcBQGl +z/sydRMHfk8fyWBykoJEoB6hjGza9ZjaC1c1rAde1zYiqkxTGkJD2wFXZvf1YBer +mo8GCEs2b1aIsEnVcqg+BgIJYXBwbGllZFRvZQFWQ+RIjPP3FDQBedcl6CjywEv8 +Qcw7J/YFT9o3cx0HY29udGVudCvaWmCQw6ojEWAZXI3hZw9421P5X9y3On+8G+P/ +kapjOHUEsUt8DkZtR54XR30kdCR/+ANk7D1Lqvc6IPdBdGsFASWr9bkSFBe6oznU +X3sVdadxS+F6dRhd0DE1etTJLemGPIrdiTg2+MBMBz0fRU2VJc+Wp9dVcpb6Zj3b +qu+oQ5QDNAFBQQFCQgFDQwFERAFFRQFGRgFHRwFISAFJSQFKSgFLSwFMTAFNTQFO +TgFPTwFQUAFRUQFSUgFTUwFUVAFVVQFWVgFXVwFYWAFZWQFaWgFhYQFiYgFjYwFk +ZAFlZQFmZgFnZwFoaAFpaQFqagFrawFsbAFtbQFubgFvbwFwcAFxcQFycgFzcwF0 +dAF1dQF2dgF3dwF4eAF5eQF6ejzRop3MrZuReyYwX4mopPshGDAqTnPFrAp4Dear +AF5zAy0EZXhjbCEEaGFzaCMGZG9sbGFyJANhbXAmBHBsdXMrBGRhc2gtA2RvdC4E +emVybzADb25lMQN0d28yBXRocmVlMwRmb3VyNARmaXZlNQNzaXg2BXNldmVuNwVl +aWdodDgEbmluZTkFY2FyZXReBmxvZGFzaF8BYWEBYmIBY2MBZGQBZWUBZmYBZ2cB +aGgBaWkBamoBa2sBbGwBbW0Bbm4Bb28BcHABcXEBcnIBc3MBdHQBdXUBdnYBd3cB +eHgBeXkBeno/K3K3xK8aYwy20/8Ii681EJPuRluefUcqYQCC5EnX5AUBY6ojFOix +R8iyhN+zmp4Q0Zyq1frqhI48uYSdkWfWNEpFt4AlhgHFJrI7W0hhRgqQUOE/Nfu+ +gwWoABFX5AE4iAQCAARub25l2D++4C8N5bRs+A/hHvf98GHHjZddMa3p7qK8QJkz +nmwBBHNvbWXK/4+us4oAoE42IVOPjmHXWoWkZcsKDkjDWT5+qmxfx0Z7rIE5sfUT +/TezHnRFnYYKsvZwM9qa1HLm2j0f84p7BgEIcmVzZXJ2ZXNHs1MgU/g/wa06vohF +NiDLZH2Gzl7k495Wtck4Qj65zUezUyBT+D/BrTq+iEU2IMtkfYbOXuTj3la1yThC +PrnNCQ7SGjsZhfj1Xxr/xyYdVR9rq0vyBs3ESP3Ll7fESAnNAAAAAAAAAAD//wAA +AAAAAFAUEF8MQCbKEquuN33ib448oGCN02xIPtcPRxlc0zTUBQGE3gPAfR1He7dt +QKlH0m4e2H3ETq+Gcg3U3IpIBHNzs1YNlvekeSSyw98EDmRjOY/WX9WRZSwpQ0K/ +pfk5FVFUCPupWHIaPTNUBrNow29agnkJYMziOf68r+GJupg51dp4AAAAAAAAAAD/ +/wAAAAAAAFYeKdBX1D4C6U5tXZl/DupxbHW7GuMS+cHGU9rzA5RQCDzRop3MrZuR +eyYwX4mopPshGDAqTnPFrAp4DearAF5zAQAAAAAAAABAAAAAAAAAAFluejoOo2We +EDDxi01lo7kT7lhQB/z3Xgu2zcFpwcA7BQFmMtpku/W8PMn1IkUvU3eoOATNzZUA +a8RnoTlMwaK0j1yhSVhd5TTukbPjoDC379TNt5q+qRUvEB83WbTHIQ4fAAhdA8QX +jamOfj8680PjmX10IB0R9Ccyz76isEuOP/FfIgMTC2luZGl2aXNpYmxlAARkZWNp +AQVjZW50aQIFbWlsbGkDCWRlY2lNaWxsaQQKY2VudGlNaWxsaQUFbWljcm8GCWRl +Y2lNaWNybwcKY2VudGlNaWNybwgEbmFubwkIZGVjaU5hbm8KCWNlbnRpTmFubwsE +cGljbwwIZGVjaVBpY28NCWNlbnRpUGljbw4FZmVtdG8PCWRlY2lGZW10bxAKY2Vu +dGlGZW10bxEEYXR0bxJeebBOe+ACblQpt8OFsfcNc3R9fJzFUll4HVygI/REPgp3 +8NB9zLO7UqSD3pDB6FKOoE4EDAQXglNBHIIeITePY7Yf51dO4ILrqWFmX2ausgkw +lhIjkJZNIGSbJ7XnyHUUAAAAAAAAAAAUAAAAAAAAAF964fM/xw2LpKiUWBEiPvmz +UTWtoCQPObDcKC7p5IuPBQFQFBBfDEAmyhKrrjd94m+OPKBgjdNsSD7XD0cZXNM0 +1GAVwOcHZKn0iucd1EjK9ANb/+vbYu/3Dch5Qob4kQ9BAyQEemVybzADb25lMQN0 +d28yBXRocmVlMwRmb3VyNARmaXZlNQNzaXg2BXNldmVuNwVlaWdodDgEbmluZTkB +QUEBQkIBQ0MBREQBRUUBRkYBR0cBSEgBSUkBSkoBS0sBTEwBTU0BTk4BT08BUFAB +UVEBUlIBU1MBVFQBVVUBVlYBV1cBWFgBWVkBWlphhiLRe67wZgLf53XJgOCza266 +6AkNgHX3UTvsS5P2TQMCBWZhbHNlAAR0cnVlAWOqIxTosUfIsoTfs5qeENGcqtX6 +6oSOPLmEnZFn1jRKCPupWHIaPTNUBrNow29agnkJYMziOf68r+GJupg51dp4AQAA +AAAAAAD/AAAAAAAAAGUBVkPkSIzz9xQ0AXnXJego8sBL/EHMOyf2BU/aN3MdBQGl +z/sydRMHfk8fyWBykoJEoB6hjGza9ZjaC1c1rAde12Yy2mS79bw8yfUiRS9Td6g4 +BM3NlQBrxGehOUzBorSPAERnHbm3Zxf5w2s8+VM3Xe2yjieACdJir/hqI9+B1G0+ +oQYDBHR5cGWMeaXCEr4bgl4ZvVR+CRq3gGAbtucj+/NmVJFGDqWJKQdzdWJ0eXBl +j/Yv4K1v5v5qgl1bVXk8ishyrS8pmOUOk5X8pIo8O2cHY2hhcnNldI/2L+Ctb+b+ +aoJdW1V5PIrIcq0vKZjlDpOV/KSKPDtna4fMIEdqTaqTWQslaNueDtVKuMQ8jpOL +ty9OGtfx6d4DCBBmcmFjdGlvbk92ZXJmbG93AQ5ub25FcXVhbFZhbHVlcwIMaW52 +YWxpZFByb29mAxRpbnN1ZmZpY2llbnRSZXNlcnZlcwQVaXNzdWVFeGNlZWRzQWxs +b3dhbmNlBhJub25GcmFjdGlvbmFsVG9rZW4HEm5vbkVuZ3JhdmFibGVUb2tlbggV +aW52YWxpZEF0dGFjaG1lbnRUeXBlCWvn3Dk6tsZbSOSVQs0diifKBYT1LZoS3hWJ +AZe66ovgBggFaW5kZXhlAVZD5EiM8/cUNAF51yXoKPLAS/xBzDsn9gVP2jdzHQZ0 +aWNrZXKh9f9GhH8oe3swYwYu5KNC7WM0z14PsnMNSM9/W7ADfgRuYW1lz44mJQaj +pLKmq8o4WmUCq/gDYEam3Y2mOuYdMJs8dSoHZGV0YWlsc0W3gCWGAcUmsjtbSGFG +CpBQ4T81+76DBagAEVfkATiIB3ByZXZpZXfafNyNYwAk54q/XIHq+n9PeWUNK9SX +Q/Kv3kBFtLaLxgVtZWRpYeDwBtWKRkeZY2CI9zjOy52kvOfQEO7Lah6PGnRKwwX6 +C2F0dGFjaG1lbnRzXnmwTnvgAm5UKbfDhbH3DXN0fXycxVJZeB1coCP0RD4IcmVz +ZXJ2ZXNudMyfHQzLVM7/LfMkydRVwazqcjI6zbdczgK3vZejVW50zJ8dDMtUzv8t +8yTJ1FXBrOpyMjrNt1zOAre9l6NVBAIABG5vbmXYP77gLw3ltGz4D+Ee9/3wYceN +l10xrenuorxAmTOebAEEc29tZX1lTpftlhZ8PDxJE1dCUSe2wPAIos1wVBdz+hst +Taokco6mipfedCD2KllpsEuHJgS/RdbfOJWcfibnpySQ5K0DPwR6ZXJvMANvbmUx +A3R3bzIFdGhyZWUzBGZvdXI0BGZpdmU1A3NpeDYFc2V2ZW43BWVpZ2h0OARuaW5l +OQFBQQFCQgFDQwFERAFFRQFGRgFHRwFISAFJSQFKSgFLSwFMTAFNTQFOTgFPTwFQ +UAFRUQFSUgFTUwFUVAFVVQFWVgFXVwFYWAFZWQFaWgZsb2Rhc2hfAWFhAWJiAWNj +AWRkAWVlAWZmAWdnAWhoAWlpAWpqAWtrAWxsAW1tAW5uAW9vAXBwAXFxAXJyAXNz +AXR0AXV1AXZ2AXd3AXh4AXl5AXp6c3dDcDaTIEnNKJUIqnF844KdskUuVehO1Pwu +PM0uAJ0FAcelWtX26ysUB9miN0XNgdGmdcKo8Jl256Oax3fXXj21d8C41m6P0G6+ +VBohooru+KjatfSazIIDFKpO243NfVQIGUctF9hiB6cPITGpWKFopW4q1lM/nGZM +GXfaXPn+YoYAAAAAAAAAAP////8AAAAAd/DQfcyzu1Kkg96QwehSjqBOBAwEF4JT +QRyCHiE3j2MAAX1lTpftlhZ8PDxJE1dCUSe2wPAIos1wVBdz+hstTaokBQEO0ho7 +GYX49V8a/8cmHVUfa6tL8gbNxEj9y5e3xEgJzYBXrgf0e5I6zMU2H89A2SmC6EH3 +V91ZsW1728jqvpmlBQEYGqHj7XS9UaPM22yyGAvUE/L4kcKKdl8Woqjzui2rsYTe +A8B9HUd7t21AqUfSbh7YfcROr4ZyDdTcikgEc3OzCAtsUA2UJkRi+3HA6HR4A3aV +tGRhWLnsUZ3W1H503FTzAQAAAAAAAAAoAAAAAAAAAIiMWGVjOvE7lbfNGo2K8trB +3BQLl3JR2dTa88dRHI6EBQFcoUlYXeU07pGz46Awt+/UzbeavqkVLxAfN1m0xyEO +H4x5pcISvhuCXhm9VH4JGreAYBu25yP782ZUkUYOpYkpBQFWHinQV9Q+AulObV2Z +fw7qcWx1uxrjEvnBxlPa8wOUUI/2L+Ctb+b+aoJdW1V5PIrIcq0vKZjlDpOV/KSK +PDtnBAIABG5vbmXYP77gLw3ltGz4D+Ee9/3wYceNl10xrenuorxAmTOebAEEc29t +ZRi3BeFduet3d8H53DSe8G7ZHpSAL02rD/F5hpUKc4x+kDtkcHmEjxsmUyrkzsam +iUSgU1i48IHLJrO7+C2eO/MGAgV2YWx1ZZf11wZCriozkiU7qE4dzsST478+03Gx +h3OGNU7MiIJrDHNjcmlwdFB1Ymtleb78HvxmpRn9ZFJqOhOHQOfxEC0Lvv86wUZO +8/dAdnRcl/XXBkKuKjOSJTuoTh3OxJPjvz7TcbGHc4Y1TsyIgmsFAVyhSVhd5TTu +kbPjoDC379TNt5q+qRUvEB83WbTHIQ4fmWJNt+QmkplUky7fyNJnpVKXAik81avA +Vk5vIlsz+vEGAgZuYW1pbmfefHU8a9VndPhyRTBspGNAlxDO4BvtypEg/K7vk7/1 +hglwcmVjaXNpb25dA8QXjamOfj8680PjmX10IB0R9Ccyz76isEuOP/FfIqExz+V3 +lFABaODZqR8HBJO7Rqgn3vzYh8jX+nxDd3nxAxAEdTRfMAAEdTRfMQEEdTRfMgIE +dTRfMwMEdTRfNAQEdTRfNQUEdTRfNgYEdTRfNwcEdTRfOAgEdTRfOQkFdTRfMTAK +BXU0XzExCwV1NF8xMgwFdTRfMTMNBXU0XzE0DgV1NF8xNQ+h9f9GhH8oe3swYwYu +5KNC7WM0z14PsnMNSM9/W7ADfgQCAARub25l2D++4C8N5bRs+A/hHvf98GHHjZdd +Ma3p7qK8QJkznmwBBHNvbWXpOEWqwxa21tBkLaKGY9P4A6B2ekBdcyl7Nr6L2RGk +baOCQvPL19HQoRLajeFgL1bU+G8OxMR2xcBoWUxLBGVWBQEqW6qsUIn/CY0VC0gs +/ti80BqRwNe0XTIhbtV2q3Hr3aXP+zJ1Ewd+Tx/JYHKSgkSgHqGMbNr1mNoLVzWs +B17XAASmLjhKE1GEGDudprl5awbojHXGgDE53TkRSOoEmuPX4QMQBHplcm8wA29u +ZTEDdHdvMgV0aHJlZTMEZm91cjQEZml2ZTUDc2l4NgVzZXZlbjcFZWlnaHQ4BG5p +bmU5A3RlbmEGZWxldmVuYgZ0d2VsdmVjCHRoaXJ0ZWVuZAhmb3VydGVlbmUHZmlm +dGVlbmaofMZ5ZGflV9dE5cliOuAMy5XZGg0vA990wHUST77HngUBZjLaZLv1vDzJ +9SJFL1N3qDgEzc2VAGvEZ6E5TMGitI+ygq2gFpnmLPxsSleGYVMNvcqTLKb210/a +a2FbKxYGiwiQO2RweYSPGyZTKuTOxqaJRKBTWLjwgcsms7v4LZ478wAAAAAAAAAA +/////wAAAAC2H+dXTuCC66lhZl9mrrIJMJYSI5CWTSBkmye158h1FAYCBHR5cGVn +Hbm3Zxf5w2s8+VM3Xe2yjieACdJir/hqI9+B1G0+oQZkaWdlc3QqW6qsUIn/CY0V +C0gs/ti80BqRwNe0XTIhbtV2q3Hr3bbrzP9Ln3kyWfBLMU+3ZhKAipfFKFy3Nevj +nti/ggWUBQEaE8+thEb7FQMXWMLfpqCdWDGD6sGvoFflUNY2pOUCG7qg4/yrnVXR +aLseJoNxU6/on4OifgSYVU05Y/ZDH9P0Az4EemVybzADb25lMQN0d28yBXRocmVl +MwRmb3VyNARmaXZlNQNzaXg2BXNldmVuNwVlaWdodDgEbmluZTkBQUEBQkIBQ0MB +REQBRUUBRkYBR0cBSEgBSUkBSkoBS0sBTEwBTU0BTk4BT08BUFABUVEBUlIBU1MB +VFQBVVUBVlYBV1cBWFgBWVkBWloBYWEBYmIBY2MBZGQBZWUBZmYBZ2cBaGgBaWkB +amoBa2sBbGwBbW0Bbm4Bb28BcHABcXEBcnIBc3MBdHQBdXUBdnYBd3cBeHgBeXkB +enq8KJGxxmrF9eYQWaMgd9qoIzOhQ1vTRgizCwP8AX2VRQMKBHplcm8wA29uZTED +dHdvMgV0aHJlZTMEZm91cjQEZml2ZTUDc2l4NgVzZXZlbjcFZWlnaHQ4BG5pbmU5 +vvwe/GalGf1kUmo6E4dA5/EQLQu+/zrBRk7z90B2dFwFASWr9bkSFBe6oznUX3sV +dadxS+F6dRhd0DE1etTJLemGx6Va1fbrKxQH2aI3Rc2B0aZ1wqjwmXbno5rHd9de +PbUIBOZYfyz2eL+DWeSIdr2OVO02bo4nNTk4aA7Z1o7nru4AAAAAAAAAAP////8A +AAAAyv+PrrOKAKBONiFTj45h11qFpGXLCg5Iw1k+fqpsX8cFAT8rcrfErxpjDLbT +/wiLrzUQk+5GW559RyphAILkSdfkz44mJQajpLKmq8o4WmUCq/gDYEam3Y2mOuYd +MJs8dSoEAgAEbm9uZdg/vuAvDeW0bPgP4R73/fBhx42XXTGt6e6ivECZM55sAQRz +b21lX3rh8z/HDYukqJRYESI++bNRNa2gJA85sNwoLunki4/YP77gLw3ltGz4D+Ee +9/3wYceNl10xrenuorxAmTOebAAA2nzcjWMAJOeKv1yB6vp/T3llDSvUl0Pyr95A +RbS2i8YEAgAEbm9uZdg/vuAvDeW0bPgP4R73/fBhx42XXTGt6e6ivECZM55sAQRz +b21l/LpiUP4CJK1HXwJD36uuZT1Ti9zqgYBIgysk1occB7XefHU8a9VndPhyRTBs +pGNAlxDO4BvtypEg/K7vk7/1hgYDBnRpY2tlcoBXrgf0e5I6zMU2H89A2SmC6EH3 +V91ZsW1728jqvpmlBG5hbWVQFBBfDEAmyhKrrjd94m+OPKBgjdNsSD7XD0cZXNM0 +1AdkZXRhaWxzRbeAJYYBxSayO1tIYUYKkFDhPzX7voMFqAARV+QBOIjg8AbVikZH +mWNgiPc4zsudpLzn0BDuy2oejxp0SsMF+gQCAARub25l2D++4C8N5bRs+A/hHvf9 +8GHHjZddMa3p7qK8QJkznmwBBHNvbWXkTroK1Z4fBpUeFE/pilrBFZvLR35wT2BO +E30CI/TDhuROugrVnh8GlR4UT+mKWsEVm8tHfnBPYE4TfQIj9MOGBQG2H+dXTuCC +66lhZl9mrrIJMJYSI5CWTSBkmye158h1FOhqQM1cJfm94oT/aaURMqdBKyFVvQ5W +EsG/44SVYMUGBgIEdHhpZKOCQvPL19HQoRLajeFgL1bU+G8OxMR2xcBoWUxLBGVW +BHZvdXQh4z5Dxapc8iknU6M4wWftO2OcTdnOvamPNGkXuslDdek4RarDFrbW0GQt +ooZj0/gDoHZ6QF1zKXs2vovZEaRtBQGAV64H9HuSOszFNh/PQNkpguhB91fdWbFt +e9vI6r6Zpe7ew+uqCPsBDy+W4XoOA5rYf+YHcacwH4xeiJldBWdrAxAEemVybzAD +b25lMQN0d28yBXRocmVlMwRmb3VyNARmaXZlNQNzaXg2BXNldmVuNwVlaWdodDgE +bmluZTkDdGVuQQZlbGV2ZW5CBnR3ZWx2ZUMIdGhpcnRlZW5ECGZvdXJ0ZWVuRQdm +aWZ0ZWVuRvK6JIAWnn06SP0AMC0f34C54xGPAaJbpnUtfc+B7wg4CByrv8PYJsC/ +0el3Coie+syLZxatAUo+7BC2WRUwIpBCAAAAAAAAAAD//wAAAAAAAPkXCATdrgR5 ++NWvdKs70gLm6kFy2am5NwcVGtt/xAyhAxoBYWEBYmIBY2MBZGQBZWUBZmYBZ2cB +aGgBaWkBamoBa2sBbGwBbW0Bbm4Bb28BcHABcXEBcnIBc3MBdHQBdXUBdnYBd3cB +eHgBeXkBenr7qVhyGj0zVAazaMNvWoJ5CWDM4jn+vK/hibqYOdXaeAH8umJQ/gIk +rUdfAkPfq65lPVOL3OqBgEiDKyTWhxwHtQUBK9paYJDDqiMRYBlcjeFnD3jbU/lf +3Lc6f7wb4/+RqmM= -----END RGB INTERFACE----- diff --git a/std/tests/data/rgb25.rgba b/std/tests/data/rgb25.rgba index dd7cf442..b527fa0c 100644 --- a/std/tests/data/rgb25.rgba +++ b/std/tests/data/rgb25.rgba @@ -1,5 +1,5 @@ -----BEGIN RGB INTERFACE----- -Id: 5uj9C1SGSU8de97LMksungm89ERSNv6kh743YybHsq2G +Id: 8MJ3wpi2Qz5pz5HpzuxRXH1XY4Q9ehiYjjmuJ4HDb3LH Name: RGB25 AAVSR0IyNQcMYnVybmVkU3VwcGx5AYiMWGVjOvE7lbfNGo2K8trB3BQLl3JR2dTa @@ -16,6 +16,179 @@ BAIEQnVybgEBMY7KoHKHC9lSMKlRWmqqFJgrrJ4/sV6iUo6wQFInp6EBDGJ1cm5l ZFN1cHBseQABAAEAAQR1c2VkAQlidXJuUmlnaHQBAAEAAQZmdXR1cmUBCWJ1cm5S aWdodAAAAQAAAwEDBQAIVHJhbnNmZXIAAAABCHByZXZpb3VzAQphc3NldE93bmVy AQD//wELYmVuZWZpY2lhcnkBCmFzc2V0T3duZXIBAP//AAECAQtiZW5lZmljaWFy -eQCe0wEGwUvUzKK5EgcivAR3l468uV7jYqqKL4WWQZHhfgEIVHJhbnNmZXI= +eQCe0wEGwUvUzKK5EgcivAR3l468uV7jYqqKL4WWQZHhfgEIVHJhbnNmZXJHAAAB +GW2FKcj22kRNFU6NnIy9ng+NiQJaO7CRIcY9UrAehwUBpc/7MnUTB35PH8lgcpKC +RKAeoYxs2vWY2gtXNawHXtcE5lh/LPZ4v4NZ5Ih2vY5U7TZujic1OThoDtnWjueu +7ggcq7/D2CbAv9HpdwqInvrMi2cWrQFKPuwQtlkVMCKQQgAAAAAAAAAA/////wAA +AAALbFANlCZEYvtxwOh0eAN2lbRkYVi57FGd1tR+dNxU8wNfBXNwYWNlIARleGNs +IQZxdW90ZXMiBGhhc2gjBmRvbGxhciQHcGVyY2VudCUJYW1wZXJzYW5kJgphcG9z +dHJvcGhlJwhicmFja2V0TCgIYnJhY2tldFIpCGFzdGVyaXNrKgRwbHVzKwVjb21t +YSwFbWludXMtA2RvdC4Fc2xhc2gvBHplcm8wA29uZTEDdHdvMgV0aHJlZTMEZm91 +cjQEZml2ZTUDc2l4NgVzZXZlbjcFZWlnaHQ4BG5pbmU5BWNvbG9uOglzZW1pQ29s +b247BGxlc3M8BWVxdWFsPQdncmVhdGVyPghxdWVzdGlvbj8CYXRAAUFBAUJCAUND +AUREAUVFAUZGAUdHAUhIAUlJAUpKAUtLAUxMAU1NAU5OAU9PAVBQAVFRAVJSAVNT +AVRUAVVVAVZWAVdXAVhYAVlZAVpaCnNxQnJhY2tldExbCWJhY2tTbGFzaFwKc3FC +cmFja2V0Ul0FY2FyZXReBmxvZGFzaF8IYmFja3RpY2tgAWFhAWJiAWNjAWRkAWVl +AWZmAWdnAWhoAWlpAWpqAWtrAWxsAW1tAW5uAW9vAXBwAXFxAXJyAXNzAXR0AXV1 +AXZ2AXd3AXh4AXl5AXp6CWNCcmFja2V0THsEcGlwZXwJY0JyYWNrZXRSfQV0aWxk +ZX4O0ho7GYX49V8a/8cmHVUfa6tL8gbNxEj9y5e3xEgJzQYCBHV0eG/oakDNXCX5 +veKE/2mlETKnQSshVb0OVhLBv+OElWDFBgVwcm9vZvK6JIAWnn06SP0AMC0f34C5 +4xGPAaJbpnUtfc+B7wg4FE2uyDLmxDeSeyVeuZtCiofZDVCozNBNchG1t7xfZs4D +gANudWwAA3NvaAEDc3R4AgNldHgDA2VvdAQDZW5xBQNhY2sGA2JlbAcCYnMIAmh0 +CQJsZgoCdnQLAmZmDAJjcg0Cc28OAnNpDwNkbGUQA2RjMREDZGMyEgNkYzMTA2Rj +NBQEbmFjaxUDc3luFgNldGIXA2NhbhgCZW0ZA3N1YhoDZXNjGwJmcxwCZ3MdAnJz +HgJ1cx8Fc3BhY2UgBGV4Y2whBnF1b3RlcyIEaGFzaCMGZG9sbGFyJAdwZXJjZW50 +JQlhbXBlcnNhbmQmCmFwb3N0cm9waGUnCGJyYWNrZXRMKAhicmFja2V0UikIYXN0 +ZXJpc2sqBHBsdXMrBWNvbW1hLAVtaW51cy0DZG90LgVzbGFzaC8EemVybzADb25l +MQN0d28yBXRocmVlMwRmb3VyNARmaXZlNQNzaXg2BXNldmVuNwVlaWdodDgEbmlu +ZTkFY29sb246CXNlbWlDb2xvbjsEbGVzczwFZXF1YWw9B2dyZWF0ZXI+CHF1ZXN0 +aW9uPwJhdEABQUEBQkIBQ0MBREQBRUUBRkYBR0cBSEgBSUkBSkoBS0sBTEwBTU0B +Tk4BT08BUFABUVEBUlIBU1MBVFQBVVUBVlYBV1cBWFgBWVkBWloKc3FCcmFja2V0 +TFsJYmFja1NsYXNoXApzcUJyYWNrZXRSXQVjYXJldF4GbG9kYXNoXwhiYWNrdGlj +a2ABYWEBYmIBY2MBZGQBZWUBZmYBZ2cBaGgBaWkBamoBa2sBbGwBbW0Bbm4Bb28B +cHABcXEBcnIBc3MBdHQBdXUBdnYBd3cBeHgBeXkBenoJY0JyYWNrZXRMewRwaXBl +fAljQnJhY2tldFJ9BXRpbGRlfgNkZWx/GBqh4+10vVGjzNtsshgL1BPy+JHCinZf +FqKo87otq7EIYBXA5wdkqfSK5x3USMr0A1v/69ti7/cNyHlChviRD0EBAAAAAAAA +AAgAAAAAAAAAGLcF4V2563d3wfncNJ7wbtkelIAvTasP8XmGlQpzjH4FAYx5pcIS +vhuCXhm9VH4JGreAYBu25yP782ZUkUYOpYkpGMuUbxKTzxgOnXjcxlvFm0cv//6t ++/WNsZjMgyj2SwEFAVYNlvekeSSyw98EDmRjOY/WX9WRZSwpQ0K/pfk5FVFUGUct +F9hiB6cPITGpWKFopW4q1lM/nGZMGXfaXPn+YoYGBApwcmV2T3V0cHV06GpAzVwl ++b3ihP9ppREyp0ErIVW9DlYSwb/jhJVgxQYJc2lnU2NyaXB0OHUEsUt8DkZtR54X +R30kdCR/+ANk7D1Lqvc6IPdBdGsIc2VxdWVuY2UBGW2FKcj22kRNFU6NnIy9ng+N +iQJaO7CRIcY9UrAehwd3aXRuZXNzc3dDcDaTIEnNKJUIqnF844KdskUuVehO1Pwu +PM0uAJ0cq7/D2CbAv9HpdwqInvrMi2cWrQFKPuwQtlkVMCKQQgBAHUILZdBBGlIY +HYsC89qDqplVfYLTs7sHm15bzCA8M+MGAgV0ZXJtcxjLlG8Sk88YDp143MZbxZtH +L//+rfv1jbGYzIMo9ksBBW1lZGlh4PAG1YpGR5ljYIj3OM7LnaS859AQ7stqHo8a +dErDBfoh4z5Dxapc8iknU6M4wWftO2OcTdnOvamPNGkXuslDdQUBpc/7MnUTB35P +H8lgcpKCRKAeoYxs2vWY2gtXNawHXtci5OCW6b19XIb14d9ddwFq/jnHPNk0hVCU +QImMqKN5XgMgBHU1XzAABHU1XzEBBHU1XzICBHU1XzMDBHU1XzQEBHU1XzUFBHU1 +XzYGBHU1XzcHBHU1XzgIBHU1XzkJBXU1XzEwCgV1NV8xMQsFdTVfMTIMBXU1XzEz +DQV1NV8xNA4FdTVfMTUPBXU1XzE2EAV1NV8xNxEFdTVfMTgSBXU1XzE5EwV1NV8y +MBQFdTVfMjEVBXU1XzIyFgV1NV8yMxcFdTVfMjQYBXU1XzI1GQV1NV8yNhoFdTVf +MjcbBXU1XzI4HAV1NV8yOR0FdTVfMzAeBXU1XzMxHyWr9bkSFBe6oznUX3sVdadx +S+F6dRhd0DE1etTJLemGBQEE5lh/LPZ4v4NZ5Ih2vY5U7TZujic1OThoDtnWjueu +7ikcTWxXs+r6EQqDNJtjDyBhlSbx/Mn8KjEb9Cg2+74QBgQHdmVyc2lvbqh8xnlk +Z+VX10TlyWI64AzLldkaDS8D33TAdRJPvseeBmlucHV0c3fAuNZuj9BuvlQaIaKK +7vio2rX0msyCAxSqTtuNzX1UB291dHB1dHOygq2gFpnmLPxsSleGYVMNvcqTLKb2 +10/aa2FbKxYGiwhsb2NrVGltZTXaHRU5IG673dykwz2HMerym6fadN89yIIgHE4W +tbkcKluqrFCJ/wmNFQtILP7YvNAakcDXtF0yIW7Vdqtx690HHKu/w9gmwL/R6XcK +iJ76zItnFq0BSj7sELZZFTAikEIgAC0lGTkHAtmjSEt54onnu/Koytf7XSvApfhH +Hbpvo8A8AxoBQUEBQkIBQ0MBREQBRUUBRkYBR0cBSEgBSUkBSkoBS0sBTEwBTU0B +Tk4BT08BUFABUVEBUlIBU1MBVFQBVVUBVlYBV1cBWFgBWVkBWloxjsqgcocL2VIw +qVFaaqoUmCusnj+xXqJSjrBAUienoQYBCmJ1cm5Qcm9vZnNHs1MgU/g/wa06vohF +NiDLZH2Gzl7k495Wtck4Qj65zTOYQIaPnKplrNCHTRoG6y7iYUzc1Tf3dhXINsua +YT2TAz8EZGFzaC0EemVybzADb25lMQN0d28yBXRocmVlMwRmb3VyNARmaXZlNQNz +aXg2BXNldmVuNwVlaWdodDgEbmluZTkBQUEBQkIBQ0MBREQBRUUBRkYBR0cBSEgB +SUkBSkoBS0sBTEwBTU0BTk4BT08BUFABUVEBUlIBU1MBVFQBVVUBVlYBV1cBWFgB +WVkBWloBYWEBYmIBY2MBZGQBZWUBZmYBZ2cBaGgBaWkBamoBa2sBbGwBbW0Bbm4B +b28BcHABcXEBcnIBc3MBdHQBdXUBdnYBd3cBeHgBeXkBeno12h0VOSBuu93cpMM9 +hzHq8pun2nTfPciCIBxOFrW5HAUBpc/7MnUTB35PH8lgcpKCRKAeoYxs2vWY2gtX +NawHXtc4dQSxS3wORm1HnhdHfSR0JH/4A2TsPUuq9zog90F0awUBJav1uRIUF7qj +OdRfexV1p3FL4Xp1GF3QMTV61Mkt6YY8it2JODb4wEwHPR9FTZUlz5an11Vylvpm +Pduq76hDlAM0AUFBAUJCAUNDAUREAUVFAUZGAUdHAUhIAUlJAUpKAUtLAUxMAU1N +AU5OAU9PAVBQAVFRAVJSAVNTAVRUAVVVAVZWAVdXAVhYAVlZAVpaAWFhAWJiAWNj +AWRkAWVlAWZmAWdnAWhoAWlpAWpqAWtrAWxsAW1tAW5uAW9vAXBwAXFxAXJyAXNz +AXR0AXV1AXZ2AXd3AXh4AXl5AXp6PNGincytm5F7JjBfiaik+yEYMCpOc8WsCngN +5qsAXnMDLQRleGNsIQRoYXNoIwZkb2xsYXIkA2FtcCYEcGx1cysEZGFzaC0DZG90 +LgR6ZXJvMANvbmUxA3R3bzIFdGhyZWUzBGZvdXI0BGZpdmU1A3NpeDYFc2V2ZW43 +BWVpZ2h0OARuaW5lOQVjYXJldF4GbG9kYXNoXwFhYQFiYgFjYwFkZAFlZQFmZgFn +ZwFoaAFpaQFqagFrawFsbAFtbQFubgFvbwFwcAFxcQFycgFzcwF0dAF1dQF2dgF3 +dwF4eAF5eQF6ej8rcrfErxpjDLbT/wiLrzUQk+5GW559RyphAILkSdfkBQFjqiMU +6LFHyLKE37OanhDRnKrV+uqEjjy5hJ2RZ9Y0SkW3gCWGAcUmsjtbSGFGCpBQ4T81 ++76DBagAEVfkATiIBAIABG5vbmXYP77gLw3ltGz4D+Ee9/3wYceNl10xrenuorxA +mTOebAEEc29tZcr/j66zigCgTjYhU4+OYddahaRlywoOSMNZPn6qbF/HRnusgTmx +9RP9N7MedEWdhgqy9nAz2prUcubaPR/zinsGAQhyZXNlcnZlc0ezUyBT+D/BrTq+ +iEU2IMtkfYbOXuTj3la1yThCPrnNR7NTIFP4P8GtOr6IRTYgy2R9hs5e5OPeVrXJ +OEI+uc0JDtIaOxmF+PVfGv/HJh1VH2urS/IGzcRI/cuXt8RICc0AAAAAAAAAAP// +AAAAAAAAUBQQXwxAJsoSq643feJvjjygYI3TbEg+1w9HGVzTNNQFAYTeA8B9HUd7 +t21AqUfSbh7YfcROr4ZyDdTcikgEc3OzVg2W96R5JLLD3wQOZGM5j9Zf1ZFlLClD +Qr+l+TkVUVQI+6lYcho9M1QGs2jDb1qCeQlgzOI5/ryv4Ym6mDnV2ngAAAAAAAAA +AP//AAAAAAAAVh4p0FfUPgLpTm1dmX8O6nFsdbsa4xL5wcZT2vMDlFAIPNGincyt +m5F7JjBfiaik+yEYMCpOc8WsCngN5qsAXnMBAAAAAAAAAEAAAAAAAAAAWW56Og6j +ZZ4QMPGLTWWjuRPuWFAH/PdeC7bNwWnBwDsFAWYy2mS79bw8yfUiRS9Td6g4BM3N +lQBrxGehOUzBorSPXKFJWF3lNO6Rs+OgMLfv1M23mr6pFS8QHzdZtMchDh8ACF0D +xBeNqY5+PzrzQ+OZfXQgHRH0JzLPvqKwS44/8V8iAxMLaW5kaXZpc2libGUABGRl +Y2kBBWNlbnRpAgVtaWxsaQMJZGVjaU1pbGxpBApjZW50aU1pbGxpBQVtaWNybwYJ +ZGVjaU1pY3JvBwpjZW50aU1pY3JvCARuYW5vCQhkZWNpTmFubwoJY2VudGlOYW5v +CwRwaWNvDAhkZWNpUGljbw0JY2VudGlQaWNvDgVmZW10bw8JZGVjaUZlbXRvEApj +ZW50aUZlbXRvEQRhdHRvEmAVwOcHZKn0iucd1EjK9ANb/+vbYu/3Dch5Qob4kQ9B +AyQEemVybzADb25lMQN0d28yBXRocmVlMwRmb3VyNARmaXZlNQNzaXg2BXNldmVu +NwVlaWdodDgEbmluZTkBQUEBQkIBQ0MBREQBRUUBRkYBR0cBSEgBSUkBSkoBS0sB +TEwBTU0BTk4BT08BUFABUVEBUlIBU1MBVFQBVVUBVlYBV1cBWFgBWVkBWlphhiLR +e67wZgLf53XJgOCza2666AkNgHX3UTvsS5P2TQMCBWZhbHNlAAR0cnVlAWOqIxTo +sUfIsoTfs5qeENGcqtX66oSOPLmEnZFn1jRKCPupWHIaPTNUBrNow29agnkJYMzi +Of68r+GJupg51dp4AQAAAAAAAAD/AAAAAAAAAGYy2mS79bw8yfUiRS9Td6g4BM3N +lQBrxGehOUzBorSPAERnHbm3Zxf5w2s8+VM3Xe2yjieACdJir/hqI9+B1G0+oQYD +BHR5cGWMeaXCEr4bgl4ZvVR+CRq3gGAbtucj+/NmVJFGDqWJKQdzdWJ0eXBlj/Yv +4K1v5v5qgl1bVXk8ishyrS8pmOUOk5X8pIo8O2cHY2hhcnNldI/2L+Ctb+b+aoJd +W1V5PIrIcq0vKZjlDpOV/KSKPDtnco6mipfedCD2KllpsEuHJgS/RdbfOJWcfibn +pySQ5K0DPwR6ZXJvMANvbmUxA3R3bzIFdGhyZWUzBGZvdXI0BGZpdmU1A3NpeDYF +c2V2ZW43BWVpZ2h0OARuaW5lOQFBQQFCQgFDQwFERAFFRQFGRgFHRwFISAFJSQFK +SgFLSwFMTAFNTQFOTgFPTwFQUAFRUQFSUgFTUwFUVAFVVQFWVgFXVwFYWAFZWQFa +WgZsb2Rhc2hfAWFhAWJiAWNjAWRkAWVlAWZmAWdnAWhoAWlpAWpqAWtrAWxsAW1t +AW5uAW9vAXBwAXFxAXJyAXNzAXR0AXV1AXZ2AXd3AXh4AXl5AXp6c3dDcDaTIEnN +KJUIqnF844KdskUuVehO1PwuPM0uAJ0FAcelWtX26ysUB9miN0XNgdGmdcKo8Jl2 +56Oax3fXXj21d8C41m6P0G6+VBohooru+KjatfSazIIDFKpO243NfVQIGUctF9hi +B6cPITGpWKFopW4q1lM/nGZMGXfaXPn+YoYAAAAAAAAAAP////8AAAAAgFeuB/R7 +kjrMxTYfz0DZKYLoQfdX3VmxbXvbyOq+maUFARgaoePtdL1Ro8zbbLIYC9QT8viR +wop2XxaiqPO6LauxhN4DwH0dR3u3bUCpR9JuHth9xE6vhnIN1NyKSARzc7MIC2xQ +DZQmRGL7ccDodHgDdpW0ZGFYuexRndbUfnTcVPMBAAAAAAAAACgAAAAAAAAAiIxY +ZWM68TuVt80ajYry2sHcFAuXclHZ1Nrzx1EcjoQFAVyhSVhd5TTukbPjoDC379TN +t5q+qRUvEB83WbTHIQ4fjHmlwhK+G4JeGb1Ufgkat4BgG7bnI/vzZlSRRg6liSkF +AVYeKdBX1D4C6U5tXZl/DupxbHW7GuMS+cHGU9rzA5RQj/Yv4K1v5v5qgl1bVXk8 +ishyrS8pmOUOk5X8pIo8O2cEAgAEbm9uZdg/vuAvDeW0bPgP4R73/fBhx42XXTGt +6e6ivECZM55sAQRzb21lGLcF4V2563d3wfncNJ7wbtkelIAvTasP8XmGlQpzjH6Q +O2RweYSPGyZTKuTOxqaJRKBTWLjwgcsms7v4LZ478wYCBXZhbHVll/XXBkKuKjOS +JTuoTh3OxJPjvz7TcbGHc4Y1TsyIgmsMc2NyaXB0UHVia2V5vvwe/GalGf1kUmo6 +E4dA5/EQLQu+/zrBRk7z90B2dFyX9dcGQq4qM5IlO6hOHc7Ek+O/PtNxsYdzhjVO +zIiCawUBXKFJWF3lNO6Rs+OgMLfv1M23mr6pFS8QHzdZtMchDh+ZYk235CaSmVST +Lt/I0melUpcCKTzVq8BWTm8iWzP68QYCBm5hbWluZ958dTxr1Wd0+HJFMGykY0CX +EM7gG+3KkSD8ru+Tv/WGCXByZWNpc2lvbl0DxBeNqY5+PzrzQ+OZfXQgHRH0JzLP +vqKwS44/8V8intMBBsFL1MyiuRIHIrwEd5eOvLle42Kqii+FlkGR4X4DBQ5zdXBw +bHlNaXNtYXRjaAEPbm9uRXF1YWxBbW91bnRzAgxpbnZhbGlkUHJvb2YDFGluc3Vm +ZmljaWVudFJlc2VydmVzBBRpbnN1ZmZpY2llbnRDb3ZlcmFnZQWhMc/ld5RQAWjg +2akfBwSTu0aoJ9782IfI1/p8Q3d58QMQBHU0XzAABHU0XzEBBHU0XzICBHU0XzMD +BHU0XzQEBHU0XzUFBHU0XzYGBHU0XzcHBHU0XzgIBHU0XzkJBXU0XzEwCgV1NF8x +MQsFdTRfMTIMBXU0XzEzDQV1NF8xNA4FdTRfMTUPo4JC88vX0dChEtqN4WAvVtT4 +bw7ExHbFwGhZTEsEZVYFASpbqqxQif8JjRULSCz+2LzQGpHA17RdMiFu1Xarcevd +pc/7MnUTB35PH8lgcpKCRKAeoYxs2vWY2gtXNawHXtcABKYuOEoTUYQYO52muXlr +BuiMdcaAMTndORFI6gSa49fhAxAEemVybzADb25lMQN0d28yBXRocmVlMwRmb3Vy +NARmaXZlNQNzaXg2BXNldmVuNwVlaWdodDgEbmluZTkDdGVuYQZlbGV2ZW5iBnR3 +ZWx2ZWMIdGhpcnRlZW5kCGZvdXJ0ZWVuZQdmaWZ0ZWVuZqh8xnlkZ+VX10TlyWI6 +4AzLldkaDS8D33TAdRJPvseeBQFmMtpku/W8PMn1IkUvU3eoOATNzZUAa8RnoTlM +waK0j7KCraAWmeYs/GxKV4ZhUw29ypMspvbXT9prYVsrFgaLCJA7ZHB5hI8bJlMq +5M7GpolEoFNYuPCByyazu/gtnjvzAAAAAAAAAAD/////AAAAALYf51dO4ILrqWFm +X2ausgkwlhIjkJZNIGSbJ7XnyHUUBgIEdHlwZWcdubdnF/nDazz5Uzdd7bKOJ4AJ +0mKv+Goj34HUbT6hBmRpZ2VzdCpbqqxQif8JjRULSCz+2LzQGpHA17RdMiFu1Xar +cevduqDj/KudVdFoux4mg3FTr+ifg6J+BJhVTTlj9kMf0/QDPgR6ZXJvMANvbmUx +A3R3bzIFdGhyZWUzBGZvdXI0BGZpdmU1A3NpeDYFc2V2ZW43BWVpZ2h0OARuaW5l +OQFBQQFCQgFDQwFERAFFRQFGRgFHRwFISAFJSQFKSgFLSwFMTAFNTQFOTgFPTwFQ +UAFRUQFSUgFTUwFUVAFVVQFWVgFXVwFYWAFZWQFaWgFhYQFiYgFjYwFkZAFlZQFm +ZgFnZwFoaAFpaQFqagFrawFsbAFtbQFubgFvbwFwcAFxcQFycgFzcwF0dAF1dQF2 +dgF3dwF4eAF5eQF6erwokbHGasX15hBZoyB32qgjM6FDW9NGCLMLA/wBfZVFAwoE +emVybzADb25lMQN0d28yBXRocmVlMwRmb3VyNARmaXZlNQNzaXg2BXNldmVuNwVl +aWdodDgEbmluZTm+/B78ZqUZ/WRSajoTh0Dn8RAtC77/OsFGTvP3QHZ0XAUBJav1 +uRIUF7qjOdRfexV1p3FL4Xp1GF3QMTV61Mkt6YbHpVrV9usrFAfZojdFzYHRpnXC +qPCZduejmsd31149tQgE5lh/LPZ4v4NZ5Ih2vY5U7TZujic1OThoDtnWjueu7gAA +AAAAAAAA/////wAAAADK/4+us4oAoE42IVOPjmHXWoWkZcsKDkjDWT5+qmxfxwUB +Pytyt8SvGmMMttP/CIuvNRCT7kZbnn1HKmEAguRJ1+TYP77gLw3ltGz4D+Ee9/3w +YceNl10xrenuorxAmTOebAAA3nx1PGvVZ3T4ckUwbKRjQJcQzuAb7cqRIPyu75O/ +9YYGAwZ0aWNrZXKAV64H9HuSOszFNh/PQNkpguhB91fdWbFte9vI6r6ZpQRuYW1l +UBQQXwxAJsoSq643feJvjjygYI3TbEg+1w9HGVzTNNQHZGV0YWlsc0W3gCWGAcUm +sjtbSGFGCpBQ4T81+76DBagAEVfkATiI4PAG1YpGR5ljYIj3OM7LnaS859AQ7stq +Ho8adErDBfoEAgAEbm9uZdg/vuAvDeW0bPgP4R73/fBhx42XXTGt6e6ivECZM55s +AQRzb21l5E66CtWeHwaVHhRP6YpawRWby0d+cE9gThN9AiP0w4bkTroK1Z4fBpUe +FE/pilrBFZvLR35wT2BOE30CI/TDhgUBth/nV07gguupYWZfZq6yCTCWEiOQlk0g +ZJsntefIdRToakDNXCX5veKE/2mlETKnQSshVb0OVhLBv+OElWDFBgYCBHR4aWSj +gkLzy9fR0KES2o3hYC9W1PhvDsTEdsXAaFlMSwRlVgR2b3V0IeM+Q8WqXPIpJ1Oj +OMFn7TtjnE3Zzr2pjzRpF7rJQ3Xu3sPrqgj7AQ8vluF6DgOa2H/mB3GnMB+MXoiZ +XQVnawMQBHplcm8wA29uZTEDdHdvMgV0aHJlZTMEZm91cjQEZml2ZTUDc2l4NgVz +ZXZlbjcFZWlnaHQ4BG5pbmU5A3RlbkEGZWxldmVuQgZ0d2VsdmVDCHRoaXJ0ZWVu +RAhmb3VydGVlbkUHZmlmdGVlbkbyuiSAFp59Okj9ADAtH9+AueMRjwGiW6Z1LX3P +ge8IOAgcq7/D2CbAv9HpdwqInvrMi2cWrQFKPuwQtlkVMCKQQgAAAAAAAAAA//8A +AAAAAAD5FwgE3a4EefjVr3SrO9IC5upBctmpuTcHFRrbf8QMoQMaAWFhAWJiAWNj +AWRkAWVlAWZmAWdnAWhoAWlpAWpqAWtrAWxsAW1tAW5uAW9vAXBwAXFxAXJyAXNz +AXR0AXV1AXZ2AXd3AXh4AXl5AXp6+6lYcho9M1QGs2jDb1qCeQlgzOI5/ryv4Ym6 +mDnV2ngB -----END RGB INTERFACE----- From da9ee2e0cba7d6b0cfbb8a49968a24fcb309df4c Mon Sep 17 00:00:00 2001 From: Dr Maxim Orlovsky Date: Fri, 14 Jul 2023 22:38:24 +0200 Subject: [PATCH 4/5] iface: do correct alias conversion for assignment names. Closes #78 --- std/src/interface/builder.rs | 185 +++++++++++++++++------------------ std/src/interface/mod.rs | 2 +- 2 files changed, 90 insertions(+), 97 deletions(-) diff --git a/std/src/interface/builder.rs b/std/src/interface/builder.rs index 91326c36..e7459e01 100644 --- a/std/src/interface/builder.rs +++ b/std/src/interface/builder.rs @@ -59,6 +59,9 @@ pub enum BuilderError { /// state `{0}` provided to the builder has invalid name InvalidStateField(FieldName), + /// state `{0}` provided to the builder has invalid name + InvalidState(AssignmentType), + /// interface doesn't specifies default operation name, thus an explicit /// operation type must be provided with `set_operation_type` method. NoOperationSubtype, @@ -98,6 +101,19 @@ impl ContractBuilder { self } + pub fn assignments_type(&self, name: &FieldName) -> Option { + let name = self + .builder + .iface + .genesis + .assignments + .get(name)? + .name + .as_ref() + .unwrap_or(name); + self.builder.iimpl.assignments_type(name) + } + pub fn add_global_state( mut self, name: impl Into, @@ -113,9 +129,13 @@ impl ContractBuilder { seal: impl Into, value: u64, ) -> Result { - self.builder = - self.builder - .add_fungible_state(name, BuilderSeal::Revealed(seal.into()), value)?; + let name = name.into(); + let ty = self + .assignments_type(&name) + .ok_or(BuilderError::AssignmentNotFound(name))?; + self.builder = self + .builder + .add_raw_state(ty, seal.into(), TypedState::Amount(value))?; Ok(self) } @@ -125,9 +145,16 @@ impl ContractBuilder { seal: impl Into, value: impl StrictSerialize, ) -> Result { - self.builder = - self.builder - .add_data_state(name, BuilderSeal::Revealed(seal.into()), value)?; + let name = name.into(); + let serialized = value.to_strict_serialized::()?; + let state = RevealedData::from(serialized); + + let ty = self + .assignments_type(&name) + .ok_or(BuilderError::AssignmentNotFound(name))?; + self.builder = self + .builder + .add_raw_state(ty, seal.into(), TypedState::Data(state))?; Ok(self) } @@ -260,10 +287,8 @@ impl TransitionBuilder { ) -> Result { let assignment_name = self.default_assignment()?; let id = self - .builder - .iimpl .assignments_type(assignment_name) - .ok_or(BuilderError::InvalidStateField(assignment_name.clone()))?; + .ok_or_else(|| BuilderError::InvalidStateField(assignment_name.clone()))?; self.add_raw_state(id, seal, TypedState::Amount(value)) } @@ -274,7 +299,32 @@ impl TransitionBuilder { seal: impl Into>, value: u64, ) -> Result { - self.builder = self.builder.add_fungible_state(name, seal, value)?; + let name = name.into(); + let ty = self + .assignments_type(&name) + .ok_or(BuilderError::AssignmentNotFound(name))?; + self.builder = self + .builder + .add_raw_state(ty, seal, TypedState::Amount(value))?; + Ok(self) + } + + pub fn add_data_state( + mut self, + name: impl Into, + seal: impl Into>, + value: impl StrictSerialize, + ) -> Result { + let name = name.into(); + let serialized = value.to_strict_serialized::()?; + let state = RevealedData::from(serialized); + + let ty = self + .assignments_type(&name) + .ok_or(BuilderError::AssignmentNotFound(name))?; + self.builder = self + .builder + .add_raw_state(ty, seal, TypedState::Data(state))?; Ok(self) } @@ -309,7 +359,7 @@ impl TransitionBuilder { } #[derive(Clone, Debug)] -pub struct OperationBuilder { +struct OperationBuilder { // TODO: use references instead of owned values schema: SubSchema, iface: Iface, @@ -381,89 +431,6 @@ impl OperationBuilder { Ok(self) } - pub fn add_fungible_state( - mut self, - name: impl Into, - seal: impl Into>, - value: u64, - ) -> Result { - let name = name.into(); - - let Some(type_id) = self - .iimpl - .assignments - .iter() - .find(|t| t.name == name) - .map(|t| t.id) - else { - return Err(BuilderError::AssignmentNotFound(name)); - }; - - let state_schema = self - .schema - .owned_types - .get(&type_id) - .expect("schema should match interface: must be checked by the constructor"); - if *state_schema != StateSchema::Fungible(FungibleType::Unsigned64Bit) { - return Err(BuilderError::InvalidStateField(name)); - } - - let state = RevealedValue::new(value, &mut thread_rng()); - match self.fungible.get_mut(&type_id) { - Some(assignments) => { - assignments.insert(seal.into(), state)?; - } - None => { - self.fungible - .insert(type_id, Confined::with((seal.into(), state)))?; - } - } - Ok(self) - } - - pub fn add_data_state( - mut self, - name: impl Into, - seal: impl Into>, - value: impl StrictSerialize, - ) -> Result { - let name = name.into(); - let serialized = value.to_strict_serialized::()?; - - let Some(type_id) = self - .iimpl - .assignments - .iter() - .find(|t| t.name == name) - .map(|t| t.id) - else { - return Err(BuilderError::AssignmentNotFound(name)); - }; - - let state_schema = self - .schema - .owned_types - .get(&type_id) - .expect("schema should match interface: must be checked by the constructor"); - - if let StateSchema::Structured(_) = *state_schema { - let state = RevealedData::from(serialized); - match self.data.get_mut(&type_id) { - Some(assignments) => { - assignments.insert(seal.into(), state)?; - } - None => { - self.data - .insert(type_id, Confined::with((seal.into(), state)))?; - } - } - } else { - return Err(BuilderError::InvalidStateField(name)); - } - - Ok(self) - } - pub fn add_raw_state( mut self, type_id: AssignmentType, @@ -476,6 +443,15 @@ impl OperationBuilder { } TypedState::Amount(value) => { let state = RevealedValue::new(value, &mut thread_rng()); + + let state_schema = + self.schema.owned_types.get(&type_id).expect( + "schema should match interface: must be checked by the constructor", + ); + if *state_schema != StateSchema::Fungible(FungibleType::Unsigned64Bit) { + return Err(BuilderError::InvalidState(type_id)); + } + match self.fungible.get_mut(&type_id) { Some(assignments) => { assignments.insert(seal.into(), state)?; @@ -486,8 +462,25 @@ impl OperationBuilder { } } } - TypedState::Data(_) => { - todo!() + TypedState::Data(data) => { + let state_schema = + self.schema.owned_types.get(&type_id).expect( + "schema should match interface: must be checked by the constructor", + ); + + if let StateSchema::Structured(_) = *state_schema { + match self.data.get_mut(&type_id) { + Some(assignments) => { + assignments.insert(seal.into(), data)?; + } + None => { + self.data + .insert(type_id, Confined::with((seal.into(), data)))?; + } + } + } else { + return Err(BuilderError::InvalidState(type_id)); + } } TypedState::Attachment(_) => { todo!() diff --git a/std/src/interface/mod.rs b/std/src/interface/mod.rs index 33071d02..36260d95 100644 --- a/std/src/interface/mod.rs +++ b/std/src/interface/mod.rs @@ -32,7 +32,7 @@ pub mod rgb21; pub mod rgb25; mod suppl; -pub use builder::{BuilderError, ContractBuilder, OperationBuilder, TransitionBuilder}; +pub use builder::{BuilderError, ContractBuilder, TransitionBuilder}; pub use contract::{ContractIface, FungibleAllocation, TypedState}; pub use iface::{ ArgMap, ArgSpec, AssignIface, ExtensionIface, GenesisIface, GlobalIface, Iface, IfaceId, From 044069e541cba3798e85409a7fd754474d0db2b3 Mon Sep 17 00:00:00 2001 From: Dr Maxim Orlovsky Date: Fri, 14 Jul 2023 22:41:43 +0200 Subject: [PATCH 5/5] iface: move script to be the last field in impl --- std/src/interface/iimpl.rs | 2 +- std/src/stl/stl.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/std/src/interface/iimpl.rs b/std/src/interface/iimpl.rs index 900e1c32..543e516f 100644 --- a/std/src/interface/iimpl.rs +++ b/std/src/interface/iimpl.rs @@ -175,12 +175,12 @@ pub struct IfaceImpl { pub version: VerNo, pub schema_id: SchemaId, pub iface_id: IfaceId, - pub script: Script, pub global_state: TinyOrdSet>, pub assignments: TinyOrdSet>, pub valencies: TinyOrdSet>, pub transitions: TinyOrdSet>, pub extensions: TinyOrdSet>, + pub script: Script, } impl CommitStrategy for IfaceImpl { diff --git a/std/src/stl/stl.rs b/std/src/stl/stl.rs index a3a863ff..ccd0f273 100644 --- a/std/src/stl/stl.rs +++ b/std/src/stl/stl.rs @@ -41,7 +41,7 @@ pub const LIB_ID_RGB_CONTRACT: &str = "price_canvas_oliver_9Te5P6nq3oaDHMgttLEbkojbeQPTqqZLhjxZ3my1F8aJ"; /// Strict types id for the library representing of RGB StdLib data types. -pub const LIB_ID_RGB_STD: &str = "inca_hand_city_7kuGjzCd8CYWU3XJd5LoCswYjXd7oPWqvXXC2PmpSA8r"; +pub const LIB_ID_RGB_STD: &str = "parent_maze_jessica_3KXsWZ6hSKRbPjSVwRGbwnwJp3ZNQ2tfe6QUwLJEDG6K"; fn _rgb_std_stl() -> Result { LibBuilder::new(libname!(LIB_NAME_RGB_STD), tiny_bset! {