Adapt to starknet 0.11.0 (#328)

* [skip ci] - a release-commit follows

Author: Nathan-SL

config.json

@@ -1,4 +1,5 @@
 {
-    "CAIRO_LANG": "0.10.3",
-    "STARKNET_DEVNET": "0.4.6"
+    "CAIRO_LANG": "0.11.0.1",
+    "STARKNET_DEVNET": "0.5.0a1",
+    "CAIRO_COMPILER": "v1.0.0-alpha.6"
 }

scripts/ensure-python.sh

@@ -4,7 +4,7 @@
 
 set -eu
 
-PY_VERSION=3.8.9
+PY_VERSION=3.9.10
 
 if [[ "$OSTYPE" == "linux-gnu"* ]]; then
     which "/opt/circleci/.pyenv/versions/$PY_VERSION/bin/python" || pyenv install "$PY_VERSION"

scripts/setup-cairo1-compiler.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+set -eu
+
+if [ "$TEST_SUBDIR" == "configuration-tests" ]; then
+    CAIRO_1_COMPILER_TARGET_TAG="v1.0.0-alpha.6"
+
+    echo "Installing cairo compiler $CAIRO_1_COMPILER_TARGET_TAG"
+    # need rust to install cairo-rs-py
+    if rustc --version; then
+        echo "rustc installed"
+    else
+        curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+        source ~/.cargo/env
+    fi
+
+    if [ -z "${CAIRO_1_COMPILER_MANIFEST+x}" ]; then
+        # setup cairo1 compiler
+        mkdir cairo-compiler
+        git clone git@github.com:starkware-libs/cairo.git cairo-compiler \
+            --branch $CAIRO_1_COMPILER_TARGET_TAG \
+            --single-branch
+        export CAIRO_1_COMPILER_MANIFEST="cairo-compiler/Cargo.toml"
+    fi
+
+    cargo run --bin starknet-compile \
+        --manifest-path "$CAIRO_1_COMPILER_MANIFEST" \
+        -- \
+        --version
+fi
+

scripts/test.sh

@@ -30,6 +30,7 @@ fi
 
 # used by some cases
 ../scripts/setup-venv.sh
+source  ../scripts/setup-cairo1-compiler.sh
 
 total=0
 success=0

scripts/update-oz-account.sh

@@ -7,7 +7,7 @@ GIT_VERSION="v$VERSION"
 
 # create a venv
 rm -rf tmp-venv
-python3.8 -m venv tmp-venv
+python3.9 -m venv tmp-venv
 source tmp-venv/bin/activate
 
 # create a tmp OZ repo

src/account-utils.ts

@@ -1,5 +1,11 @@
-import { iterativelyCheckStatus, StarknetContract, StringMap } from "./types";
-import { toBN } from "starknet/utils/number";
+import {
+    Cairo1ContractClass,
+    iterativelyCheckStatus,
+    Numeric,
+    StarknetContract,
+    StringMap
+} from "./types";
+import { toBN, toHex } from "starknet/utils/number";
 import * as ellipticCurve from "starknet/utils/ellipticCurve";
 import { ec } from "elliptic";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
@@ -10,7 +16,8 @@ import {
     INTERNAL_ARTIFACTS_DIR,
     TransactionHashPrefix,
     TRANSACTION_VERSION,
-    StarknetChainId
+    StarknetChainId,
+    DECLARE_VERSION
 } from "./constants";
 import { numericToHexString } from "./utils";
 import * as crypto from "crypto";
@@ -187,6 +194,62 @@ export async function sendDeployAccountTx(
     });
 }
 
+export function calculateDeclareV2TxHash(
+    accountAddress: string,
+    callData: string[],
+    maxFee: string,
+    chainId: StarknetChainId,
+    additionalData: string[]
+) {
+    const calldataHash = hash.computeHashOnElements(callData);
+    return hash.computeHashOnElements([
+        TransactionHashPrefix.DECLARE,
+        numericToHexString(DECLARE_VERSION),
+        accountAddress,
+        0, // entrypoint selector is implied
+        calldataHash,
+        maxFee,
+        chainId,
+        ...additionalData
+    ]);
+}
+
+export async function sendDeclareV2Tx(
+    signatures: string[],
+    classHash: string,
+    maxFee: Numeric,
+    senderAddress: string,
+    version: Numeric,
+    nonce: Numeric,
+    contractClass: Cairo1ContractClass
+) {
+    const hre = await import("hardhat");
+    const resp = await axios
+        .post(`${hre.starknet.networkConfig.url}/gateway/add_transaction`, {
+            type: "DECLARE",
+            contract_class: contractClass.getCompiledClass(),
+            signature: signatures,
+            sender_address: senderAddress,
+            compiled_class_hash: toHex(toBN(classHash)),
+            version: numericToHexString(version),
+            nonce: numericToHexString(nonce),
+            max_fee: numericToHexString(maxFee)
+        })
+        .catch((error: AxiosError) => {
+            const msg = `Declaring contract failed: ${error.response.data.message}`;
+            throw new StarknetPluginError(msg, error);
+        });
+
+    return new Promise<string>((resolve, reject) => {
+        iterativelyCheckStatus(
+            resp.data.transaction_hash,
+            hre.starknetWrapper,
+            () => resolve(resp.data.transaction_hash),
+            reject
+        );
+    });
+}
+
 export async function sendEstimateFeeTx(data: unknown) {
     const hre = await import("hardhat");
     // To resolve TypeError: Do not know how to serialize a BigInt

src/account.ts

@@ -19,17 +19,20 @@ import {
     StarknetChainId,
     TransactionHashPrefix,
     TRANSACTION_VERSION,
+    DECLARE_VERSION,
     UDC_DEPLOY_FUNCTION_NAME
 } from "./constants";
 import { StarknetPluginError } from "./starknet-plugin-error";
 import * as ellipticCurve from "starknet/utils/ellipticCurve";
 import { BigNumberish, toBN } from "starknet/utils/number";
 import { ec } from "elliptic";
 import {
+    calculateDeclareV2TxHash,
     calculateDeployAccountHash,
     CallParameters,
     generateKeys,
     handleInternalContractArtifacts,
+    sendDeclareV2Tx,
     sendDeployAccountTx,
     sendEstimateFeeTx,
     signMultiCall
@@ -41,7 +44,8 @@ import {
     UDC,
     readContract,
     bnToDecimalStringArray,
-    estimatedFeeToMaxFee
+    estimatedFeeToMaxFee,
+    readCairo1Contract
 } from "./utils";
 import { Call, hash, RawCalldata } from "starknet";
 import { getTransactionReceiptUtil } from "./extend-utils";
@@ -403,6 +407,10 @@ export abstract class Account {
         contractFactory: StarknetContractFactory,
         options: DeclareOptions = {}
     ): Promise<string> {
+        if (contractFactory.isCairo1()) {
+            return await this.declareV2(contractFactory, options);
+        }
+
         let maxFee = options?.maxFee;
         if (maxFee && options?.overhead) {
             const msg = "maxFee and overhead cannot be specified together";
@@ -442,6 +450,51 @@ export abstract class Account {
             maxFee: BigInt(maxFee)
         });
     }
+
+    private async declareV2(
+        contractFactory: StarknetContractFactory,
+        options: DeclareOptions = {}
+    ): Promise<string> {
+        const maxFee = options?.maxFee;
+        if (!maxFee) {
+            const msg =
+                "maxFee must be provided to send declare transactions.\n" +
+                "A value of '0' for 'maxFee' is not supported.";
+            throw new StarknetPluginError(msg);
+        }
+
+        const version = DECLARE_VERSION;
+        const nonce = options.nonce == null ? await this.getNonce() : options.nonce;
+        const hre = await import("hardhat");
+        const chainId = hre.starknet.networkConfig.starknetChainId;
+
+        const compiledClassHash = await hre.starknetWrapper.getCompiledClassHash(
+            contractFactory.casmPath
+        );
+        const classHash = await hre.starknetWrapper.getSierraContractClassHash(
+            contractFactory.metadataPath
+        );
+
+        const calldata = [classHash];
+        const messageHash = calculateDeclareV2TxHash(
+            this.address,
+            calldata,
+            maxFee.toString(),
+            chainId,
+            [nonce.toString(), compiledClassHash]
+        );
+
+        const signatures = this.getSignatures(messageHash);
+        return sendDeclareV2Tx(
+            bnToDecimalStringArray(signatures),
+            compiledClassHash,
+            maxFee,
+            this.address,
+            version,
+            nonce,
+            readCairo1Contract(contractFactory.metadataPath)
+        );
+    }
 }
 
 /**

src/adapt.ts

@@ -5,6 +5,17 @@ import { StringMap } from "./types";
 
 const NAMED_TUPLE_DELIMITER = ": ";
 const ARGUMENTS_DELIMITER = ", ";
+const COMMON_TYPES = [
+    "felt",
+    "core::felt252",
+    "core::integer::u8",
+    "core::integer::u16",
+    "core::integer::u38",
+    "core::integer::u64",
+    "core::integer::u128",
+    "core::integer::u256",
+    "core::starknet::contract_address::ContractAddress"
+];
 
 function isNumeric(value: { toString: () => string }) {
     if (value === undefined || value === null) {
@@ -147,7 +158,7 @@ export function adaptInputUtil(
     for (let i = 0; i < inputSpecs.length; ++i) {
         const inputSpec = inputSpecs[i];
         const currentValue = input[inputSpec.name];
-        if (inputSpec.type === "felt") {
+        if (COMMON_TYPES.includes(inputSpec.type)) {
             const errorMsg =
                 `${functionName}: Expected "${inputSpec.name}" to be a felt (Numeric); ` +
                 `got: ${typeof currentValue}`;
@@ -220,8 +231,7 @@ function adaptComplexInput(
     if (input === undefined || input === null) {
         throw new StarknetPluginError(`${inputSpec.name} is ${input}`);
     }
-
-    if (type === "felt") {
+    if (COMMON_TYPES.includes(type)) {
         if (isNumeric(input)) {
             adaptedArray.push(toNumericString(input));
             return;
@@ -339,7 +349,8 @@ export function adaptOutputUtil(
 
     for (const outputSpec of outputSpecs) {
         const currentValue = result[resultIndex];
-        if (outputSpec.type === "felt") {
+        if (COMMON_TYPES.includes(outputSpec.type)) {
+            outputSpec.name = outputSpec.name ?? "response";
             adapted[outputSpec.name] = currentValue;
             resultIndex++;
         } else if (outputSpec.type.endsWith("*")) {
@@ -391,7 +402,7 @@ export function adaptOutputUtil(
  * @returns an object consisting of the next unused index and the generated tuple/struct itself
  */
 function generateComplexOutput(raw: bigint[], rawIndex: number, type: string, abi: starknet.Abi) {
-    if (type === "felt") {
+    if (COMMON_TYPES.includes(type)) {
         return {
             generatedComplex: raw[rawIndex],
             newRawIndex: rawIndex + 1

src/cairo1-compiler.ts

@@ -0,0 +1,86 @@
+import { ProcessResult } from "@nomiclabs/hardhat-docker";
+import shell from "shelljs";
+import { Image } from "@nomiclabs/hardhat-docker";
+import { DockerServer } from "./external-server/docker-server";
+import { CommonSpawnOptions } from "child_process";
+
+export const exec = (args: string) => {
+    const result = shell.exec(args, {
+        silent: true
+    });
+
+    return {
+        statusCode: result.code,
+        stdout: Buffer.from(result.stderr),
+        stderr: Buffer.from(result.stdout)
+    } as ProcessResult;
+};
+
+export class DockerCairo1Compiler extends DockerServer {
+    constructor(
+        image: Image,
+        private sources: string[],
+        private cairo1CompilerArgs?: string[],
+        stdout?: string,
+        stderr?: string
+    ) {
+        super(
+            image,
+            "127.0.0.1",
+            null,
+            "",
+            "starknet-docker-cairo1-compiler",
+            cairo1CompilerArgs,
+            stdout,
+            stderr
+        );
+    }
+
+    protected async getDockerArgs(): Promise<string[]> {
+        const volumes = [];
+        for (const source of this.sources) {
+            volumes.push("-v", `${source}:${source}`);
+        }
+
+        const dockerArgs = [...volumes];
+        return dockerArgs;
+    }
+
+    protected async getContainerArgs(): Promise<string[]> {
+        return ["/bin/sh", "-c", `"${this.cairo1CompilerArgs.join(" ")}"`];
+    }
+
+    async compileCairo1(options?: CommonSpawnOptions): Promise<ProcessResult> {
+        const res = await this.spawnChildProcess(options);
+        const stdout: string[] = [];
+        const stderr: string[] = [];
+        let statusCode;
+
+        res.stdout.on("data", (chunk) => {
+            stdout.push(chunk);
+            console.log(chunk.toString());
+        });
+
+        res.stderr.on("data", (chunk) => {
+            stderr.push(chunk);
+            console.log(chunk.toString());
+        });
+
+        await new Promise((resolve, reject) => {
+            res.on("close", (code) => {
+                statusCode = code;
+                resolve(code);
+            });
+
+            res.on("error", (error) => {
+                reject(error);
+            });
+        });
+
+        return {
+            statusCode,
+            stdout: Buffer.from(stdout.toString()),
+            stderr: Buffer.from(stderr.toString())
+        } as ProcessResult;
+    }
+}