ic-mops 1.12.0 → 2.0.0

package/.eslintrc.json

@@ -1,8 +1,8 @@
 {
-    "env": {
-        "node": true
-    },
-    "parserOptions": {
-        "sourceType": "module"
-    }
-}
+  "env": {
+    "node": true
+  },
+  "parserOptions": {
+    "sourceType": "module"
+  }
+}

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Mops CLI Changelog
 
+## Next
+- `mops publish` add support for subheadings in changelog (by @f0i)
+- `mops toolchain` now downloads `moc.js` in addition to `moc` binary
+- New `mops build` subcommand (alternative to `dfx build`)
+- `core` package used in place of `base` for benchmarks
+
 ## 1.12.0
 - Add pinned dependencies support to `mops update` and `mops outdated` commands
 - Add support for pocket-ic v9

package/api/actors.ts

@@ -1,53 +1,57 @@
-import {Actor, HttpAgent, Identity} from '@icp-sdk/core/agent';
-import {Principal} from '@icp-sdk/core/principal';
+import { Actor, HttpAgent, Identity } from "@icp-sdk/core/agent";
+import { Principal } from "@icp-sdk/core/principal";
 
-import {_SERVICE, idlFactory} from '../declarations/main/main.did.js';
-import {idlFactory as storageIdlFactory} from '../declarations/storage/storage.did.js';
-import {_SERVICE as _STORAGE_SERVICE} from '../declarations/storage/storage.did.js';
+import { _SERVICE, idlFactory } from "../declarations/main/main.did.js";
+import { idlFactory as storageIdlFactory } from "../declarations/storage/storage.did.js";
+import { _SERVICE as _STORAGE_SERVICE } from "../declarations/storage/storage.did.js";
 
-import {getEndpoint} from './network.js';
-import {getNetwork} from './network.js';
+import { getEndpoint } from "./network.js";
+import { getNetwork } from "./network.js";
 
 let agentPromiseByPrincipal = new Map<string, Promise<HttpAgent>>();
 
-let getAgent = async (identity ?: Identity) : Promise<HttpAgent> => {
-	let principal = identity ? identity?.getPrincipal().toText() : '';
-	let agentPromise = agentPromiseByPrincipal.get(principal);
+let getAgent = async (identity?: Identity): Promise<HttpAgent> => {
+  let principal = identity ? identity?.getPrincipal().toText() : "";
+  let agentPromise = agentPromiseByPrincipal.get(principal);
 
-	if (!agentPromise) {
-		let network = getNetwork();
-		let host = getEndpoint(network).host;
+  if (!agentPromise) {
+    let network = getNetwork();
+    let host = getEndpoint(network).host;
 
-		agentPromise = HttpAgent.create({
-			host,
-			identity,
-			shouldFetchRootKey: network === 'local',
-			verifyQuerySignatures: process.env.MOPS_VERIFY_QUERY_SIGNATURES !== 'false',
-			shouldSyncTime: true,
-		});
+    agentPromise = HttpAgent.create({
+      host,
+      identity,
+      shouldFetchRootKey: network === "local",
+      verifyQuerySignatures:
+        process.env.MOPS_VERIFY_QUERY_SIGNATURES !== "false",
+      shouldSyncTime: true,
+    });
 
-		agentPromiseByPrincipal.set(principal, agentPromise);
-	}
+    agentPromiseByPrincipal.set(principal, agentPromise);
+  }
 
-	return agentPromise;
+  return agentPromise;
 };
 
-export let mainActor = async (identity ?: Identity) : Promise<_SERVICE> => {
-	let agent = await getAgent(identity);
-	let network = getNetwork();
-	let canisterId = getEndpoint(network).canisterId;
+export let mainActor = async (identity?: Identity): Promise<_SERVICE> => {
+  let agent = await getAgent(identity);
+  let network = getNetwork();
+  let canisterId = getEndpoint(network).canisterId;
 
-	return Actor.createActor(idlFactory, {
-		agent,
-		canisterId,
-	});
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+  });
 };
 
-export let storageActor = async (storageId : Principal, identity ?: Identity) : Promise<_STORAGE_SERVICE> => {
-	let agent = await getAgent(identity);
+export let storageActor = async (
+  storageId: Principal,
+  identity?: Identity,
+): Promise<_STORAGE_SERVICE> => {
+  let agent = await getAgent(identity);
 
-	return Actor.createActor(storageIdlFactory, {
-		agent,
-		canisterId: storageId,
-	});
+  return Actor.createActor(storageIdlFactory, {
+    agent,
+    canisterId: storageId,
+  });
 };

package/api/downloadPackageFiles.ts

@@ -1,81 +1,95 @@
-import {Principal} from '@icp-sdk/core/principal';
-import {mainActor, storageActor} from './actors.js';
-import {resolveVersion} from './resolveVersion.js';
-import {parallel} from '../parallel.js';
-import {Storage} from '../declarations/storage/storage.did.js';
+import { Principal } from "@icp-sdk/core/principal";
+import { mainActor, storageActor } from "./actors.js";
+import { resolveVersion } from "./resolveVersion.js";
+import { parallel } from "../parallel.js";
+import { Storage } from "../declarations/storage/storage.did.js";
 
-export async function downloadPackageFiles(pkg : string, version = '', threads = 8, onLoad = (_fileIds : string[], _fileId : string) => {}) : Promise<Map<string, Array<number>>> {
-	version = await resolveVersion(pkg, version);
+export async function downloadPackageFiles(
+  pkg: string,
+  version = "",
+  threads = 8,
+  onLoad = (_fileIds: string[], _fileId: string) => {},
+): Promise<Map<string, Array<number>>> {
+  version = await resolveVersion(pkg, version);
 
-	let {storageId, fileIds} = await getPackageFilesInfo(pkg, version);
-	let storage = await storageActor(storageId);
+  let { storageId, fileIds } = await getPackageFilesInfo(pkg, version);
+  let storage = await storageActor(storageId);
 
-	let filesData = new Map<string, Array<number>>();
-	await parallel(threads, fileIds, async (fileId : string) => {
-		let {path, data} = await downloadFile(storage, fileId);
-		filesData.set(path, data);
-		onLoad(fileIds, fileId);
-	});
+  let filesData = new Map<string, Array<number>>();
+  await parallel(threads, fileIds, async (fileId: string) => {
+    let { path, data } = await downloadFile(storage, fileId);
+    filesData.set(path, data);
+    onLoad(fileIds, fileId);
+  });
 
-	return filesData;
+  return filesData;
 }
 
 // get package files meta
-export async function getPackageFilesInfo(pkg : string, version : string) : Promise<{ storageId : Principal, fileIds : string[] }> {
-	let actor = await mainActor();
+export async function getPackageFilesInfo(
+  pkg: string,
+  version: string,
+): Promise<{ storageId: Principal; fileIds: string[] }> {
+  let actor = await mainActor();
 
-	let [packageDetailsRes, fileIds] = await Promise.all([
-		actor.getPackageDetails(pkg, version),
-		getFileIds(pkg, version),
-	]);
+  let [packageDetailsRes, fileIds] = await Promise.all([
+    actor.getPackageDetails(pkg, version),
+    getFileIds(pkg, version),
+  ]);
 
-	if ('err' in packageDetailsRes) {
-		throw packageDetailsRes.err;
-	}
-	let packageDetails = packageDetailsRes.ok;
+  if ("err" in packageDetailsRes) {
+    throw packageDetailsRes.err;
+  }
+  let packageDetails = packageDetailsRes.ok;
 
-	return {
-		storageId: packageDetails.publication.storage,
-		fileIds,
-	};
+  return {
+    storageId: packageDetails.publication.storage,
+    fileIds,
+  };
 }
 
 // get package files ids
-export async function getFileIds(pkg : string, version : string) : Promise<string[]> {
-	let actor = await mainActor();
-	let fileIdsRes = await actor.getFileIds(pkg, version);
+export async function getFileIds(
+  pkg: string,
+  version: string,
+): Promise<string[]> {
+  let actor = await mainActor();
+  let fileIdsRes = await actor.getFileIds(pkg, version);
 
-	if ('err' in fileIdsRes) {
-		throw fileIdsRes.err;
-	}
-	let filesIds = fileIdsRes.ok;
+  if ("err" in fileIdsRes) {
+    throw fileIdsRes.err;
+  }
+  let filesIds = fileIdsRes.ok;
 
-	return filesIds;
+  return filesIds;
 }
 
 // download single file
-export async function downloadFile(storage : Storage | string, fileId : string) : Promise<{path : string, data : Array<number>;}> {
-	if (typeof storage === 'string') {
-		storage = await storageActor(Principal.fromText(storage));
-	}
-	let fileMetaRes = await storage.getFileMeta(fileId);
-	if ('err' in fileMetaRes) {
-		throw fileMetaRes.err;
-	}
-	let fileMeta = fileMetaRes.ok;
+export async function downloadFile(
+  storage: Storage | string,
+  fileId: string,
+): Promise<{ path: string; data: Array<number> }> {
+  if (typeof storage === "string") {
+    storage = await storageActor(Principal.fromText(storage));
+  }
+  let fileMetaRes = await storage.getFileMeta(fileId);
+  if ("err" in fileMetaRes) {
+    throw fileMetaRes.err;
+  }
+  let fileMeta = fileMetaRes.ok;
 
-	let data : Array<number> = [];
-	for (let i = 0n; i < fileMeta.chunkCount; i++) {
-		let chunkRes = await storage.downloadChunk(fileId, i);
-		if ('err' in chunkRes) {
-			throw chunkRes.err;
-		}
-		let chunk = chunkRes.ok;
-		data = [...data, ...chunk];
-	}
+  let data: Array<number> = [];
+  for (let i = 0n; i < fileMeta.chunkCount; i++) {
+    let chunkRes = await storage.downloadChunk(fileId, i);
+    if ("err" in chunkRes) {
+      throw chunkRes.err;
+    }
+    let chunk = chunkRes.ok;
+    data = [...data, ...chunk];
+  }
 
-	return {
-		path: fileMeta.path,
-		data: data,
-	};
-}
+  return {
+    path: fileMeta.path,
+    data: data,
+  };
+}

package/api/getHighestVersion.ts

@@ -1,6 +1,6 @@
-import {mainActor} from './actors.js';
+import { mainActor } from "./actors.js";
 
-export async function getHighestVersion(pkgName : string) {
-	let actor = await mainActor();
-	return actor.getHighestVersion(pkgName);
-}
+export async function getHighestVersion(pkgName: string) {
+  let actor = await mainActor();
+  return actor.getHighestVersion(pkgName);
+}

package/api/index.ts

@@ -1,4 +1,4 @@
-export {mainActor, storageActor} from './actors.js';
-export {downloadPackageFiles} from './downloadPackageFiles.js';
-export {getEndpoint, getNetwork} from './network.js';
-export {resolveVersion} from './resolveVersion.js';
+export { mainActor, storageActor } from "./actors.js";
+export { downloadPackageFiles } from "./downloadPackageFiles.js";
+export { getEndpoint, getNetwork } from "./network.js";
+export { resolveVersion } from "./resolveVersion.js";

package/api/network.ts

@@ -1,24 +1,22 @@
 export function getNetwork() {
-	return globalThis.MOPS_NETWORK || 'ic';
+  return globalThis.MOPS_NETWORK || "ic";
 }
 
-export function getEndpoint(network : string) {
-	if (network === 'staging') {
-		return {
-			host: 'https://icp-api.io',
-			canisterId: '2d2zu-vaaaa-aaaak-qb6pq-cai',
-		};
-	}
-	else if (network === 'ic') {
-		return {
-			host: 'https://icp-api.io',
-			canisterId: 'oknww-riaaa-aaaam-qaf6a-cai',
-		};
-	}
-	else {
-		return {
-			host: 'http://127.0.0.1:4943',
-			canisterId: '2d2zu-vaaaa-aaaak-qb6pq-cai',
-		};
-	}
-}
+export function getEndpoint(network: string) {
+  if (network === "staging") {
+    return {
+      host: "https://icp-api.io",
+      canisterId: "2d2zu-vaaaa-aaaak-qb6pq-cai",
+    };
+  } else if (network === "ic") {
+    return {
+      host: "https://icp-api.io",
+      canisterId: "oknww-riaaa-aaaam-qaf6a-cai",
+    };
+  } else {
+    return {
+      host: "http://127.0.0.1:4943",
+      canisterId: "2d2zu-vaaaa-aaaak-qb6pq-cai",
+    };
+  }
+}

package/api/resolveVersion.ts

@@ -1,12 +1,15 @@
-import {getHighestVersion} from './getHighestVersion.js';
+import { getHighestVersion } from "./getHighestVersion.js";
 
-export async function resolveVersion(pkg : string, version = '') : Promise<string> {
-	if (!version) {
-		let versionRes = await getHighestVersion(pkg);
-		if ('err' in versionRes) {
-			throw versionRes.err;
-		}
-		version = versionRes.ok;
-	}
-	return version;
-}
+export async function resolveVersion(
+  pkg: string,
+  version = "",
+): Promise<string> {
+  if (!version) {
+    let versionRes = await getHighestVersion(pkg);
+    if ("err" in versionRes) {
+      throw versionRes.err;
+    }
+    version = versionRes.ok;
+  }
+  return version;
+}

package/bin/mops.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-import '../cli.js';
+import "../cli.js";

package/bundle/bench/bench-canister.mo

@@ -10,104 +10,112 @@ import Bench "mo:bench";
 
 import UserBench "./user-bench"; // file path will be replaced with the *.bench.mo file path
 
-persistent actor class() {
-	type BenchResult = {
-		instructions : Int;
-		rts_mutator_instructions : Int;
-		stable_memory_size : Int;
-		rts_stable_memory_size : Int;
-		rts_logical_stable_memory_size : Int;
-		rts_collector_instructions : Int;
-		rts_heap_size : Int;
-		rts_memory_size : Int;
-		rts_total_allocation : Int;
-		rts_reclaimed : Int;
-	};
-
-	transient var benchOpt : ?Bench.Bench = null;
-
-	public func init() : async Bench.BenchSchema {
-		let bench = UserBench.init();
-		benchOpt := ?bench;
-		// ignore ExperimentalStableMemory.grow(1);
-		ignore Region.grow(Region.new(), 1);
-		bench.getSchema();
-	};
-
-	public query func getSchema() : async Bench.BenchSchema {
-		let ?bench = benchOpt else Debug.trap("bench not initialized");
-		bench.getSchema();
-	};
-
-	func _getStats() : BenchResult {
-		{
-			instructions = 0;
-			rts_heap_size = Prim.rts_heap_size();
-			stable_memory_size = Int64.toInt(Int64.fromNat64(ExperimentalStableMemory.size())) * 65536;
-			rts_stable_memory_size = Prim.rts_stable_memory_size();
-			rts_logical_stable_memory_size = Prim.rts_logical_stable_memory_size();
-			rts_memory_size = Prim.rts_memory_size();
-			rts_total_allocation = Prim.rts_total_allocation();
-			rts_reclaimed = Prim.rts_reclaimed();
-			rts_mutator_instructions = Prim.rts_mutator_instructions();
-			rts_collector_instructions = Prim.rts_collector_instructions();
-		}
-	};
-
-	func _diffStats(before : BenchResult, after : BenchResult) : BenchResult {
-		{
-			instructions = after.instructions - before.instructions;
-			rts_heap_size = after.rts_heap_size - before.rts_heap_size;
-			stable_memory_size = after.stable_memory_size - before.stable_memory_size;
-			rts_stable_memory_size = after.rts_stable_memory_size - before.rts_stable_memory_size;
-			rts_logical_stable_memory_size = after.rts_logical_stable_memory_size - before.rts_logical_stable_memory_size;
-			rts_memory_size = after.rts_memory_size - before.rts_memory_size;
-			rts_total_allocation = after.rts_total_allocation - before.rts_total_allocation;
-			rts_reclaimed = after.rts_reclaimed - before.rts_reclaimed;
-			rts_mutator_instructions = after.rts_mutator_instructions - before.rts_mutator_instructions;
-			rts_collector_instructions = after.rts_collector_instructions - before.rts_collector_instructions;
-		}
-	};
-
-	func _runCell(rowIndex : Nat, colIndex : Nat) : BenchResult {
-		let ?bench = benchOpt else Debug.trap("bench not initialized");
-		let statsBefore = _getStats();
-
-		let instructions = Nat64.toNat(ExperimentalInternetComputer.countInstructions(func() {
-			bench.runCell(rowIndex, colIndex);
-		}));
-
-		let statsAfter = _getStats();
-		_diffStats(statsBefore, { statsAfter with instructions });
-	};
-
-	func _runCellAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-		let ?bench = benchOpt else Debug.trap("bench not initialized");
-		let statsBefore = _getStats();
-
-		let instructions = Nat64.toNat(ExperimentalInternetComputer.countInstructions(func() {
-			bench.runCell(rowIndex, colIndex);
-		}));
-
-		await (func() : async () {})();
-
-		let statsAfter = _getStats();
-		_diffStats(statsBefore, { statsAfter with instructions });
-	};
-
-	public query func getStats() : async BenchResult {
-		_getStats();
-	};
-
-	public query func runCellQuery(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-		_runCell(rowIndex, colIndex);
-	};
-
-	public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-		_runCell(rowIndex, colIndex);
-	};
-
-	public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
-		await _runCellAwait(rowIndex, colIndex);
-	};
-};
+persistent actor class () {
+  type BenchResult = {
+    instructions : Int;
+    rts_mutator_instructions : Int;
+    stable_memory_size : Int;
+    rts_stable_memory_size : Int;
+    rts_logical_stable_memory_size : Int;
+    rts_collector_instructions : Int;
+    rts_heap_size : Int;
+    rts_memory_size : Int;
+    rts_total_allocation : Int;
+    rts_reclaimed : Int;
+  };
+
+  transient var benchOpt : ?Bench.Bench = null;
+
+  public func init() : async Bench.BenchSchema {
+    let bench = UserBench.init();
+    benchOpt := ?bench;
+    // ignore ExperimentalStableMemory.grow(1);
+    ignore Region.grow(Region.new(), 1);
+    bench.getSchema();
+  };
+
+  public query func getSchema() : async Bench.BenchSchema {
+    let ?bench = benchOpt else Debug.trap("bench not initialized");
+    bench.getSchema();
+  };
+
+  func _getStats() : BenchResult {
+    {
+      instructions = 0;
+      rts_heap_size = Prim.rts_heap_size();
+      stable_memory_size = Int64.toInt(Int64.fromNat64(ExperimentalStableMemory.size())) * 65536;
+      rts_stable_memory_size = Prim.rts_stable_memory_size();
+      rts_logical_stable_memory_size = Prim.rts_logical_stable_memory_size();
+      rts_memory_size = Prim.rts_memory_size();
+      rts_total_allocation = Prim.rts_total_allocation();
+      rts_reclaimed = Prim.rts_reclaimed();
+      rts_mutator_instructions = Prim.rts_mutator_instructions();
+      rts_collector_instructions = Prim.rts_collector_instructions();
+    };
+  };
+
+  func _diffStats(before : BenchResult, after : BenchResult) : BenchResult {
+    {
+      instructions = after.instructions - before.instructions;
+      rts_heap_size = after.rts_heap_size - before.rts_heap_size;
+      stable_memory_size = after.stable_memory_size - before.stable_memory_size;
+      rts_stable_memory_size = after.rts_stable_memory_size - before.rts_stable_memory_size;
+      rts_logical_stable_memory_size = after.rts_logical_stable_memory_size - before.rts_logical_stable_memory_size;
+      rts_memory_size = after.rts_memory_size - before.rts_memory_size;
+      rts_total_allocation = after.rts_total_allocation - before.rts_total_allocation;
+      rts_reclaimed = after.rts_reclaimed - before.rts_reclaimed;
+      rts_mutator_instructions = after.rts_mutator_instructions - before.rts_mutator_instructions;
+      rts_collector_instructions = after.rts_collector_instructions - before.rts_collector_instructions;
+    };
+  };
+
+  func _runCell(rowIndex : Nat, colIndex : Nat) : BenchResult {
+    let ?bench = benchOpt else Debug.trap("bench not initialized");
+    let statsBefore = _getStats();
+
+    let instructions = Nat64.toNat(
+      ExperimentalInternetComputer.countInstructions(
+        func() {
+          bench.runCell(rowIndex, colIndex);
+        }
+      )
+    );
+
+    let statsAfter = _getStats();
+    _diffStats(statsBefore, { statsAfter with instructions });
+  };
+
+  func _runCellAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
+    let ?bench = benchOpt else Debug.trap("bench not initialized");
+    let statsBefore = _getStats();
+
+    let instructions = Nat64.toNat(
+      ExperimentalInternetComputer.countInstructions(
+        func() {
+          bench.runCell(rowIndex, colIndex);
+        }
+      )
+    );
+
+    await (func() : async () {})();
+
+    let statsAfter = _getStats();
+    _diffStats(statsBefore, { statsAfter with instructions });
+  };
+
+  public query func getStats() : async BenchResult {
+    _getStats();
+  };
+
+  public query func runCellQuery(rowIndex : Nat, colIndex : Nat) : async BenchResult {
+    _runCell(rowIndex, colIndex);
+  };
+
+  public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async BenchResult {
+    _runCell(rowIndex, colIndex);
+  };
+
+  public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
+    await _runCellAwait(rowIndex, colIndex);
+  };
+};

package/bundle/bench/user-bench.mo

@@ -2,9 +2,9 @@ import Bench "mo:bench";
 
 // placeholder file that will be replaced with the *.bench.mo file
 module {
-	public func init() : Bench.Bench {
-		let bench = Bench.Bench();
-		// benchmark code goes here...
-		bench;
-	};
-};
+  public func init() : Bench.Bench {
+    let bench = Bench.Bench();
+    // benchmark code goes here...
+    bench;
+  };
+};

package/bundle/bin/mops.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-import '../cli.js';
+import "../cli.js";