faet: principals support

Author: hugoclrd

.vscode/settings.json

@@ -1,5 +1,5 @@
 {
-  "rust-analyzer.check.command": "clippy",
+  // "rust-analyzer.check.command": "clippy",
   // rust-analyzer hack:
   // manually set --workspace in extraArgs so that it's always set only one time
   "rust-analyzer.check.workspace": false,

Cargo.lock

@@ -33,6 +33,7 @@ clarinet-format = { path = "../clarinet-format" }
 clarinet-deployments = { path = "../clarinet-deployments" }
 hiro-system-kit = { path = "../hiro-system-kit" }
 stacks-network = { path = "../stacks-network" }
+ts-to-clar = { path = "../ts-to-clar" }
 
 [target.'cfg(unix)'.dependencies]
 nix = "0.29.0"

components/clarinet-cli/Cargo.toml

@@ -91,6 +91,9 @@ enum Command {
     /// Subcommands for Devnet usage
     #[clap(subcommand, name = "devnet")]
     Devnet(Devnet),
+    /// Subcommands ts-to-clar transpiler usage
+    #[clap(name = "build", aliases = &["transpile"], bin_name = "build")]
+    Build(Build),
     /// Get Clarity autocompletion and inline errors from your code editor (VSCode, vim, emacs, etc)
     #[clap(name = "lsp", bin_name = "lsp")]
     LSP,
@@ -102,6 +105,12 @@ enum Command {
     DAP,
 }
 
+#[derive(Parser, PartialEq, Clone, Debug)]
+struct Build {
+    #[clap(long = "path", short = 'p')]
+    pub path: Option<String>,
+}
+
 #[derive(Parser, PartialEq, Clone, Debug)]
 struct Formatter {
     #[clap(long = "manifest-path", short = 'm')]
@@ -1367,6 +1376,24 @@ pub fn main() {
             }
             Devnet::DevnetStart(cmd) => devnet_start(cmd, clarinetrc),
         },
+        Command::Build(Build { path }) => {
+            let file_name = path.unwrap_or_else(|| {
+                eprintln!("No file path provided. Please specify a .clar.ts file.");
+                process::exit(1);
+            });
+            let file_path = std::path::Path::new(&file_name);
+            let extension = file_path.extension().unwrap_or_default();
+            assert_eq!(extension, "ts");
+            assert!(file_path.is_file());
+            assert!(file_name.ends_with(".clar.ts"));
+
+            let output_path = file_name.strip_suffix(".ts").unwrap();
+
+            let src = std::fs::read_to_string(file_path).unwrap();
+            let clarity_code = ts_to_clar::transpile(&file_name, &src).unwrap();
+            std::fs::write(output_path, clarity_code).unwrap();
+            println!("Transpiled {file_name} to {output_path}");
+        }
     };
 }
 

components/clarinet-cli/src/frontend/cli.rs

@@ -9,12 +9,12 @@ license = "GPL-3.0"
 anyhow = "1.0.98"
 
 oxc_allocator = "0.75"
-oxc_ast = { version = "0.75", features = ["serialize"] }
+oxc_ast = { version = "0.75" }
 oxc_ast_visit = "0.75"
 oxc_parser = "0.75"
 oxc_span = "0.75"
 oxc_syntax = "0.75"
-oxc_traverse = "0.75"
+oxc_traverse = { version = "0.75" }
 oxc_semantic = "0.75"
 
 clarity = { workspace = true }

components/ts-to-clar/Cargo.toml

@@ -4,7 +4,7 @@ use std::vec;
 
 use clarity::vm::{
     representations::{PreSymbolicExpression, PreSymbolicExpressionType, Span},
-    types::{SequenceSubtype, StringSubtype, TypeSignature as ClarityTypeSignature},
+    types::{PrincipalData, SequenceSubtype, StringSubtype, TypeSignature as ClarityTypeSignature},
     ClarityName, Value as ClarityValue,
 };
 use oxc_allocator::Allocator;
@@ -23,6 +23,9 @@ fn type_signature_to_pse(
         ClarityTypeSignature::UIntType => PreSymbolicExpression::atom(ClarityName::from("uint")),
         ClarityTypeSignature::IntType => PreSymbolicExpression::atom(ClarityName::from("int")),
         ClarityTypeSignature::BoolType => PreSymbolicExpression::atom(ClarityName::from("bool")),
+        ClarityTypeSignature::PrincipalType => {
+            PreSymbolicExpression::atom(ClarityName::from("principal"))
+        }
         ClarityTypeSignature::SequenceType(seq_subtype) => match seq_subtype {
             SequenceSubtype::StringType(string_subtype) => match string_subtype {
                 StringSubtype::ASCII(len) => PreSymbolicExpression::list(vec![
@@ -80,6 +83,22 @@ fn convert_expression_with_type(
             }
             _ => return Err(anyhow::anyhow!("Invalid expression for Bool")),
         },
+        ClarityTypeSignature::PrincipalType => match &expr {
+            OxcExpression::StringLiteral(str) => PreSymbolicExpression::atom_value(
+                ClarityValue::Principal(PrincipalData::parse(str.value.as_str())?),
+            ),
+            OxcExpression::Identifier(ident) => {
+                if ident.name == "txSender" {
+                    PreSymbolicExpression::atom(ClarityName::from("tx-sender"))
+                } else {
+                    return Err(anyhow::anyhow!(
+                        "Invalid identifier for Principal: {}",
+                        ident.name
+                    ));
+                }
+            }
+            _ => return Err(anyhow::anyhow!("Invalid expression for Principal")),
+        },
         ClarityTypeSignature::SequenceType(SequenceSubtype::StringType(StringSubtype::ASCII(
             _len,
         ))) => match &expr {
@@ -124,7 +143,7 @@ fn convert_expression_with_type(
 
             _ => return Err(anyhow::anyhow!("Unsupported expression for Tuple")),
         },
-        _ => return Err(anyhow::anyhow!("Unsupported type for constant")),
+        _ => return Err(anyhow::anyhow!("Unsupported type for variable")),
     })
 }
 
@@ -167,7 +186,7 @@ fn convert_function(
         .parameters
         .iter()
         .map(|(name, r#type)| {
-            let name = PreSymbolicExpression::atom(ClarityName::from(name.as_str()));
+            let name = PreSymbolicExpression::atom(ClarityName::from(to_kebab_case(name).as_str()));
             let r#type = type_signature_to_pse(r#type)?;
             Ok(vec![name, r#type])
         })
@@ -331,6 +350,19 @@ mod test {
     // The following tests use the assert_pses_eq function to dynamically
     // build the expected PSEs from the Clarity source code.
 
+    #[test]
+    fn test_principal_data_var() {
+        let ts_src =
+            "const owner = new DataVar<Principal>(\"ST3PF13W7Z0RRM42A8VZRVFQ75SV1K26RXEP8YGKJ\");";
+        assert_pses_eq(
+            ts_src,
+            r#"(define-data-var owner principal 'ST3PF13W7Z0RRM42A8VZRVFQ75SV1K26RXEP8YGKJ)"#,
+        );
+
+        let ts_src = "const owner = new DataVar<Principal>(txSender);";
+        assert_pses_eq(ts_src, r#"(define-data-var owner principal tx-sender)"#);
+    }
+
     #[test]
     fn test_convert_tuple_type() {
         let ts_src = "const state = new DataVar<{ ok: Int }>({ ok: 1 });";
@@ -416,4 +448,19 @@ mod test {
         };
         assert_pses_eq(ts_src, r#"(define-public (myfunc) (ok true))"#);
     }
+
+    #[test]
+    fn test_function_arg_casing() {
+        let ts_src = indoc! {
+            r#"const addr = new DataVar<Principal>(txSender);
+            function updateAddr(newAddr: Principal) { return ok(addr.set(newAddr)); }"#
+        };
+        assert_pses_eq(
+            ts_src,
+            indoc! {
+                r#"(define-data-var addr principal tx-sender)
+                (define-private (update-addr (new-addr principal)) (ok (var-set addr new-addr)))"#
+            },
+        );
+    }
 }

components/ts-to-clar/src/converter.rs

@@ -33,6 +33,7 @@ fn atom(name: &str) -> PreSymbolicExpression {
 
 fn get_clarity_binary_operator(operator: &ast::BinaryOperator) -> &str {
     use ast::BinaryOperator::*;
+
     match operator {
         Addition => "+",
         Subtraction => "-",
@@ -61,14 +62,20 @@ fn get_clarity_binary_operator(operator: &ast::BinaryOperator) -> &str {
 
 impl<'a> StatementConverter<'a> {
     fn new(ir: &'a IR, function: &'a IRFunction<'a>) -> Self {
+        let current_bindings = function
+            .parameters
+            .iter()
+            .map(|(name, r#type)| (name.to_string(), Some(r#type.clone())))
+            .collect();
+
         Self {
             ir,
             function,
             expressions: Vec::new(),
             lists_stack: vec![],
             current_context_type: None,
             current_context_type_stack: vec![],
-            current_bindings: vec![],
+            current_bindings,
         }
     }
 
@@ -384,13 +391,16 @@ impl<'a> Traverse<'a, ConverterState<'a>> for StatementConverter<'a> {
         }
 
         let ident_name = ident.name.as_str();
+
+        // function call
         let matching_function = self.ir.functions.iter().any(|f| f.name == ident_name);
         if matching_function {
             self.lists_stack
                 .push(atom(to_kebab_case(ident_name).as_str()));
             return;
         }
 
+        // data-var reference
         let matching_data_var = self
             .current_bindings
             .iter()
@@ -401,6 +411,9 @@ impl<'a> Traverse<'a, ConverterState<'a>> for StatementConverter<'a> {
             return;
         }
 
+        //
+
+        // imports
         if let Some((_, name)) = self
             .ir
             .std_specific_imports
@@ -851,4 +864,14 @@ mod test {
         let expected_clar_src = "(let ((my-count1 1) (my-count2 2)) true)";
         assert_last_function_body_eq(ts_src, expected_clar_src);
     }
+
+    #[test]
+    fn test_function_arg_casing() {
+        let ts_src = indoc!(
+            r#"const addr = new DataVar<Principal>(txSender);
+            function updateAddr(newAddr: Principal) { return ok(addr.set(newAddr)); }"#
+        );
+        let expected_clar_src = "(ok (var-set addr new-addr))";
+        assert_last_function_body_eq(ts_src, expected_clar_src);
+    }
 }

components/ts-to-clar/src/expression_converter.rs

@@ -372,6 +372,11 @@ mod test {
         get_ir(allocator, "tmp.clar.ts", src)
     }
 
+    fn expr_identifier<'a>(allocator: &'a Allocator, name: &'a str) -> Expression<'a> {
+        AstBuilder::new(allocator)
+            .expression_identifier(Span::empty(0), Atom::from_in(name.to_string(), allocator))
+    }
+
     fn expr_number<'a>(allocator: &'a Allocator, value: f64) -> Expression<'a> {
         AstBuilder::new(allocator).expression_numeric_literal(
             Span::empty(0),
@@ -425,6 +430,9 @@ mod test {
     fn assert_expr_eq(actual: &Expression, expected: &Expression) {
         use Expression::*;
         match (&actual, &expected) {
+            (Identifier(actual_id), Identifier(expected_id)) => {
+                assert_eq!(actual_id.name, expected_id.name);
+            }
             (NumericLiteral(actual_num), NumericLiteral(expected_num)) => {
                 assert_eq!(actual_num.value, expected_num.value);
             }
@@ -579,6 +587,33 @@ mod test {
         assert_data_var_eq(ir, &expected);
     }
 
+    #[test]
+    fn test_data_var_principal_ir() {
+        let src =
+            "const owner = new DataVar<Principal>(\"ST3AM1A56AK2C1XAFJ4115ZSV26EB49BVQ10MGCS0\");";
+        let allocator = Allocator::default();
+        let ir = &get_tmp_ir(&allocator, src).data_vars[0];
+        let expected = IRDataVar {
+            name: "owner".to_string(),
+            r#type: PrincipalType,
+            expr: expr_string(&allocator, "ST3AM1A56AK2C1XAFJ4115ZSV26EB49BVQ10MGCS0"),
+        };
+        assert_data_var_eq(ir, &expected);
+    }
+
+    #[test]
+    fn test_data_var_tx_sender() {
+        let src = "const owner = new DataVar<Principal>(txSender);";
+        let allocator = Allocator::default();
+        let ir = &get_tmp_ir(&allocator, src).data_vars[0];
+        let expected = IRDataVar {
+            name: "owner".to_string(),
+            r#type: PrincipalType,
+            expr: expr_identifier(&allocator, "txSender"),
+        };
+        assert_data_var_eq(ir, &expected);
+    }
+
     #[test]
     fn test_data_map_ir() {
         let src = "const statuses = new DataMap<Uint, Bool>();";

components/ts-to-clar/src/parser.rs

@@ -40,6 +40,7 @@ fn extract_type(
         "Uint" => Ok(TypeSignature::UIntType),
         "Int" => Ok(TypeSignature::IntType),
         "Bool" => Ok(TypeSignature::BoolType),
+        "Principal" => Ok(TypeSignature::PrincipalType),
         "StringAscii" => extract_numeric_type_param(type_params).map(get_ascii_type),
         "StringUtf8" => extract_numeric_type_param(type_params).map(get_utf8_type),
         _ => Err(anyhow!("Unknown type: {}", type_ident)),