@ohos-ports/azle 0.33.0-beta.0

package/src/stable/build/commands/dev/setup/install_node.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+if [ -z "$1" ]; then
+    echo "Error: No Node.js version specified."
+    echo "Usage: ./install_node.sh <NODE_VERSION>"
+    exit 1
+fi
+
+NODE_VERSION=$1
+
+source "$HOME/.nvm/nvm.sh"
+
+if nvm ls "$NODE_VERSION" &> /dev/null; then
+    echo "Node.js version $NODE_VERSION is already installed. Skipping installation."
+    nvm use "$NODE_VERSION"
+else
+    echo "Installing Node.js version $NODE_VERSION..."
+    nvm install "$NODE_VERSION"
+    nvm use "$NODE_VERSION"
+    nvm alias default "$NODE_VERSION"
+    echo "Node.js $NODE_VERSION installation completed."
+fi
+
+node --version
+exit 0

package/src/stable/build/commands/dev/setup/install_rust.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+if [ -z "$1" ]; then
+    echo "Error: No Rust version specified."
+    echo "Usage: ./install_rust.sh <RUST_VERSION>"
+    exit 1
+fi
+
+RUST_VERSION=$1
+
+# Install Rust
+echo "Installing Rust version $RUST_VERSION..."
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain "$RUST_VERSION"
+source $HOME/.cargo/env
+
+# Add the Wasm target for WebAssembly
+rustup target add wasm32-wasip1
+
+echo "Rust $RUST_VERSION installation completed."
+rustc --version
+cargo --version
+rustup target list --installed | grep wasm32-wasip1
+
+exit 0

package/src/stable/build/commands/dev/setup/install_wasi2ic.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+VERSION=$1
+
+if [[ $VERSION =~ ^https?:// ]]; then
+    echo "Installing wasi2ic from repository $VERSION"
+    cargo auditable install wasi2ic --git "$VERSION" --locked
+else
+    echo "Installing wasi2ic version $VERSION"
+    cargo auditable install wasi2ic --version "$VERSION" --locked
+fi

package/src/stable/build/commands/dev/template/experimental.ts

@@ -0,0 +1,28 @@
+import { IOType } from 'child_process';
+import { join } from 'path';
+
+import { compile } from '#commands/build/wasm_binary/compile';
+import {
+    AZLE_ROOT,
+    EXPERIMENTAL_STATIC_CANISTER_TEMPLATE_PATH
+} from '#utils/global_paths';
+
+export async function runCommand(ioType: IOType): Promise<void> {
+    compile(
+        join(
+            AZLE_ROOT,
+            'src',
+            'experimental',
+            'build',
+            'commands',
+            'build',
+            'wasm_binary',
+            'rust',
+            'experimental_canister_template',
+            'Cargo.toml'
+        ),
+        EXPERIMENTAL_STATIC_CANISTER_TEMPLATE_PATH,
+        ioType,
+        true
+    );
+}

package/src/stable/build/commands/dev/template/generate_licenses.ts

@@ -0,0 +1,28 @@
+import { IOType } from 'child_process';
+import { join } from 'path';
+
+import { execSyncPretty } from '#utils/exec_sync_pretty';
+import { AZLE_ROOT } from '#utils/global_paths';
+
+/**
+ * Generates a best-effort YAML file containing the license texts of all dependencies (including transitive dependencies)
+ * of Azle's Cargo workspace. These license texts are required to comply with the distribution of
+ * Azle's canister template Wasm binaries and the npx azle generate command's Wasm binary.
+ */
+export function generateLicenses(ioType: IOType): void {
+    const licensesPath = join(
+        AZLE_ROOT,
+        'dist',
+        'canister_templates',
+        'licenses.yml'
+    );
+
+    const command = `cargo bundle-licenses --format yaml --output ${licensesPath}`;
+
+    execSyncPretty(command, {
+        cwd: AZLE_ROOT,
+        stdio: ioType
+    });
+
+    console.info('✓ Licenses generated successfully');
+}

package/src/stable/build/commands/dev/template/stable.ts

@@ -0,0 +1,27 @@
+import { IOType } from 'child_process';
+import { join } from 'path';
+
+import { compile } from '#commands/build/wasm_binary/compile';
+import {
+    AZLE_ROOT,
+    STABLE_STATIC_CANISTER_TEMPLATE_PATH
+} from '#utils/global_paths';
+
+export async function runCommand(ioType: IOType): Promise<void> {
+    compile(
+        join(
+            AZLE_ROOT,
+            'src',
+            'stable',
+            'build',
+            'commands',
+            'build',
+            'wasm_binary',
+            'rust',
+            'stable_canister_template',
+            'Cargo.toml'
+        ),
+        STABLE_STATIC_CANISTER_TEMPLATE_PATH,
+        ioType
+    );
+}

package/src/stable/build/commands/extension/install.ts

@@ -0,0 +1,25 @@
+import { IOType } from 'child_process';
+import { join } from 'path';
+
+import { execSyncPretty } from '#utils/exec_sync_pretty';
+import { AZLE_ROOT } from '#utils/global_paths';
+
+export function runCommand(ioType: IOType): void {
+    const dfxExtensionDirectoryPath = join(
+        AZLE_ROOT,
+        'src',
+        'stable',
+        'build',
+        'dfx_extension'
+    );
+    execSyncPretty(
+        `./install.sh`,
+        {
+            stdio: ioType,
+            cwd: dfxExtensionDirectoryPath
+        },
+        'dfx extension installation script execution failed'
+    );
+
+    console.info('azle dfx extension successfully installed');
+}

package/src/stable/build/commands/generate/index.ts

@@ -0,0 +1,21 @@
+import { readFile } from 'fs/promises';
+
+import { candid_to_ts_js } from './rust/candid_to_ts_js/pkg/candid_to_ts_js';
+
+/**
+ * Generates TypeScript types and JavaScript IDL types from a Candid file.
+ *
+ * @param candidPath - Path to the Candid file to convert
+ *
+ * @returns The generated types are written to stdout
+ *
+ * @remarks
+ *
+ * The generated types can be used with `@query`/`@update`/other method decorators and for inter-canister calls using the `call` function
+ */
+export async function runCommand(candidPath: string): Promise<void> {
+    const candid = await readFile(candidPath, 'utf-8');
+    const result = candid_to_ts_js(candid);
+
+    process.stdout.write(result);
+}

package/src/stable/build/commands/generate/rust/candid_to_ts_js/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "candid-to-ts-js"
+version = "0.0.0"
+edition = "2024"
+license-file = "../../../../../../../LICENSE"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+candid_parser = { git = "https://github.com/demergent-labs/candid", rev = "22e24796dbb31b2d133bcd4d234abbaf34d6fd21" }
+wasm-bindgen = "0.2.100"

package/src/stable/build/commands/generate/rust/candid_to_ts_js/build.sh

@@ -0,0 +1,9 @@
+# TODO unfortunately we need the --dev option or else we get this error:
+# TODO RangeError: WebAssembly.Table.grow(): failed to grow table by 4
+# TODO this is probably caused by the wasm-opt optimization automatically performed
+# TODO without the --dev option
+wasm-pack build --target nodejs --dev
+
+# wasm-pack build automatically adds a .gitignore to ignore all of the generated files
+# but we want to check them into our repository
+rm pkg/.gitignore

package/src/stable/build/commands/generate/rust/candid_to_ts_js/licenses.md

@@ -0,0 +1 @@
+The licenses for the Wasm binary located at `./pkg/candid_to_ts_js_bg.wasm` can be found at `azle/dist/canister_templates/licenses.yml`.

package/src/stable/build/commands/generate/rust/candid_to_ts_js/pkg/candid_to_ts_js.d.ts

@@ -0,0 +1,18 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Converts a Candid service string to its corresponding TypeScript types and JavaScript IDL types.
+ *
+ * These types can be used with `@query`/`@update`/other method decorators and for inter-canister calls using the `call` function.
+ *
+ * # Parameters
+ *
+ * * `candid` - A string containing a valid Candid service definition
+ *
+ * # Returns
+ *
+ * TypeScript types and JavaScript IDL types as a string on success,
+ * or an error message if parsing or compilation fails
+ * ```
+ */
+export function candid_to_ts_js(candid: string): any;

package/src/stable/build/commands/generate/rust/candid_to_ts_js/pkg/candid_to_ts_js.js

@@ -0,0 +1,144 @@
+
+let imports = {};
+imports['__wbindgen_placeholder__'] = module.exports;
+let wasm;
+const { TextDecoder, TextEncoder } = require(`util`);
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedTextEncoder = new TextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (typeof(arg) !== 'string') throw new Error(`expected a string argument, found ${typeof(arg)}`);
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+        if (ret.read !== arg.length) throw new Error('failed to pass whole string');
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_0.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+/**
+ * Converts a Candid service string to its corresponding TypeScript types and JavaScript IDL types.
+ *
+ * These types can be used with `@query`/`@update`/other method decorators and for inter-canister calls using the `call` function.
+ *
+ * # Parameters
+ *
+ * * `candid` - A string containing a valid Candid service definition
+ *
+ * # Returns
+ *
+ * TypeScript types and JavaScript IDL types as a string on success,
+ * or an error message if parsing or compilation fails
+ * ```
+ * @param {string} candid
+ * @returns {any}
+ */
+module.exports.candid_to_ts_js = function(candid) {
+    const ptr0 = passStringToWasm0(candid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.candid_to_ts_js(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+};
+
+module.exports.__wbindgen_init_externref_table = function() {
+    const table = wasm.__wbindgen_export_0;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+};
+
+module.exports.__wbindgen_string_new = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+};
+
+module.exports.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+const path = require('path').join(__dirname, 'candid_to_ts_js_bg.wasm');
+const bytes = require('fs').readFileSync(path);
+
+const wasmModule = new WebAssembly.Module(bytes);
+const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+wasm = wasmInstance.exports;
+module.exports.__wasm = wasm;
+
+wasm.__wbindgen_start();
+

package/src/stable/build/commands/generate/rust/candid_to_ts_js/pkg/candid_to_ts_js_bg.wasm.d.ts

@@ -0,0 +1,9 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const candid_to_ts_js: (a: number, b: number) => [number, number, number];
+export const __wbindgen_export_0: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

package/src/stable/build/commands/generate/rust/candid_to_ts_js/pkg/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "candid-to-ts-js",
+  "version": "0.0.0",
+  "files": [
+    "candid_to_ts_js_bg.wasm",
+    "candid_to_ts_js.js",
+    "candid_to_ts_js.d.ts"
+  ],
+  "main": "candid_to_ts_js.js",
+  "types": "candid_to_ts_js.d.ts"
+}

package/src/stable/build/commands/generate/rust/candid_to_ts_js/src/lib.rs

@@ -0,0 +1,31 @@
+use candid_parser::{IDLProg, TypeEnv, bindings::typescript_and_javascript::compile, check_prog};
+use wasm_bindgen::prelude::{JsValue, wasm_bindgen};
+
+/// Converts a Candid service string to its corresponding TypeScript types and JavaScript IDL types.
+///
+/// These types can be used with `@query`/`@update`/other method decorators and for inter-canister calls using the `call` function.
+///
+/// # Parameters
+///
+/// * `candid` - A string containing a valid Candid service definition
+///
+/// # Returns
+///
+/// TypeScript types and JavaScript IDL types as a string on success,
+/// or an error message if parsing or compilation fails
+/// ```
+#[wasm_bindgen]
+pub fn candid_to_ts_js(candid: String) -> Result<JsValue, JsValue> {
+    let ast: IDLProg = candid
+        .parse()
+        .map_err(|e| JsValue::from_str(&format!("Failed to parse Candid: {e}")))?;
+
+    let mut env = TypeEnv::new();
+
+    let actor = check_prog(&mut env, &ast)
+        .map_err(|e| JsValue::from_str(&format!("Failed to type check Candid: {e}")))?;
+
+    let ts_js = compile(&env, &actor);
+
+    Ok(JsValue::from_str(&ts_js))
+}

package/src/stable/build/commands/new.ts

@@ -0,0 +1,165 @@
+import { cp, readFile, writeFile } from 'fs/promises';
+import { join } from 'path';
+
+import { AZLE_ROOT } from '#utils/global_paths';
+
+import { devDependencies } from '../../../../package.json';
+
+export async function runCommand(
+    azleVersion: string,
+    templatePath: string,
+    httpServer: boolean = false,
+    experimental: boolean = false
+): Promise<void> {
+    if (process.argv[3] === undefined) {
+        throw new Error(`You must provide a name for your Azle project`);
+    }
+
+    const projectName = process.argv[3];
+
+    // Copy the template to the new project directory
+    await cp(templatePath, projectName, { recursive: true });
+
+    // Edit the configuration files in place so they are ready to use in the new project
+    await editPackageJson(
+        projectName,
+        templatePath,
+        azleVersion,
+        experimental,
+        httpServer
+    );
+    await editTsConfig(projectName, httpServer);
+    await editJestConfig(projectName);
+    await editDfxJson(projectName, templatePath, experimental);
+
+    console.info(`${projectName} created successfully`);
+}
+
+/**
+ * Edits the package.json for the new project.
+ *
+ * @param projectName - The name of the project directory.
+ * @param templatePath - The path to the template directory.
+ * @param azleVersion - The version of Azle to set in the project's dependencies.
+ * @param experimental - Whether to include experimental dependencies in the project.
+ */
+async function editPackageJson(
+    projectName: string,
+    templatePath: string,
+    azleVersion: string,
+    experimental: boolean,
+    httpServer: boolean
+): Promise<void> {
+    const templatePackageJsonString = await readFile(
+        join(templatePath, 'package.json'),
+        {
+            encoding: 'utf-8'
+        }
+    );
+
+    let packageJson = JSON.parse(templatePackageJsonString);
+
+    packageJson.dependencies = {
+        ...packageJson.dependencies,
+        azle: `^${azleVersion}`
+    };
+    packageJson.devDependencies = {
+        ...packageJson.devDependencies,
+        cuzz: devDependencies.cuzz,
+        jest: devDependencies.jest,
+        'ts-jest': devDependencies['ts-jest']
+    };
+
+    if (experimental === true) {
+        packageJson.dependencies['azle-experimental-deps'] =
+            devDependencies['azle-experimental-deps'];
+    }
+
+    if (httpServer === true) {
+        packageJson.dependencies['@dfinity/identity-secp256k1'] =
+            devDependencies['@dfinity/identity'];
+    }
+
+    const packageJsonPath = join(projectName, 'package.json');
+    await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 4));
+}
+
+/**
+ * Edits the tsconfig.json for the new project
+ *
+ * @param projectName - The name of the project directory.
+ * @param useExperimentalDecorators - Whether to enable the TypeScript experimentalDecorators compiler option.
+ */
+async function editTsConfig(
+    projectName: string,
+    useExperimentalDecorators: boolean
+): Promise<void> {
+    const templateTsConfigString = await readFile(
+        join(AZLE_ROOT, 'tsconfig.dev.json'),
+        { encoding: 'utf-8' }
+    );
+
+    let tsConfig = JSON.parse(templateTsConfigString);
+
+    if (useExperimentalDecorators === true) {
+        tsConfig.compilerOptions = {
+            ...tsConfig.compilerOptions,
+            experimentalDecorators: useExperimentalDecorators
+        };
+    }
+
+    const tsConfigPath = join(projectName, 'tsconfig.json');
+    await writeFile(tsConfigPath, JSON.stringify(tsConfig, null, 4));
+}
+
+/**
+ * Edits the jest.config.js for the new project
+ *
+ * @param projectName - The name of the project directory.
+ */
+async function editJestConfig(projectName: string): Promise<void> {
+    const templateJestConfigString = await readFile(
+        join(AZLE_ROOT, 'jest.config.dev.js'),
+        { encoding: 'utf-8' }
+    );
+
+    const jestConfigPath = join(projectName, 'jest.config.js');
+    await writeFile(jestConfigPath, templateJestConfigString);
+}
+
+/**
+ * Edits the dfx.json for the new project to enable experimental mode for all canisters if the experimental argument is true.
+ *
+ * @param projectName - The name of the project directory.
+ * @param templatePath - The path to the template directory.
+ * @param experimental - Whether to set the experimental flag on all canisters.
+ */
+async function editDfxJson(
+    projectName: string,
+    templatePath: string,
+    experimental: boolean
+): Promise<void> {
+    if (experimental === true) {
+        const templateDfxJsonString = await readFile(
+            join(templatePath, 'dfx.json'),
+            {
+                encoding: 'utf-8'
+            }
+        );
+
+        let dfxJson = JSON.parse(templateDfxJsonString);
+
+        // Set experimental flag for all canisters
+        for (const canister of Object.keys(dfxJson.canisters)) {
+            dfxJson.canisters[canister].custom = {
+                ...dfxJson.canisters[canister].custom,
+                experimental: true
+            };
+        }
+
+        await writeFile(
+            join(projectName, 'dfx.json'),
+            JSON.stringify(dfxJson, null, 4)
+        );
+    }
+}

package/src/stable/build/commands/version.ts

@@ -0,0 +1,5 @@
+import { version } from '../../../../package.json';
+
+export function runCommand(): void {
+    console.info(version);
+}

package/src/stable/build/dfx_extension/extension.json

@@ -0,0 +1,36 @@
+{
+    "name": "azle",
+    "version": "0.33.0",
+    "homepage": "https://github.com/dfinity/dfx-extensions",
+    "authors": "",
+    "summary": "",
+    "categories": [],
+    "keywords": [],
+    "canister_type": {
+        "defaults": {
+            "candid": ".azle/{{canister_name}}/{{canister_name}}.did",
+            "build": "AZLE_DFX_ROOT=$(pwd) npm --offline --prefix={{canister.main}} exec azle build {{canister_name}}",
+            "post_install": "bash -c 'AZLE_DFX_ROOT=$(pwd) npm --offline --prefix={{canister.main}} exec azle post-install {{canister_name}}'",
+            "wasm": ".azle/{{canister_name}}/{{canister_name}}.wasm",
+            "gzip": true,
+            "metadata": [
+                {
+                    "name": "candid:service"
+                },
+                {
+                    "name": "cdk:name",
+                    "content": "azle"
+                }
+            ],
+            "tech_stack": {
+                "cdk": {
+                    "azle": {}
+                },
+                "language": {
+                    "typescript": {},
+                    "javascript": {}
+                }
+            }
+        }
+    }
+}

package/src/stable/build/dfx_extension/install.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+DFX_CACHE_DIR="$(dfx cache show)"
+
+if [ ! -d "$DFX_CACHE_DIR" ]; then
+    dfx cache install
+fi
+
+mkdir -p "$DFX_CACHE_DIR/extensions/azle"
+cp extension.json "$DFX_CACHE_DIR/extensions/azle/extension.json"