@ohos-ports/azle 0.33.0-beta.0

package/src/stable/lib/stable_structures/stable_json.ts

@@ -0,0 +1,254 @@
+import { Principal } from '@dfinity/principal';
+// @ts-ignore
+import { TextDecoder, TextEncoder } from '@sinonjs/text-encoding';
+
+import { jsonParse, jsonStringify } from '../json';
+import { Serializable } from './stable_b_tree_map';
+
+/**
+ * Creates a JSON-based `Serializable` object for use with `StableBTreeMap`.
+ *
+ * @param options - Configuration options
+ * @param options.replacer - Custom `JSON.stringify` `replacer` function for JSON serialization. Defaults to the ICP-enabled `jsonReplacer`
+ * @param options.reviver - Custom `JSON.parse` `reviver` function for JSON deserialization. Defaults to the ICP-enabled `jsonReviver`
+ *
+ * @returns The JSON-based `Serializable` object
+ */
+export function StableJson(options?: {
+    replacer?: typeof jsonReplacer;
+    reviver?: typeof jsonReviver;
+}): Serializable {
+    const textEncoder = new TextEncoder();
+    const textDecoder = new TextDecoder();
+
+    return {
+        toBytes(data: any): Uint8Array {
+            return textEncoder.encode(jsonStringify(data, options?.replacer));
+        },
+        fromBytes(bytes: Uint8Array): any {
+            return jsonParse(textDecoder.decode(bytes), options?.reviver);
+        }
+    };
+}
+
+export const stableJson = StableJson();
+
+/**
+ * Custom ICP-enabled `JSON.stringify` `replacer` function that can convert some JSON-invalid JavaScript values into valid JSON. Handles special types like `Principal`, `BigInt`, and `Uint8Array` by default.
+ *
+ * @param _key - The key being processed (unused)
+ * @param value - The value to convert
+ *
+ * @returns The converted value as a valid JSON string
+ */
+export function jsonReplacer(_key: string, value: any): any {
+    if (typeof value === 'undefined') {
+        return {
+            __undefined__: '__undefined__'
+        };
+    }
+
+    if (typeof value === 'bigint') {
+        return {
+            __bigint__: value.toString()
+        };
+    }
+
+    if (
+        typeof value === 'object' &&
+        value !== null &&
+        value._isPrincipal === true
+    ) {
+        return {
+            __principal__: value.toString()
+        };
+    }
+
+    if (typeof value === 'number' && isNaN(value)) {
+        return {
+            __nan__: '__nan__'
+        };
+    }
+
+    if (typeof value === 'number' && value === Infinity) {
+        return {
+            __infinity__: '__infinity__'
+        };
+    }
+
+    if (typeof value === 'number' && value === -Infinity) {
+        return {
+            __negative_infinity__: '__negative_infinity__'
+        };
+    }
+
+    if (typeof value === 'number' && Object.is(value, -0)) {
+        return {
+            __negative_zero__: '__negative_zero__'
+        };
+    }
+
+    if (value instanceof Int8Array) {
+        return {
+            __int8array__: Array.from(value)
+        };
+    }
+
+    if (value instanceof Int16Array) {
+        return {
+            __int16array__: Array.from(value)
+        };
+    }
+
+    if (value instanceof Int32Array) {
+        return {
+            __int32array__: Array.from(value)
+        };
+    }
+
+    if (value instanceof BigInt64Array) {
+        return {
+            __bigint64array__: Array.from(value)
+        };
+    }
+
+    if (value instanceof Uint8Array) {
+        return {
+            __uint8array__: Array.from(value)
+        };
+    }
+
+    if (value instanceof Uint16Array) {
+        return {
+            __uint16array__: Array.from(value)
+        };
+    }
+
+    if (value instanceof Uint32Array) {
+        return {
+            __uint32array__: Array.from(value)
+        };
+    }
+
+    if (value instanceof BigUint64Array) {
+        return {
+            __biguint64array__: Array.from(value)
+        };
+    }
+
+    if (value instanceof Float32Array) {
+        return {
+            __float32array__: Array.from(value)
+        };
+    }
+
+    if (value instanceof Float64Array) {
+        return {
+            __float64array__: Array.from(value)
+        };
+    }
+
+    if (value instanceof Map) {
+        return {
+            __map__: Array.from(value.entries())
+        };
+    }
+
+    if (value instanceof Set) {
+        return {
+            __set__: Array.from(value)
+        };
+    }
+
+    return value;
+}
+
+/**
+ * Custom ICP-enabled `JSON.parse` `reviver` function that can convert valid JSON strings produced by `jsonReplacer` back into JavaScript values. Handles special types like `Principal`, `BigInt`, and `Uint8Array` by default.
+ *
+ * @param _key - The key being processed (unused)
+ * @param value - The value to convert
+ *
+ * @returns The restored JavaScript value
+ */
+export function jsonReviver(_key: string, value: any): any {
+    if (typeof value === 'object' && value !== null) {
+        if (typeof value.__undefined__ === 'string') {
+            return undefined;
+        }
+
+        if (typeof value.__bigint__ === 'string') {
+            return BigInt(value.__bigint__);
+        }
+
+        if (typeof value.__principal__ === 'string') {
+            return Principal.fromText(value.__principal__);
+        }
+
+        if (value.__nan__ === '__nan__') {
+            return NaN;
+        }
+
+        if (value.__infinity__ === '__infinity__') {
+            return Infinity;
+        }
+
+        if (value.__negative_infinity__ === '__negative_infinity__') {
+            return -Infinity;
+        }
+
+        if (value.__negative_zero__ === '__negative_zero__') {
+            return -0;
+        }
+
+        if (Array.isArray(value.__int8array__)) {
+            return Int8Array.from(value.__int8array__);
+        }
+
+        if (Array.isArray(value.__int16array__)) {
+            return Int16Array.from(value.__int16array__);
+        }
+
+        if (Array.isArray(value.__int32array__)) {
+            return Int32Array.from(value.__int32array__);
+        }
+
+        if (Array.isArray(value.__bigint64array__)) {
+            return BigInt64Array.from(value.__bigint64array__);
+        }
+
+        if (Array.isArray(value.__uint8array__)) {
+            return Uint8Array.from(value.__uint8array__);
+        }
+
+        if (Array.isArray(value.__uint16array__)) {
+            return Uint16Array.from(value.__uint16array__);
+        }
+
+        if (Array.isArray(value.__uint32array__)) {
+            return Uint32Array.from(value.__uint32array__);
+        }
+
+        if (Array.isArray(value.__biguint64array__)) {
+            return BigUint64Array.from(value.__biguint64array__);
+        }
+
+        if (Array.isArray(value.__float32array__)) {
+            return Float32Array.from(value.__float32array__);
+        }
+
+        if (Array.isArray(value.__float64array__)) {
+            return Float64Array.from(value.__float64array__);
+        }
+
+        if (Array.isArray(value.__map__)) {
+            return new Map(value.__map__);
+        }
+
+        if (Array.isArray(value.__set__)) {
+            return new Set(value.__set__);
+        }
+    }
+
+    return value;
+}

package/src/stable/lib/state.ts

@@ -0,0 +1,322 @@
+import { log } from './globals';
+
+export type Action =
+    | DELETE_AZLE_REJECT_CALLBACK
+    | DELETE_AZLE_RESOLVE_CALLBACK
+    | DELETE_AZLE_TIMER_CALLBACK
+    | SET_AZLE_CANISTER_CLASS_META
+    | SET_AZLE_CANISTER_METHOD_NAMES
+    | SET_AZLE_ICP_REPLICA_WASM_ENVIRONMENT
+    | SET_AZLE_REJECT_CALLBACK
+    | SET_AZLE_RESOLVE_CALLBACK
+    | SET_AZLE_TIMER_CALLBACK
+    | SET_CONSOLE
+    | SET_CRYPTO
+    | SET_GLOBAL_EXPERIMENTAL_ERROR_PROPERTY
+    | SET_TEXT_DECODER
+    | SET_TEXT_ENCODER;
+
+interface ActionShape {
+    type: string;
+    payload: any;
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+interface DELETE_AZLE_REJECT_CALLBACK extends ActionShape {
+    type: 'DELETE_AZLE_REJECT_CALLBACK';
+    payload: string;
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+interface DELETE_AZLE_RESOLVE_CALLBACK extends ActionShape {
+    type: 'DELETE_AZLE_RESOLVE_CALLBACK';
+    payload: string;
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+interface DELETE_AZLE_TIMER_CALLBACK extends ActionShape {
+    type: 'DELETE_AZLE_TIMER_CALLBACK';
+    payload: bigint;
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+interface SET_AZLE_CANISTER_CLASS_META extends ActionShape {
+    type: 'SET_AZLE_CANISTER_CLASS_META';
+    payload: typeof globalThis._azleCanisterClassMeta;
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+interface SET_AZLE_CANISTER_METHOD_NAMES extends ActionShape {
+    type: 'SET_AZLE_CANISTER_METHOD_NAMES';
+    payload: typeof globalThis._azleCanisterMethodNames;
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+interface SET_AZLE_ICP_REPLICA_WASM_ENVIRONMENT extends ActionShape {
+    type: 'SET_AZLE_ICP_REPLICA_WASM_ENVIRONMENT';
+    payload: typeof globalThis._azleIcpReplicaWasmEnvironment;
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+interface SET_AZLE_REJECT_CALLBACK extends ActionShape {
+    type: 'SET_AZLE_REJECT_CALLBACK';
+    payload: {
+        globalRejectId: string;
+        rejectCallback: NonNullable<
+            typeof globalThis._azleRejectCallbacks
+        >[string];
+    };
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+interface SET_AZLE_RESOLVE_CALLBACK extends ActionShape {
+    type: 'SET_AZLE_RESOLVE_CALLBACK';
+    payload: {
+        globalResolveId: string;
+        resolveCallback: NonNullable<
+            typeof globalThis._azleResolveCallbacks
+        >[string];
+    };
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+interface SET_AZLE_TIMER_CALLBACK extends ActionShape {
+    type: 'SET_AZLE_TIMER_CALLBACK';
+    payload: {
+        timerId: bigint;
+        timerCallback: NonNullable<
+            typeof globalThis._azleTimerCallbacks
+        >[string];
+    };
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+interface SET_CONSOLE extends ActionShape {
+    type: 'SET_CONSOLE';
+    payload: typeof globalThis.console;
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+interface SET_CRYPTO extends ActionShape {
+    type: 'SET_CRYPTO';
+    payload: typeof globalThis.crypto;
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+interface SET_GLOBAL_EXPERIMENTAL_ERROR_PROPERTY extends ActionShape {
+    type: 'SET_GLOBAL_EXPERIMENTAL_ERROR_PROPERTY';
+    payload: string;
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+interface SET_TEXT_DECODER extends ActionShape {
+    type: 'SET_TEXT_DECODER';
+    payload: typeof globalThis.TextDecoder;
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+interface SET_TEXT_ENCODER extends ActionShape {
+    type: 'SET_TEXT_ENCODER';
+    payload: typeof globalThis.TextEncoder;
+    location: {
+        filepath: string;
+        functionName: string;
+    };
+}
+
+/**
+ * Dispatches an action to the Azle JavaScript runtime.
+ *
+ * This function processes action objects with the provided type and payload,
+ * along with location information (filepath and function name), to perform
+ * important global state changes in Azle. Actions are used to manage global state
+ * like inter-canister callbacks and timer callbacks.
+ *
+ * @param action - The action object to dispatch, containing:
+ *   - type: String identifying the action type
+ *   - payload: Data relevant to the action
+ *   - location: Object containing filepath and functionName for debugging
+ */
+globalThis._azleDispatch = (action: Action): void => {
+    if (
+        globalThis.process !== undefined &&
+        globalThis.process.env.AZLE_LOG_ACTIONS === 'true'
+    ) {
+        log(action);
+    }
+
+    if (
+        globalThis.process !== undefined &&
+        globalThis.process.env.AZLE_RECORD_ACTIONS === 'true'
+    ) {
+        if (globalThis._azleActions === undefined) {
+            globalThis._azleActions = [];
+        }
+
+        globalThis._azleActions.push(action);
+    }
+
+    if (action.type === 'DELETE_AZLE_REJECT_CALLBACK') {
+        if (globalThis._azleRejectCallbacks !== undefined) {
+            delete globalThis._azleRejectCallbacks[action.payload];
+        }
+
+        return;
+    }
+
+    if (action.type === 'DELETE_AZLE_RESOLVE_CALLBACK') {
+        if (globalThis._azleResolveCallbacks !== undefined) {
+            delete globalThis._azleResolveCallbacks[action.payload];
+        }
+
+        return;
+    }
+
+    if (action.type === 'DELETE_AZLE_TIMER_CALLBACK') {
+        if (globalThis._azleTimerCallbacks !== undefined) {
+            delete globalThis._azleTimerCallbacks[action.payload.toString()];
+        }
+        return;
+    }
+
+    if (action.type === 'SET_AZLE_CANISTER_CLASS_META') {
+        globalThis._azleCanisterClassMeta = action.payload;
+        return;
+    }
+
+    if (action.type === 'SET_AZLE_CANISTER_METHOD_NAMES') {
+        globalThis._azleCanisterMethodNames = action.payload;
+        return;
+    }
+
+    if (action.type === 'SET_AZLE_ICP_REPLICA_WASM_ENVIRONMENT') {
+        globalThis._azleIcpReplicaWasmEnvironment = action.payload;
+        return;
+    }
+
+    if (action.type === 'SET_AZLE_REJECT_CALLBACK') {
+        if (globalThis._azleRejectCallbacks === undefined) {
+            globalThis._azleRejectCallbacks = {};
+        }
+        globalThis._azleRejectCallbacks[action.payload.globalRejectId] =
+            action.payload.rejectCallback;
+        return;
+    }
+
+    if (action.type === 'SET_AZLE_RESOLVE_CALLBACK') {
+        if (globalThis._azleResolveCallbacks === undefined) {
+            globalThis._azleResolveCallbacks = {};
+        }
+        globalThis._azleResolveCallbacks[action.payload.globalResolveId] =
+            action.payload.resolveCallback;
+        return;
+    }
+
+    if (action.type === 'SET_AZLE_TIMER_CALLBACK') {
+        if (globalThis._azleTimerCallbacks === undefined) {
+            globalThis._azleTimerCallbacks = {};
+        }
+        globalThis._azleTimerCallbacks[action.payload.timerId.toString()] =
+            action.payload.timerCallback;
+        return;
+    }
+
+    if (action.type === 'SET_CONSOLE') {
+        globalThis.console = action.payload;
+        return;
+    }
+
+    if (action.type === 'SET_CRYPTO') {
+        globalThis.crypto = action.payload;
+        return;
+    }
+
+    /**
+     * Creates a getter property on globalThis that throws an error when accessed.
+     * Used to prevent access to experimental features when experimental mode is disabled.
+     */
+    if (action.type === 'SET_GLOBAL_EXPERIMENTAL_ERROR_PROPERTY') {
+        Object.defineProperty(globalThis, action.payload, {
+            get() {
+                throw new Error(experimentalWarningMessage(action.payload));
+            },
+            configurable: true
+        });
+
+        return;
+    }
+
+    if (action.type === 'SET_TEXT_DECODER') {
+        globalThis.TextDecoder = action.payload;
+        return;
+    }
+
+    if (action.type === 'SET_TEXT_ENCODER') {
+        globalThis.TextEncoder = action.payload;
+        return;
+    }
+};
+
+/**
+ * Generates an error message explaining how to enable experimental mode for a given feature.
+ *
+ * @param name - The name of the experimental feature
+ * @returns A formatted error message with dfx.json configuration instructions
+ */
+function experimentalWarningMessage(name: string): string {
+    return `Azle: experimental mode must be enabled to use global ${name}. You can enable experimental mode in your dfx.json file like this:
+{
+    "canisters": {
+        "canisterName": {
+            "type": "azle",
+            "main": "index.ts",
+            "custom": {
+                "experimental": true
+            }
+        }
+    }
+}
+`;
+}

package/src/stable/test/benchmarks/_azle_get_benchmarks.did

@@ -0,0 +1,9 @@
+type benchmark_entry = record {
+    method_name: text;
+    instructions: nat64;
+    timestamp: nat64;
+};
+
+service: () -> {
+    _azle_get_benchmarks: () -> (vec benchmark_entry) query;
+}