WIP: Integrate optimality checker

Still missing parse_for and parse_if

Author: lucidLuckylee

src/generate.rs

@@ -4,32 +4,26 @@ use proc_macro2::{Ident, Span, TokenStream};
 use quote::{quote, quote_spanned};
 
 pub fn generate(syntax: Vec<(Syntax, Span)>) -> TokenStream {
-    let mut tokens = quote!(::bitcoin::blockdata::script::Builder::new());
+    let mut tokens = quote!(pushable::Builder::new());
 
     for (item, span) in syntax {
         let push = match item {
-            Syntax::Opcode(opcode) => generate_opcode(opcode, span),
+            Syntax::Opcode(opcode) =>generate_opcode(opcode, span),
             Syntax::Bytes(bytes) => generate_bytes(bytes, span),
             Syntax::Int(int) => generate_int(int, span),
-            Syntax::Escape(expression) => {
-                let builder = tokens;
-                tokens = TokenStream::new();
-                generate_escape(builder, expression, span)
-            }
+            Syntax::Escape(expression) => generate_escape(expression, span)
         };
         tokens.extend(push);
     }
 
-    tokens.extend(quote!(.into_script()));
+    tokens.extend(quote!(.0.into_script()));
     tokens
 }
 
 fn generate_opcode(opcode: Opcode, span: Span) -> TokenStream {
     let ident = Ident::new(opcode.to_string().as_ref(), span);
     quote_spanned!(span=>
-        .push_opcode(
-            ::bitcoin::blockdata::opcodes::all::#ident
-        )
+            .push_opcode(::bitcoin::blockdata::opcodes::all::#ident)
     )
 }
 
@@ -45,19 +39,8 @@ fn generate_int(n: i64, span: Span) -> TokenStream {
     quote_spanned!(span=>.push_int(#n))
 }
 
-fn generate_escape(builder: TokenStream, expression: TokenStream, span: Span) -> TokenStream {
+fn generate_escape(expression: TokenStream, span: Span) -> TokenStream {
     quote_spanned!(span=>
-            (|builder, value| {
-                #[allow(clippy::all)]
-                
-                use ::bitcoin::blockdata::script::Builder;
-                fn push<T: pushable::Pushable>(builder: Builder, value: T) -> Builder {
-                    value.bitcoin_script_push(builder)
-                }
-                push(builder, value)
-            })(
-                #builder,
-                #expression
-            )
-        )
+            .push_expression(#expression)
+    )
 }

src/lib.rs

@@ -136,87 +136,242 @@ pub fn script(tokens: TokenStream) -> TokenStream {
 #[proc_macro]
 pub fn define_pushable(_: TokenStream) -> TokenStream {
     quote!(
-        pub mod pushable {
-
-            use bitcoin::blockdata::opcodes::Opcode;
-            use bitcoin::blockdata::script::Builder;
-            use bitcoin::blockdata::script::PushBytesBuf;
-            use std::convert::TryFrom;
-
-            // We split up the bitcoin_script_push function to allow pushing a single u8 value as
-            // an integer (i64), Vec<u8> as raw data and Vec<T> for any T: Pushable object that is
-            // not a u8. Otherwise the Vec<u8> and Vec<T: Pushable> definitions conflict.
-            trait NotU8Pushable {
-                fn bitcoin_script_push(self, builder: Builder) -> Builder;
-            }
-            impl NotU8Pushable for Opcode {
-                fn bitcoin_script_push(self, builder: Builder) -> Builder {
-                    builder.push_opcode(self)
+    pub mod pushable {
+
+        use bitcoin::blockdata::opcodes::{all::*, Opcode};
+        use bitcoin::blockdata::script::Builder as BitcoinBuilder;
+        use bitcoin::blockdata::script::{PushBytesBuf, Script};
+        use std::convert::TryFrom;
+
+        pub struct Builder(pub BitcoinBuilder);
+
+        pub fn check_optimality(opcode: Opcode, next_opcode: Opcode) {
+            match (opcode, next_opcode) {
+                (OP_PUSHNUM_1, OP_ADD) => eprintln!("Script can be optimized: 1 OP_ADD => OP_1ADD"),
+                (OP_PUSHNUM_1, OP_SUB) => eprintln!("Script can be optimized: 1 OP_SUB => OP_1SUB"),
+                (OP_DROP, OP_DROP) => {
+                    eprintln!("Script can be optimized: OP_DROP OP_DROP => OP_2DROP")
                 }
-            }
-            impl NotU8Pushable for i64 {
-                fn bitcoin_script_push(self, builder: Builder) -> Builder {
-                    builder.push_int(self)
+                (OP_PUSHBYTES_0, OP_ROLL) => eprintln!("Script can be optimized: Remove 0 OP_ROLL"),
+                (OP_PUSHNUM_1, OP_ROLL) => {
+                    eprintln!("Script can be optimized: 1 OP_ROLL => OP_SWAP")
                 }
-            }
-            impl NotU8Pushable for i32 {
-                fn bitcoin_script_push(self, builder: Builder) -> Builder {
-                    builder.push_int(self as i64)
+                (OP_PUSHNUM_2, OP_ROLL) => {
+                    eprintln!("Script can be optimized: 2 OP_ROLL => OP_ROT")
                 }
-            }
-            impl NotU8Pushable for u32 {
-                fn bitcoin_script_push(self, builder: Builder) -> Builder {
-                    builder.push_int(self as i64)
+                (OP_PUSHBYTES_0, OP_PICK) => {
+                    eprintln!("Script can be optimized: 0 OP_PICK => OP_DUP")
                 }
-            }
-            impl NotU8Pushable for usize {
-                fn bitcoin_script_push(self, builder: Builder) -> Builder {
-                    builder.push_int(
-                        i64::try_from(self).unwrap_or_else(|_| panic!("Usize does not fit in i64")),
-                    )
+                (OP_PUSHBYTES_1, OP_PICK) => {
+                    eprintln!("Script can be optimized: 1 OP_PICK => OP_OVER")
                 }
+                (OP_IF, OP_ELSE) => eprintln!("Script can be optimized: OP_IF OP_ELSE => OP_NOTIF"),
+                (_, _) => (),
             }
-            impl NotU8Pushable for Vec<u8> {
-                fn bitcoin_script_push(self, builder: Builder) -> Builder {
-                    builder.push_slice(PushBytesBuf::try_from(self).unwrap())
-                }
+        }
+
+        impl Builder {
+            pub fn new() -> Self {
+                let builder = BitcoinBuilder::new();
+                Builder(builder)
             }
-            impl NotU8Pushable for ::bitcoin::PublicKey {
-                fn bitcoin_script_push(self, builder: Builder) -> Builder {
-                    builder.push_key(&self)
-                }
+
+            pub fn as_bytes(&self) -> &[u8] {
+                self.0.as_bytes()
             }
-            impl NotU8Pushable for ::bitcoin::ScriptBuf {
-                fn bitcoin_script_push(self, builder: Builder) -> Builder {
-                    let mut script_vec = vec![];
-                    script_vec.extend_from_slice(builder.as_bytes());
-                    script_vec.extend_from_slice(self.as_bytes());
-                    Builder::from(script_vec)
-                }
+
+            pub fn as_script(&self) -> &Script {
+                self.0.as_script()
             }
-            impl<T: NotU8Pushable> NotU8Pushable for Vec<T> {
-                fn bitcoin_script_push(self, mut builder: Builder) -> Builder {
-                    for pushable in self {
-                        builder = pushable.bitcoin_script_push(builder);
-                    }
-                    builder
-                }
+
+            pub fn push_opcode(mut self, opcode: Opcode) -> Builder {
+                match self.as_script().instructions_minimal().last() {
+                    Some(instr_result) => match instr_result {
+                        Ok(instr) => match instr {
+                            bitcoin::script::Instruction::PushBytes(push_bytes) => {
+                                if push_bytes.as_bytes() == [] {
+                                    check_optimality(::bitcoin::opcodes::all::OP_PUSHBYTES_0, opcode)
+                                }
+                            },
+                            bitcoin::script::Instruction::Op(previous_opcode) => {
+                                check_optimality(previous_opcode, opcode)
+                            }
+                        },
+                        Err(_) => eprintln!("Script includes non-minimal pushes."),
+                    },
+                    None => (),
+                };
+                self.0 = self.0.push_opcode(opcode);
+                self
+            }
+
+            pub fn push_int(mut self, int: i64) -> Builder {
+                self.0 = self.0.push_int(int);
+                self
             }
-            pub trait Pushable {
-                fn bitcoin_script_push(self, builder: Builder) -> Builder;
+
+            pub fn push_slice(mut self, slice: PushBytesBuf) -> Builder {
+                self.0 = self.0.push_slice(slice);
+                self
+            }
+
+            pub fn push_key(mut self, pub_key: &::bitcoin::PublicKey) -> Builder {
+                self.0 = self.0.push_key(pub_key);
+                self
             }
-            impl<T: NotU8Pushable> Pushable for T {
-                fn bitcoin_script_push(self, builder: Builder) -> Builder {
-                    NotU8Pushable::bitcoin_script_push(self, builder)
+
+            pub fn push_expression<T: Pushable>(self, expression: T) -> Builder {
+                let last_opcode_index = match self.as_script().instruction_indices_minimal().last()
+                {
+                    Some(instr_result) => match instr_result {
+                        Ok((index, instr)) => match instr {
+                            bitcoin::script::Instruction::PushBytes(push_bytes) => {
+                                // Seperately handle OP_0 because it is turned into a PushBytes
+                                // struct in the Script instruction
+                                if push_bytes.as_bytes() == [] {
+                                    Some((index, ::bitcoin::opcodes::all::OP_PUSHBYTES_0))
+                                } else {
+                                    None
+                                }
+                            },
+                            bitcoin::script::Instruction::Op(opcode) => Some((index, opcode)),
+                        },
+                        Err(_) => {
+                            eprintln!("Script includes non-minimal pushes.");
+                            None
+                        }
+                    },
+                    None => None,
+                };
+                let builder = expression.bitcoin_script_push(self);
+                if let Some((last_index, previous_opcode)) = last_opcode_index {
+                    match builder
+                        .as_script()
+                        .instructions_minimal()
+                        .skip(last_index + 1)
+                        .next()
+                    {
+                        Some(instr_result) => match instr_result {
+                            Ok(instr) => match instr {
+                                bitcoin::script::Instruction::PushBytes(_) => (),
+                                bitcoin::script::Instruction::Op(opcode) => {
+                                    check_optimality(previous_opcode, opcode)
+                                }
+                            },
+                            Err(_) => eprintln!("Script includes non-minimal pushes."),
+                        },
+                        None => eprintln!("Script extends an empty script!"),
+                    };
                 }
+                builder
             }
+        }
 
-            impl Pushable for u8 {
-                fn bitcoin_script_push(self, builder: Builder) -> Builder {
-                    builder.push_int(self as i64)
+        impl From<Vec<u8>> for Builder {
+            fn from(v: Vec<u8>) -> Builder {
+                let builder = BitcoinBuilder::from(v);
+                Builder(builder)
+            }
+        }
+        // We split up the bitcoin_script_push function to allow pushing a single u8 value as
+        // an integer (i64), Vec<u8> as raw data and Vec<T> for any T: Pushable object that is
+        // not a u8. Otherwise the Vec<u8> and Vec<T: Pushable> definitions conflict.
+        trait NotU8Pushable {
+            fn bitcoin_script_push(self, builder: Builder) -> Builder;
+        }
+        impl NotU8Pushable for i64 {
+            fn bitcoin_script_push(self, builder: Builder) -> Builder {
+                builder.push_int(self)
+            }
+        }
+        impl NotU8Pushable for i32 {
+            fn bitcoin_script_push(self, builder: Builder) -> Builder {
+                builder.push_int(self as i64)
+            }
+        }
+        impl NotU8Pushable for u32 {
+            fn bitcoin_script_push(self, builder: Builder) -> Builder {
+                builder.push_int(self as i64)
+            }
+        }
+        impl NotU8Pushable for usize {
+            fn bitcoin_script_push(self, builder: Builder) -> Builder {
+                builder.push_int(
+                    i64::try_from(self).unwrap_or_else(|_| panic!("Usize does not fit in i64")),
+                )
+            }
+        }
+        impl NotU8Pushable for Vec<u8> {
+            fn bitcoin_script_push(self, builder: Builder) -> Builder {
+                builder.push_slice(PushBytesBuf::try_from(self).unwrap())
+            }
+        }
+        impl NotU8Pushable for ::bitcoin::PublicKey {
+            fn bitcoin_script_push(self, builder: Builder) -> Builder {
+                builder.push_key(&self)
+            }
+        }
+        impl NotU8Pushable for ::bitcoin::ScriptBuf {
+            fn bitcoin_script_push(self, builder: Builder) -> Builder {
+                let previous_opcode = match self.as_script().instructions_minimal().last() {
+                    Some(instr_result) => match instr_result {
+                        Ok(instr) => match instr {
+                            bitcoin::script::Instruction::PushBytes(_) => None,
+                            bitcoin::script::Instruction::Op(previous_opcode) => {
+                                Some(previous_opcode)
+                            }
+                        },
+                        Err(_) => {
+                            eprintln!("Script includes non-minimal pushes.");
+                            None
+                        }
+                    },
+                    None => None,
+                };
+
+                if let Some(previous_opcode) = previous_opcode {
+                    match self.as_script().instructions_minimal().last() {
+                        Some(instr_result) => match instr_result {
+                            Ok(instr) => match instr {
+                                bitcoin::script::Instruction::PushBytes(_) => (),
+                                bitcoin::script::Instruction::Op(opcode) => {
+                                    check_optimality(previous_opcode, opcode)
+                                }
+                            },
+                            Err(_) => eprintln!("Script includes non-minimal pushes."),
+                        },
+                        None => (),
+                    }
+                };
+                let mut script_vec = vec![];
+                script_vec.extend_from_slice(builder.as_bytes());
+                script_vec.extend_from_slice(self.as_bytes());
+                Builder::from(script_vec)
+            }
+        }
+        impl<T: NotU8Pushable> NotU8Pushable for Vec<T> {
+            fn bitcoin_script_push(self, mut builder: Builder) -> Builder {
+                for pushable in self {
+                    builder = pushable.bitcoin_script_push(builder);
                 }
+                builder
+            }
+        }
+        pub trait Pushable {
+            fn bitcoin_script_push(self, builder: Builder) -> Builder;
+        }
+        impl<T: NotU8Pushable> Pushable for T {
+            fn bitcoin_script_push(self, builder: Builder) -> Builder {
+                NotU8Pushable::bitcoin_script_push(self, builder)
+            }
+        }
+
+        impl Pushable for u8 {
+            fn bitcoin_script_push(self, builder: Builder) -> Builder {
+                builder.push_int(self as i64)
             }
         }
+    }
     )
     .into()
 }

src/parse.rs

@@ -151,10 +151,21 @@ where
             Group(block) if block.delimiter() == Delimiter::Brace => {
                 let inner_block = block.stream();
                 escape.extend(quote! {
-                    {
-                        script_var.extend_from_slice(script !{
+                    {   
+                        let next_script = script !{
                             #inner_block
-                        }.as_bytes());
+                        };
+                        if script_var.len() > 0 {
+                            if next_script.as_bytes().len() == 0 {
+                                eprintln!("Script can be optimized: Inner block of a for loop iteration is empty.");
+                            } else {
+                                // TODO this could be a data push
+                                let previous_opcode = ::bitcoin::opcodes::Opcode::from(script_var[script_var.len() - 1]);
+                                let opcode = ::bitcoin::opcodes::Opcode::from(next_script.as_bytes()[0]);
+                                pushable::check_optimality(previous_opcode, opcode);
+                            }
+                        }
+                        script_var.extend_from_slice(next_script.as_bytes());
                     }
                     bitcoin::script::ScriptBuf::from(script_var)
                 });