Adapt to starknet 0.11.0

config.json

@@ -1,4 +1,4 @@
 {
-    "CAIRO_LANG": "0.10.3",
+    "CAIRO_LANG": "0.11.0a0",
     "STARKNET_DEVNET": "0.4.6"
 }

src/constants.ts

@@ -2,6 +2,8 @@ import config from "../config.json";
 
 export const PLUGIN_NAME = "Starknet";
 export const ABI_SUFFIX = "_abi.json";
+export const SIERRA_SUFFIX = ".casm";
+export const CARGO_FILE = "Cargo.toml";
 export const DEFAULT_STARKNET_SOURCES_PATH = "contracts";
 export const DEFAULT_STARKNET_ARTIFACTS_PATH = "starknet-artifacts";
 export const DEFAULT_STARKNET_ACCOUNT_PATH = "~/.starknet_accounts";

src/index.ts

@@ -50,7 +50,8 @@ import {
     starknetPluginVersionAction,
     starknetMigrateAction,
     starknetNewAccountAction,
-    starknetDeployAccountAction
+    starknetDeployAccountAction,
+    starknetCompileCairo1Action
 } from "./task-actions";
 import {
     bigIntToShortStringUtil,
@@ -239,6 +240,25 @@ task("starknet-compile", "Compiles Starknet contracts")
     .addFlag("disableHintValidation", "Allows compiling a contract with any python code in hints.")
     .setAction(starknetCompileAction);
 
+task("starknet-compile-cairo1", "Compiles Starknet cairo1 contracts")
+    .addOptionalVariadicPositionalParam(
+        "paths",
+        "The paths to be used for deployment.\n" +
+            "Each of the provided paths is recursively looked into while searching for compilation artifacts.\n" +
+            "If no paths are provided, the default contracts directory is traversed."
+    )
+    .addOptionalParam(
+        "manifestPath",
+        "Allows to specify locally installed cairo1 compiler path.\n" +
+            "e.g. --manifest-path 'path/to/Cargo.toml' or can also be set on hardhat.config.ts file."
+    )
+    .addOptionalParam(
+        "cairoPath",
+        "Allows specifying the locations of imported files, if necessary.\n" +
+            "Separate them with a colon (:), e.g. --cairo-path='path/to/lib1:path/to/lib2'"
+    )
+    .setAction(starknetCompileCairo1Action);
+
 extendEnvironment((hre) => {
     hre.starknet = {
         getContractFactory: async (contractPath) => {

src/starknet-docker-proxy.ts

@@ -22,7 +22,8 @@ export class StarknetDockerProxy extends DockerServer {
         image: Image,
         private rootPath: string,
         private accountPaths: string[],
-        private cairoPaths: string[]
+        private cairoPaths: string[],
+        private manifestPath?: string
     ) {
         super(image, "127.0.0.1", null, "", "starknet-docker-proxy");
     }
@@ -35,6 +36,7 @@ export class StarknetDockerProxy extends DockerServer {
         for (const mirroredPath of [this.rootPath, ...this.accountPaths, ...this.cairoPaths]) {
             volumes.push("-v", `${mirroredPath}:${mirroredPath}`);
         }
+        if (this.manifestPath) volumes.push("-v", `${this.manifestPath}:${this.manifestPath}`);
 
         const dockerArgs = [...volumes];
 

src/starknet-wrappers.ts

@@ -11,12 +11,15 @@ import { FeeEstimation } from "./starknet-types";
 import { hash } from "starknet";
 import { toBN, toHex } from "starknet/utils/number";
 import axios from "axios";
+import path from "path";
 
 interface CompileWrapperOptions {
     file: string;
     output: string;
-    abi: string;
+    abi?: string;
     cairoPath: string;
+    sierraOutput?: string;
+    manifestPath?: string;
     accountContract: boolean;
     disableHintValidation: boolean;
 }
@@ -116,7 +119,7 @@ export abstract class StarknetWrapper {
     }
 
     public async execute(
-        command: "starknet" | "starknet-compile" | "get_class_hash" | "cairo-migrate",
+        command: "starknet" | "starknet-compile" | "get_class_hash" | "cairo-migrate" | "cargo",
         args: string[]
     ): Promise<ProcessResult> {
         return await this.externalServer.post<ProcessResult>({
@@ -153,6 +156,41 @@ export abstract class StarknetWrapper {
         return executed;
     }
 
+    private getCargoRunCommand(bin: string, manifestPath: string, args: string[]): string[] {
+        return [
+            "cargo",
+            "run",
+            "--bin",
+            bin,
+            "--manifest-path",
+            manifestPath,
+            "--",
+            args.join(" "),
+            "--allowed-libfuncs-list-name",
+            "experimental_v0.1.0"
+        ];
+    }
+
+    protected preparedCairoOneCompileOptions(options: CompileWrapperOptions): string[] {
+        const cairoCompile = this.getCargoRunCommand("starknet-compile", options.manifestPath, [
+            options.file,
+            options.output
+        ]);
+        const sierraCompile = this.getCargoRunCommand(
+            "starknet-sierra-compile",
+            options.manifestPath,
+            [options.output, options.sierraOutput]
+        );
+        const ret = [...cairoCompile, "&&", ...sierraCompile];
+        return ret;
+    }
+
+    public async cairo1Compile(options: CompileWrapperOptions): Promise<ProcessResult> {
+        const preparedOptions = this.preparedCairoOneCompileOptions(options);
+        const executed = await this.execute("cargo", preparedOptions);
+        return executed;
+    }
+
     public prepareDeclareOptions(options: DeclareWrapperOptions): string[] {
         const prepared = [
             "declare",
@@ -465,7 +503,14 @@ export class DockerWrapper extends StarknetWrapper {
         cairoPaths: string[],
         hre: HardhatRuntimeEnvironment
     ) {
-        const externalServer = new StarknetDockerProxy(image, rootPath, accountPaths, cairoPaths);
+        const manifestPath = hre.config.starknet?.manifestPath;
+        const externalServer = new StarknetDockerProxy(
+            image,
+            rootPath,
+            accountPaths,
+            cairoPaths,
+            manifestPath ? manifestPath : path.dirname(manifestPath)
+        );
         super(externalServer, hre);
         console.log(
             `${PLUGIN_NAME} plugin using dockerized environment (${getFullImageName(image)})`

src/starknet_cli_wrapper.py

@@ -1,6 +1,7 @@
 """Wrapper of Starknet CLI"""
 
 import asyncio
+import subprocess
 from contextlib import redirect_stderr, redirect_stdout
 from http.server import HTTPServer, BaseHTTPRequestHandler
 import io
@@ -11,8 +12,8 @@
 try:
     from starkware.starknet.cli.starknet_cli import main as starknet_main
     from starkware.starknet.compiler.compile import main as starknet_compile_main
-    from starkware.starknet.core.os.class_hash import compute_class_hash
-    from starkware.starknet.services.api.contract_class import ContractClass
+    from starkware.starknet.core.os.contract_class.deprecated_class_hash import compute_deprecated_class_hash
+    from starkware.starknet.services.api.contract_class.contract_class import DeprecatedCompiledClass
     from starkware.cairo.lang.migrators.migrator import main as cairo_migrate_main
 except ImportError:
     sys.exit("Make sure the environment you configured has starknet (cairo-lang) installed!")
@@ -30,13 +31,26 @@ async def starknet_compile_main_wrapper(args):
         print(err, file=sys.stderr)
         return 1
 
+async def cargo_run(args):
+    sys.argv = [sys.argv[0], *args]
+    try:
+        args_split = " ".join(args).split("&&")
+        starknet_compile = args_split[0]
+        starknet_sierra_compile = args_split[1]
+        subprocess.run(starknet_compile, shell=True)
+        subprocess.run(starknet_sierra_compile, shell=True)
+        return 0
+    except Exception as err:
+        print(err, file=sys.stderr)
+        return 1
+
 async def get_class_hash(args):
     path ,= args
     with open(path, encoding="utf-8") as file:
         raw_class = json.load(file)
 
-    loaded_class = ContractClass.load(raw_class)
-    class_hash = compute_class_hash(loaded_class)
+    loaded_class = DeprecatedCompiledClass.load(raw_class)
+    class_hash = compute_deprecated_class_hash(loaded_class)
     print(hex(class_hash))
     return 0
 
@@ -51,6 +65,7 @@ async def cairo_migrate_main_wrapper(args):
 MAIN_MAP = {
     "starknet": starknet_main_wrapper,
     "starknet-compile": starknet_compile_main_wrapper,
+    "cargo": cargo_run,
     "get_class_hash": get_class_hash,
     "cairo-migrate": cairo_migrate_main_wrapper
 }

src/task-actions.ts

@@ -3,7 +3,13 @@ import * as fs from "fs";
 import axios from "axios";
 import FormData = require("form-data");
 import { StarknetPluginError } from "./starknet-plugin-error";
-import { ABI_SUFFIX, ALPHA_TESTNET, DEFAULT_STARKNET_NETWORK } from "./constants";
+import {
+    ABI_SUFFIX,
+    ALPHA_TESTNET,
+    CARGO_FILE,
+    DEFAULT_STARKNET_NETWORK,
+    SIERRA_SUFFIX
+} from "./constants";
 import { ProcessResult } from "@nomiclabs/hardhat-docker";
 import {
     adaptLog,
@@ -74,6 +80,89 @@ function getFileName(filePath: string) {
     return path.basename(filePath, path.extname(filePath));
 }
 
+export async function starknetCompileCairo1Action(
+    args: TaskArguments,
+    hre: HardhatRuntimeEnvironment
+) {
+    const manifestPath = hre.config.starknet.manifestPath || args?.manifestPath;
+    if (!manifestPath) {
+        const msg =
+            "Could not find manifest-path\n" +
+            "The argument '—-manifest-path path/to/Cargo.toml' or manifestPath on hardhat.config.ts should be set.";
+        throw new StarknetPluginError(msg);
+    }
+
+    if (path.basename(manifestPath) !== CARGO_FILE) {
+        const msg = "The manifest-path must be a path to a Cargo.toml file";
+        throw new StarknetPluginError(msg);
+    }
+
+    const root = hre.config.paths.root;
+    const rootRegex = new RegExp("^" + root);
+
+    const defaultSourcesPath = hre.config.paths.starknetSources;
+    const sourcesPaths: string[] = args.paths || [defaultSourcesPath];
+    const artifactsPath = hre.config.paths.starknetArtifacts;
+
+    const cairoPaths = [defaultSourcesPath, root];
+    if (args.cairoPath) {
+        args.cairoPath.split(":").forEach((path: string) => {
+            cairoPaths.push(path);
+        });
+    }
+    if (hre.config.paths.cairoPaths) {
+        hre.config.paths.cairoPaths.forEach((path: string) => {
+            cairoPaths.push(path);
+        });
+    }
+    for (let i = 0; i < cairoPaths.length; i++) {
+        if (!path.isAbsolute(cairoPaths[i])) {
+            cairoPaths[i] = adaptPath(root, cairoPaths[i]);
+        }
+    }
+
+    const cairoPath = cairoPaths.join(":");
+    let statusCode = 0;
+    for (let sourcesPath of sourcesPaths) {
+        sourcesPath = adaptPath(root, sourcesPath);
+        checkSourceExists(sourcesPath);
+        const files = await traverseFiles(sourcesPath, "*.cairo");
+        const recompiler = new Recompiler(hre);
+        for (const file of files) {
+            console.log("Compiling", file);
+            const suffix = file.replace(rootRegex, "");
+            const fileName = getFileName(suffix);
+            const dirPath = path.join(artifactsPath, suffix);
+            const outputPath = path.join(dirPath, `${fileName}.json`);
+            const sierraOutput = path.join(dirPath, `${fileName}${SIERRA_SUFFIX}`);
+
+            fs.mkdirSync(dirPath, { recursive: true });
+            initializeFile(outputPath);
+            initializeFile(sierraOutput);
+
+            const executed = await hre.starknetWrapper.cairo1Compile({
+                file,
+                output: outputPath,
+                cairoPath,
+                sierraOutput,
+                manifestPath,
+                accountContract: args.accountContract,
+                disableHintValidation: args.disableHintValidation
+            });
+
+            // Update cache after compilation
+            await recompiler.updateCache(args, file, outputPath, sierraOutput, cairoPath);
+            statusCode += processExecuted(executed, true);
+        }
+        await recompiler.saveCache();
+    }
+
+    if (statusCode) {
+        const msg = `Failed compilation of ${statusCode} contract${statusCode === 1 ? "" : "s"}.`;
+        throw new StarknetPluginError(msg);
+    }
+}
+
 export async function starknetCompileAction(args: TaskArguments, hre: HardhatRuntimeEnvironment) {
     const root = hre.config.paths.root;
     const rootRegex = new RegExp("^" + root);

src/types/starknet.ts

@@ -98,6 +98,7 @@ export type StarknetConfig = {
     networkUrl?: string;
     networkConfig?: NetworkConfig;
     recompile?: boolean;
+    manifestPath?: string;
     requestTimeout?: number;
 };