Adapt to starknet 0.11.0

config.json

@@ -1,4 +1,4 @@
 {
-    "CAIRO_LANG": "0.10.3",
-    "STARKNET_DEVNET": "0.4.6"
+    "CAIRO_LANG": "0.11.0.1",
+    "STARKNET_DEVNET": "0.5.0a1"
 }

scripts/ensure-python.sh

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

scripts/test.sh

@@ -9,7 +9,7 @@ CONFIG_FILE_NAME="hardhat.config.ts"
 
 # setup example repo
 rm -rf starknet-hardhat-example
-EXAMPLE_REPO_BRANCH="plugin"
+EXAMPLE_REPO_BRANCH="adapt-0.11.0"
 if [[ "$CIRCLE_BRANCH" == "master" ]] && [[ "$EXAMPLE_REPO_BRANCH" != "plugin" ]]; then
     echo "Invalid example repo branch: $EXAMPLE_REPO_BRANCH"
     exit 1

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 {
+    ContractClass,
+    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,
+    TRANSACTION_VERSION_TWO
 } 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(TRANSACTION_VERSION_TWO),
+        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: ContractClass
+) {
+    const hre = await import("hardhat");
+    const resp = await axios
+        .post(`${hre.starknet.networkConfig.url}/gateway/add_transaction`, {
+            type: "DECLARE",
+            contract_class: contractClass,
+            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,
+    TRANSACTION_VERSION_TWO,
     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";
@@ -442,6 +446,49 @@ export abstract class Account {
             maxFee: BigInt(maxFee)
         });
     }
+
+    public async declareV2(
+        contractFactory: StarknetContractFactory,
+        options: DeclareOptions = {}
+    ): Promise<string> {
+        const maxFee = options?.maxFee || 1e18; // Hardcoded value need to change
+        if (maxFee && options?.overhead) {
+            const msg = "maxFee and overhead cannot be specified together";
+            throw new StarknetPluginError(msg);
+        }
+
+        const version = TRANSACTION_VERSION_TWO;
+        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,13 @@ import { StringMap } from "./types";
 
 const NAMED_TUPLE_DELIMITER = ": ";
 const ARGUMENTS_DELIMITER = ", ";
+const COMMON_TYPES = [
+    "felt",
+    "core::felt252",
+    "core::integer::u8",
+    "core::integer::u256",
+    "core::starknet::contract_address::ContractAddress"
+];
 
 function isNumeric(value: { toString: () => string }) {
     if (value === undefined || value === null) {
@@ -147,7 +154,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 +227,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 +345,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 +398,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,100 @@
+import { ProcessResult } from "@nomiclabs/hardhat-docker";
+import shell from "shelljs";
+import { Image } from "@nomiclabs/hardhat-docker";
+import { DockerServer } from "./external-server/docker-server";
+import { getFreePort } from "./external-server/external-server";
+import { CommonSpawnOptions } from "child_process";
+
+export const exec = (args: string) => {
+    const result = shell.exec(args);
+    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];
+
+        if (this.isDockerDesktop) {
+            this.port = await this.getPort();
+            dockerArgs.push("-p", `${this.port}:${this.port}`);
+        } else {
+            dockerArgs.push("--network", "host");
+        }
+
+        return dockerArgs;
+    }
+
+    protected async getContainerArgs(): Promise<string[]> {
+        this.port = await this.getPort();
+        return ["/bin/sh", "-c", `"${this.cairo1CompilerArgs.join(" ")}"`];
+    }
+
+    protected async getPort(): Promise<string> {
+        if (!this.port) {
+            this.port = await getFreePort();
+        }
+        return this.port;
+    }
+
+    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;
+    }
+}

src/constants.ts

@@ -2,6 +2,9 @@ import config from "../config.json";
 
 export const PLUGIN_NAME = "Starknet";
 export const ABI_SUFFIX = "_abi.json";
+export const CAIRO_ASSEMBLY_SUFFIX = ".casm";
+export const CARGO_FILE = "Cargo.toml";
+export const DOCKER_HOST_BIN_PATH = "/usr/local/bin/target/release";
 export const DEFAULT_STARKNET_SOURCES_PATH = "contracts";
 export const DEFAULT_STARKNET_ARTIFACTS_PATH = "starknet-artifacts";
 export const DEFAULT_STARKNET_ACCOUNT_PATH = "~/.starknet_accounts";
@@ -61,6 +64,7 @@ export enum StarknetChainId {
 export const PREFIX_TRANSACTION = "Starknet Transaction";
 
 export const TRANSACTION_VERSION = BigInt(1);
+export const TRANSACTION_VERSION_TWO = BigInt(2);
 export const QUERY_VERSION = BigInt(2) ** BigInt(128) + TRANSACTION_VERSION;
 
 export const HEXADECIMAL_REGEX = /^0x[0-9a-fA-F]+?$/;