chore: migrate motoko/low_wasm_memory to icp-cli (#1379)

Author: marc0olo

.github/workflows/low_wasm_memory.yml

@@ -0,0 +1,28 @@
+name: low_wasm_memory
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    paths:
+      - motoko/low_wasm_memory/**
+      - .github/workflows/low_wasm_memory.yml
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  motoko-low_wasm_memory:
+    runs-on: ubuntu-24.04
+    container: ghcr.io/dfinity/icp-dev-env-motoko:0.3.2
+    env:
+      ICP_CLI_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+      - name: Deploy and test
+        working-directory: motoko/low_wasm_memory
+        run: |
+          icp network start -d
+          icp deploy
+          make test

.github/workflows/motoko-low_wasm_memory-example.yml

@@ -0,0 +1,22 @@
+.PHONY: configure test
+
+# Set wasm_memory_limit to 5 MiB and wasm_memory_threshold to 2 MiB.
+# The low Wasm memory hook fires when remaining Wasm memory falls below the
+# threshold (i.e. when usage exceeds limit - threshold = 3 MiB).
+configure:
+	icp canister settings update backend \
+	  --wasm-memory-limit 5mib \
+	  --wasm-memory-threshold 2mib \
+	  -f
+
+test: configure
+	@echo "=== Polling for onLowWasmMemory hook (up to 60s) ==="
+	@secs=0; \
+	while [ $$secs -lt 60 ]; do \
+	  result=$$(icp canister call --query backend getExecutedFunctionsOrder '()') || \
+	    { echo "FAIL: canister call failed"; exit 1; }; \
+	  echo "$$result"; \
+	  echo "$$result" | grep -q 'onLowWasmMemory' && echo "PASS" && exit 0; \
+	  sleep 3; secs=$$((secs + 3)); \
+	done; \
+	echo "FAIL: onLowWasmMemory hook did not fire within 60s"; exit 1

motoko/low_wasm_memory/Makefile

@@ -1,50 +1,47 @@
 # Low Wasm memory hook
 
-The Internet Computer can automatically execute a special type of function called a low Wasm memory hook, which runs when the canister's available Wasm memory falls below the `wasm_memory_threshold`.
+This example demonstrates the low Wasm memory hook on the Internet Computer. The ICP runtime automatically executes a special `lowmemory` system function when a canister's available Wasm memory falls below the configured `wasm_memory_threshold`. The example shows the execution order of the `heartbeat` and `lowmemory` system functions as the canister progressively allocates memory until the threshold is reached.
 
-This Motoko example demonstrates using the low Wasm memory hook on ICP. For more information take a look at [low Wasm memory hook specification](https://internetcomputer.org/docs/references/ic-interface-spec#on-low-wasm-memory).
+For more information, see the [low Wasm memory hook specification](https://docs.internetcomputer.org/references/ic-interface-spec/canister-interface/#on-low-wasm-memory).
 
-## Deploying from ICP Ninja
+## Build and deploy from the command line
 
-[![](https://icp.ninja/assets/open.svg)](https://icp.ninja/editor?g=https://github.com/dfinity/examples/tree/master/motoko/low_wasm_memory)
+### Prerequisites
 
-## Build and deploy from the command-line
+- Node.js
+- icp-cli: `npm install -g @icp-sdk/icp-cli @icp-sdk/ic-wasm`
+- ic-mops: `npm install -g ic-mops`
 
-### 1. [Download and install the IC SDK.](https://internetcomputer.org/docs/building-apps/getting-started/install)
+### Install
 
-### 2. Download your project from ICP Ninja using the 'Download files' button on the upper left corner, or [clone the GitHub examples repository.](https://github.com/dfinity/examples/)
-
-### 3. Navigate into the project's directory.
-
-### 4. Deploy the project to your local environment:
-
-```
-dfx start --background --clean && dfx deploy
+```bash
+git clone https://github.com/dfinity/examples
+cd examples/motoko/low_wasm_memory
 ```
 
-After the deployment, the memory usage periodically increases as defined in the `heartbeat` function.
+### Deploy and test
 
-The `dfx canister update-settings` command sets the 'wasm_memory_limit' to 5MiB and 'wasm_memory_threshold' to 2MiB.
-Hence, whenever the Wasm memory used by the canister is above 3MiB (in other words, the remaining Wasm memory is less than 'wasm_memory_threshold'), the low Wasm memory hook will be triggered.
-
-This Motoko canister starts with ~2.3MiB of memory usage after the deployment, so it will trigger the low Wasm memory hook after allocating ~0.7MiB of memory.
+```bash
+icp network start -d
+icp deploy
+make test
+icp network stop
+```
 
-You can verify that the canister settings got updated and check the current 'Memory Size' with the following command:
+`make test` does two things:
 
-```sh
-dfx canister status low_wasm_memory_hook
-```
+1. **Configures the canister settings**: sets `wasm_memory_limit` to 5 MiB and `wasm_memory_threshold` to 2 MiB. This means the `lowmemory` hook fires when remaining Wasm memory falls below 2 MiB (i.e. when usage exceeds 3 MiB). The canister starts with ~2.3 MiB of usage after deployment, so the hook triggers after allocating roughly 0.7 MiB more.
 
-After a few seconds, observe the output of the `getExecutedFunctionsOrder` query:
+2. **Polls `getExecutedFunctionsOrder`** until `onLowWasmMemory` appears as the last entry (or times out after 60 s).
 
-Query the canister by calling `getExecutedFunctionsOrder` to get the order of executed functions.
+To observe the execution order manually:
 
-```sh
-dfx canister call low_wasm_memory_hook --query getExecutedFunctionsOrder
+```bash
+icp canister call --query backend getExecutedFunctionsOrder '()'
 ```
 
-Repeat the call until the last executed method is `onLowWasmMemory`.
+Repeat until the last entry is `onLowWasmMemory`.
 
 ## Security considerations and best practices
 
-If you base your application on this example, it is recommended that you familiarize yourself with and adhere to the [security best practices](https://internetcomputer.org/docs/building-apps/security/overview) for developing on ICP. This example may not implement all the best practices.
+Refer to the [security best practices](https://docs.internetcomputer.org/guides/security/overview) for information on security and best practices for your ICP app.

motoko/low_wasm_memory/README.md

@@ -2,7 +2,7 @@ import Array "mo:core/Array";
 import Queue "mo:core/Queue";
 import List "mo:core/List";
 
-persistent actor {
+actor {
   // Types
   type FnType = {
     #heartbeat;

…_memory/src/low_wasm_memory_hook/main.mo motoko/low_wasm_memory/backend/app.momotoko/low_wasm_memory/src/low_wasm_memory_hook/main.mo renamed to motoko/low_wasm_memory/backend/app.mo motoko/low_wasm_memory/src/low_wasm_memory_hook/main.mo renamed to motoko/low_wasm_memory/backend/app.mo

@@ -0,0 +1,4 @@
+canisters:
+  - name: backend
+    recipe:
+      type: "@dfinity/motoko@v5.0.0"

motoko/low_wasm_memory/dfx.json

@@ -1,13 +1,14 @@
-# Motoko dependencies (https://mops.one/)
-
 [toolchain]
-moc = "1.5.1"
+moc = "1.9.0"
 
 [dependencies]
-core = "2.4.0"
+core = "2.5.0"
 
 [moc]
-# M0236: use context dot notation (e.g. map.get(k) instead of Map.get(map, compare, k))
-# M0237: redundant explicit implicit arguments (e.g. Nat.compare is inferred automatically)
-# M0223: redundant type instantiation (e.g. Array.tabulate instead of Array.tabulate<T>)
-args = ["-W=M0236,M0237,M0223"]
+# M0236: use context dot notation
+# M0237: redundant explicit implicit arguments
+# M0223: redundant type instantiation
+args = ["--default-persistent-actors", "-W=M0236,M0237,M0223"]
+
+[canisters.backend]
+main = "backend/app.mo"