feat: ability to run scripts

example in counter: clarinet run scripts/abi.ts

Author: lgalabru

deno/index.ts

@@ -189,6 +189,26 @@ interface UnitTestOptions {
   fn: TestFunction;
 }
 
+export interface Contract {
+  contract_id: string;
+  source: string;
+  contract_interface: any
+}
+
+export interface StacksNode {
+  url: string;
+}
+
+type ScriptFunction = (
+  accounts: Map<string, Account>,
+  contracts: Map<string, Contract>,
+  node: StacksNode,
+) => void | Promise<void>;
+
+interface ScriptOptions {
+  fn: ScriptFunction;
+}
+
 export class Clarinet {
   static test(options: UnitTestOptions) {
     Deno.test({
@@ -213,6 +233,32 @@ export class Clarinet {
       },
     });
   }
+
+  static run(options: ScriptOptions) {
+    Deno.test({
+      name: "running script",
+      async fn() {
+        (Deno as any).core.ops();
+        let result = JSON.parse((Deno as any).core.opSync("setup_chain", {
+          name: "running script",
+          transactions: [],
+        }));
+        let accounts: Map<string, Account> = new Map();
+        for (let account of result["accounts"]) {
+          accounts.set(account.name, account);
+        }
+        let contracts: Map<string, any> = new Map();
+        for (let contract of result["contracts"]) {
+          contracts.set(contract.contract_id, contract);
+        }
+        let stacks_node: StacksNode = {
+          url: result["stacks_node_url"]
+        };
+        await options.fn(accounts, contracts, stacks_node);
+      },
+    });
+  }
+
 }
 
 export namespace types {

examples/counter/.vscode/settings.json

@@ -1,7 +1,4 @@
 {
-    "git.ignoreLimitWarning": true,
     "deno.enable": true,
     "deno.unstable": false,
-    "editor.formatOnSave": true,
-    "editor.formatOnPaste": true,
 }

examples/counter/contracts/counter.clar

@@ -6,6 +6,7 @@
 (define-public (increment (step uint))
     (let ((new-val (+ step (var-get counter)))) 
         (var-set counter new-val)
+        (print { object: "counter", action: "incremented", value: new-val })
         (ok new-val)))
 
 (define-read-only (read-counter)

examples/counter/scripts/abi.ts

@@ -0,0 +1,15 @@
+import { Clarinet, Contract, Account, StacksNode } from 'https://deno.land/x/clarinet@v0.11.0/index.ts';
+
+Clarinet.run({
+    async fn(accounts: Map<string, Account>, contracts: Map<string, Contract>, node: StacksNode) {
+        console.log("Contracts");
+        for (let contract of contracts) {
+            console.log(contract);
+        }
+        console.log("Accounts");
+        for (let account of accounts) {
+            console.log(account);
+        }
+
+    }
+});

examples/counter/tests/counter_test.ts

@@ -1,4 +1,4 @@
-import { Clarinet, Tx, Chain, Account, types } from 'https://deno.land/x/clarinet@v0.6.0/index.ts';
+import { Clarinet, Tx, Chain, Account, types } from 'https://deno.land/x/clarinet@v0.11.0/index.ts';
 import { assertEquals } from "https://deno.land/std@0.90.0/testing/asserts.ts";
 
 Clarinet.test({
@@ -26,6 +26,7 @@ Clarinet.test({
             Tx.contractCall("counter", "increment", [types.uint(4)], wallet_1.address),
             Tx.contractCall("counter", "increment", [types.uint(10)], wallet_1.address)
         ]);
+
         assertEquals(block.height, 3);
         block.receipts[0].result
             .expectOk()

src/frontend/cli.rs

@@ -44,6 +44,9 @@ enum Command {
     /// Deploy subcommand
     #[clap(name = "deploy")]
     Deploy(Deploy),
+    /// Run subcommand
+    #[clap(name = "run")]
+    Run(Run),
 }
 
 #[derive(Clap)]
@@ -120,6 +123,15 @@ struct Test {
     pub files: Vec<String>,
 }
 
+#[derive(Clap)]
+struct Run {
+    /// Print debug info
+    #[clap(short = 'd')]
+    pub debug: bool,
+    /// Script to run
+    pub script: String,
+}
+
 #[derive(Clap)]
 struct Deploy {
     /// Print debug info
@@ -234,6 +246,15 @@ pub fn main() {
             }
             run_tests(test.files, test.coverage, test.watch);
         },
+        Command::Run(run) => {
+            let start_repl = false;
+            let res = load_session(start_repl, "development".into());
+            if let Err(e) = res {
+                println!("{}", e);
+                return;
+            }
+            run_tests(vec![run.script], false, false);
+        },
         Command::Deploy(deploy) => {
             let start_repl = false;
             let mode = if deploy.mocknet == true {

src/generators/contract.rs

@@ -66,7 +66,7 @@ impl GetChangesForNewContract {
     fn create_template_test(&mut self) {
         let content = format!(
             r#"
-import {{ Clarinet, Tx, Chain, Account, types }} from 'https://deno.land/x/clarinet@v0.10.0/index.ts';
+import {{ Clarinet, Tx, Chain, Account, types }} from 'https://deno.land/x/clarinet@v0.11.0/index.ts';
 import {{ assertEquals }} from 'https://deno.land/std@0.90.0/testing/asserts.ts';
 
 Clarinet.test({{

src/test/deno.rs

@@ -44,6 +44,7 @@ mod sessions {
     use std::fs;
     use std::env;
     use std::collections::HashMap;
+    use clarity_repl::clarity::analysis::ContractAnalysis;
     use deno_core::error::AnyError;
     use clarity_repl::repl::{self, Session};
     use clarity_repl::repl::settings::Account;
@@ -54,7 +55,7 @@ mod sessions {
         pub static ref SESSIONS: Mutex<HashMap<u32, (String, Session)>> = Mutex::new(HashMap::new());
     }
 
-    pub fn handle_setup_chain(name: String, transactions: Vec<TransactionArgs>) -> Result<(u32, Vec<Account>), AnyError> {
+    pub fn handle_setup_chain(name: String, transactions: Vec<TransactionArgs>) -> Result<(u32, Vec<Account>, Vec<(ContractAnalysis, String)>), AnyError> {
         let mut sessions = SESSIONS.lock().unwrap();
         let session_id = sessions.len() as u32;
 
@@ -133,10 +134,10 @@ mod sessions {
         settings.initial_deployer = initial_deployer;
         settings.include_boot_contracts = vec!["pox".to_string(), "costs".to_string(), "bns".to_string()];
         let mut session = Session::new(settings.clone());
-        session.start();
+        let (_, contracts) = session.start();
         session.advance_chain_tip(1);
         sessions.insert(session_id, (name, session));
-        Ok((session_id, settings.initial_accounts))
+        Ok((session_id, settings.initial_accounts, contracts))
     }
 
     pub fn perform_block<F, R>(session_id: u32, handler: F) -> Result<R, AnyError> where F: FnOnce(&str, &mut Session) -> Result<R, AnyError> {
@@ -702,11 +703,17 @@ struct SetupChainArgs {
 fn setup_chain(state: &mut OpState, args: Value, _: ()) -> Result<String, AnyError> {
     let args: SetupChainArgs = serde_json::from_value(args)
       .expect("Invalid request from JavaScript for \"op_load\".");
-    let (session_id, accounts) = sessions::handle_setup_chain(args.name, args.transactions)?;
+    let (session_id, accounts, contracts) = sessions::handle_setup_chain(args.name, args.transactions)?;
+    let serialized_contracts = contracts.iter().map(|(a, s)| json!({
+      "contract_id": a.contract_identifier.to_string(),
+      "contract_interface": a.contract_interface.clone(),
+      "source": s
+    })).collect::<Vec<_>>();
 
     Ok(json!({
         "session_id": session_id,
         "accounts": accounts,
+        "contracts": serialized_contracts,
     }).to_string())
 }