ic-mops 0.31.1 → 0.32.0

package/dist/cli.js

@@ -22,6 +22,7 @@ import { bump } from './commands/bump.js';
 import { sync } from './commands/sync.js';
 import { outdated } from './commands/outdated.js';
 import { update } from './commands/update.js';
+import { bench } from './commands/bench.js';
 import { transferOwnership } from './commands/transfer-ownership.js';
 // import {docs} from './commands/docs.js';
 program.name('mops');
@@ -178,6 +179,18 @@ program
     .action(async (filter, options) => {
     await test(filter, options);
 });
+// bench
+program
+    .command('bench [filter]')
+    .description('Run benchmarks')
+    .addOption(new Option('--save', 'Save benchmark results to .bench/<filename>.json'))
+    .addOption(new Option('--compare', 'Run benchmark and compare results with .bench/<filename>.json'))
+    .addOption(new Option('--gc <gc>', 'Garbage collector').choices(['copying', 'compacting', 'generational', 'incremental']).default('incremental'))
+    // .addOption(new Option('--force-gc', 'Force GC'))
+    .addOption(new Option('--verbose', 'Show more information'))
+    .action(async (filter, options) => {
+    await bench(filter, options);
+});
 // template
 program
     .command('template')

package/dist/commands/bench/bench-canister.mo

@@ -0,0 +1,87 @@
+import Nat64 "mo:base/Nat64";
+import Nat "mo:base/Nat";
+import Debug "mo:base/Debug";
+import ExperimentalInternetComputer "mo:base/ExperimentalInternetComputer";
+import Prim "mo:prim";
+import Bench "mo:bench";
+
+import UserBench "./user-bench";
+
+actor class() {
+	var benchOpt : ?Bench.Bench = null;
+
+	public func init() : async Bench.BenchSchema {
+		let bench = UserBench.init();
+		benchOpt := ?bench;
+		bench.getSchema();
+	};
+
+	public query func getSchema() : async Bench.BenchSchema {
+		let ?bench = benchOpt else Debug.trap("bench not initialized");
+		bench.getSchema();
+	};
+
+	func _getStats() : Bench.BenchResult {
+		{
+			instructions = 0;
+			rts_heap_size = Prim.rts_heap_size();
+			rts_memory_size = Prim.rts_memory_size();
+			rts_total_allocation = Prim.rts_total_allocation();
+			rts_mutator_instructions = Prim.rts_mutator_instructions();
+			rts_collector_instructions = Prim.rts_collector_instructions();
+		}
+	};
+
+	func _diffStats(before : Bench.BenchResult, after : Bench.BenchResult) : Bench.BenchResult {
+		{
+			instructions = after.instructions - before.instructions;
+			rts_heap_size = after.rts_heap_size - before.rts_heap_size;
+			rts_memory_size = after.rts_memory_size - before.rts_memory_size;
+			rts_total_allocation = after.rts_total_allocation - before.rts_total_allocation;
+			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) : Bench.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 Bench.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 Bench.BenchResult {
+		_getStats();
+	};
+
+	public query func runCellQuery(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+		_runCell(rowIndex, colIndex);
+	};
+
+	public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+		_runCell(rowIndex, colIndex);
+	};
+
+	public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+		await _runCellAwait(rowIndex, colIndex);
+	};
+};

package/dist/commands/bench/user-bench.mo

@@ -0,0 +1,14 @@
+import Nat "mo:base/Nat";
+import Iter "mo:base/Iter";
+import Buffer "mo:base/Buffer";
+import Vector "mo:vector/Class";
+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;
+	};
+};

package/dist/commands/bench.d.ts

@@ -0,0 +1,11 @@
+type BenchOptions = {
+    dfx?: string;
+    moc?: string;
+    gc?: 'copying' | 'compacting' | 'generational' | 'incremental';
+    forceGc?: boolean;
+    save?: boolean;
+    compare?: boolean;
+    verbose?: boolean;
+};
+export declare function bench(filter?: string, options?: BenchOptions): Promise<boolean>;
+export {};

package/dist/commands/bench.js

@@ -0,0 +1,275 @@
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import chalk from 'chalk';
+import { globSync } from 'glob';
+import { markdownTable } from 'markdown-table';
+import logUpdate from 'log-update';
+import { getRootDir } from '../mops.js';
+import { parallel } from '../parallel.js';
+import { createActor } from '../declarations/bench/index.js';
+import { absToRel } from './test/utils.js';
+import { getMocVersion } from '../helpers/get-moc-version.js';
+import { getDfxVersion } from '../helpers/get-dfx-version.js';
+import { getMocPath } from '../helpers/get-moc-path.js';
+import { sources } from './sources.js';
+import { execaCommand } from 'execa';
+let ignore = [
+    '**/node_modules/**',
+    '**/.mops/**',
+    '**/.vessel/**',
+    '**/.git/**',
+];
+let globConfig = {
+    nocase: true,
+    ignore: ignore,
+};
+export async function bench(filter = '', options = {}) {
+    let defaultOptions = {
+        moc: getMocVersion(),
+        dfx: getDfxVersion(),
+        gc: 'incremental',
+        forceGc: true,
+        save: false,
+        compare: false,
+        verbose: false,
+    };
+    options = { ...defaultOptions, ...options };
+    options.verbose && console.log(options);
+    let rootDir = getRootDir();
+    let globStr = '**/bench?(mark)/**/*.bench.mo';
+    if (filter) {
+        globStr = `**/bench?(mark)/**/*${filter}*.mo`;
+    }
+    let files = globSync(path.join(rootDir, globStr), globConfig);
+    if (!files.length) {
+        if (filter) {
+            console.log(`No benchmark files found for filter '${filter}'`);
+            return false;
+        }
+        console.log('No *.bench.mo files found');
+        console.log('Put your benchmark code in \'bench\' directory in *.bench.mo files');
+        return false;
+    }
+    files.sort();
+    let benchDir = `${getRootDir()}/.mops/.bench/`;
+    fs.rmSync(benchDir, { recursive: true, force: true });
+    fs.mkdirSync(benchDir, { recursive: true });
+    console.log('Benchmark files:');
+    for (let file of files) {
+        console.log(chalk.gray(`• ${absToRel(file)}`));
+    }
+    console.log('');
+    console.log('='.repeat(50));
+    console.log('');
+    console.log('Starting dfx replica...');
+    startDfx(options.verbose);
+    console.log('Deploying canisters...');
+    await parallel(os.cpus().length, files, async (file) => {
+        try {
+            await deployBenchFile(file, options);
+        }
+        catch (err) {
+            console.error('Unexpected error. Stopping dfx replica...');
+            stopDfx(options.verbose);
+            throw err;
+        }
+    });
+    await parallel(1, files, async (file) => {
+        console.log('\n' + '—'.repeat(50));
+        console.log(`\nRunning ${chalk.gray(absToRel(file))}...`);
+        console.log('');
+        try {
+            await runBenchFile(file, options);
+        }
+        catch (err) {
+            console.error('Unexpected error. Stopping dfx replica...');
+            stopDfx(options.verbose);
+            throw err;
+        }
+    });
+    console.log('Stopping dfx replica...');
+    stopDfx(options.verbose);
+    fs.rmSync(benchDir, { recursive: true, force: true });
+    return true;
+}
+function getMocArgs(options) {
+    let args = '';
+    if (options.forceGc) {
+        args += ' --force-gc';
+    }
+    if (options.gc) {
+        args += ` --${options.gc}-gc`;
+    }
+    return args;
+}
+function dfxJson(canisterName, options = {}) {
+    options || console.log(options);
+    let canisters = {};
+    if (canisterName) {
+        canisters[canisterName] = {
+            type: 'custom',
+            wasm: 'canister.wasm',
+            candid: 'canister.did',
+        };
+    }
+    return {
+        version: 1,
+        canisters,
+        defaults: {
+            build: {
+                packtool: 'mops sources',
+            },
+        },
+        networks: {
+            local: {
+                type: 'ephemeral',
+                bind: '127.0.0.1:4944',
+            },
+        },
+    };
+}
+function startDfx(verbose = false) {
+    stopDfx(verbose);
+    let dir = path.join(getRootDir(), '.mops/.bench');
+    fs.writeFileSync(path.join(dir, 'dfx.json'), JSON.stringify(dfxJson(''), null, 2));
+    execSync('dfx start --background --clean' + (verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['inherit', verbose ? 'inherit' : 'ignore', 'inherit'] });
+}
+function stopDfx(verbose = false) {
+    let dir = path.join(getRootDir(), '.mops/.bench');
+    execSync('dfx stop' + (verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['pipe', verbose ? 'inherit' : 'ignore', 'pipe'] });
+}
+async function deployBenchFile(file, options = {}) {
+    let rootDir = getRootDir();
+    let tempDir = path.join(rootDir, '.mops/.bench/', path.parse(file).name);
+    let canisterName = path.parse(file).name;
+    // prepare temp files
+    fs.mkdirSync(tempDir, { recursive: true });
+    fs.writeFileSync(path.join(tempDir, 'dfx.json'), JSON.stringify(dfxJson(canisterName, options), null, 2));
+    fs.cpSync(new URL('./bench/bench-canister.mo', import.meta.url), path.join(tempDir, 'canister.mo'));
+    fs.cpSync(file, path.join(tempDir, 'user-bench.mo'));
+    // build canister
+    let mocPath = getMocPath();
+    let mocArgs = getMocArgs(options);
+    options.verbose && console.time(`build ${canisterName}`);
+    await execaCommand(`${mocPath} -c --idl canister.mo ${mocArgs} ${(await sources({ cwd: tempDir })).join(' ')}`, { cwd: tempDir, stdio: options.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
+    options.verbose && console.timeEnd(`build ${canisterName}`);
+    // deploy canister
+    options.verbose && console.time(`deploy ${canisterName}`);
+    await execaCommand(`dfx deploy ${canisterName} --mode reinstall --yes --identity anonymous`, { cwd: tempDir, stdio: options.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
+    options.verbose && console.timeEnd(`deploy ${canisterName}`);
+    // init bench
+    options.verbose && console.time(`init ${canisterName}`);
+    let canisterId = execSync(`dfx canister id ${canisterName}`, { cwd: tempDir }).toString().trim();
+    let actor = await createActor(canisterId, {
+        agentOptions: {
+            host: 'http://127.0.0.1:4944',
+        },
+    });
+    await actor.init();
+    options.verbose && console.timeEnd(`init ${canisterName}`);
+}
+async function runBenchFile(file, options = {}) {
+    let rootDir = getRootDir();
+    let tempDir = path.join(rootDir, '.mops/.bench/', path.parse(file).name);
+    let canisterName = path.parse(file).name;
+    let canisterId = execSync(`dfx canister id ${canisterName}`, { cwd: tempDir }).toString().trim();
+    let actor = await createActor(canisterId, {
+        agentOptions: {
+            host: 'http://127.0.0.1:4944',
+        },
+    });
+    let schema = await actor.getSchema();
+    // load previous results
+    let prevResults;
+    let resultsJsonFile = path.join(rootDir, '.bench', `${path.parse(file).name}.json`);
+    if (options.compare) {
+        if (fs.existsSync(resultsJsonFile)) {
+            let prevResultsJson = JSON.parse(fs.readFileSync(resultsJsonFile).toString());
+            prevResults = new Map(prevResultsJson.results);
+        }
+        else {
+            console.log(chalk.yellow(`No previous results found "${resultsJsonFile}"`));
+        }
+    }
+    let results = new Map();
+    let formatNumber = (n) => {
+        return n.toLocaleString('en-US').replaceAll(',', '_');
+    };
+    let getTable = (prop) => {
+        let resArr = [['', ...schema.cols]];
+        for (let [_rowIndex, row] of schema.rows.entries()) {
+            let curRow = [row];
+            for (let [_colIndex, col] of schema.cols.entries()) {
+                let res = results.get(`${row}:${col}`);
+                if (res) {
+                    // compare with previous results
+                    let diff = '';
+                    if (options.compare && prevResults) {
+                        let prevRes = prevResults.get(`${row}:${col}`);
+                        if (prevRes) {
+                            let percent = (Number(res[prop]) - Number(prevRes[prop])) / Number(prevRes[prop]) * 100;
+                            let sign = percent > 0 ? '+' : '';
+                            let percentText = percent == 0 ? '0%' : sign + percent.toFixed(2) + '%';
+                            // diff = ' (' + (percent > 0 ? chalk.red(percentText) : chalk.green(percentText)) + ')'; // alignment is broken
+                            diff = ' (' + percentText + ')';
+                        }
+                        else {
+                            diff = chalk.yellow(' (no previous results)');
+                        }
+                    }
+                    // add to table
+                    curRow.push(formatNumber(res[prop]) + diff);
+                }
+                else {
+                    curRow.push('');
+                }
+            }
+            resArr.push(curRow);
+        }
+        return markdownTable(resArr, { align: ['l', ...'r'.repeat(schema.cols.length)] });
+    };
+    let printResults = () => {
+        logUpdate(`
+			\n${chalk.bold(schema.name)}
+			${schema.description ? '\n' + chalk.gray(schema.description) : ''}
+			\n\n${chalk.blue('Instructions')}\n\n${getTable('instructions')}
+			\n\n${chalk.blue('Heap')}\n\n${getTable('rts_heap_size')}
+		`);
+    };
+    printResults();
+    // run all cells
+    for (let [rowIndex, row] of schema.rows.entries()) {
+        for (let [colIndex, col] of schema.cols.entries()) {
+            // let res = await actor.runCellQuery(BigInt(rowIndex), BigInt(colIndex));
+            // let res = await actor.runCellUpdate(BigInt(rowIndex), BigInt(colIndex));
+            let res = await actor.runCellUpdateAwait(BigInt(rowIndex), BigInt(colIndex));
+            results.set(`${row}:${col}`, res);
+            printResults();
+        }
+    }
+    logUpdate.done();
+    // save results
+    if (options.save) {
+        console.log(`Saving results to ${chalk.gray(absToRel(resultsJsonFile))}`);
+        let json = {
+            version: 1,
+            moc: options.moc,
+            dfx: options.dfx,
+            gc: options.gc,
+            forceGc: options.forceGc,
+            results: Array.from(results.entries()),
+        };
+        fs.mkdirSync(path.dirname(resultsJsonFile), { recursive: true });
+        fs.writeFileSync(resultsJsonFile, JSON.stringify(json, (_, val) => {
+            if (typeof val === 'bigint') {
+                return Number(val);
+            }
+            else {
+                return val;
+            }
+        }, 2));
+    }
+    return { schema, results };
+}

package/dist/commands/publish.js

@@ -176,6 +176,10 @@ export async function publish(options = {}) {
         '!tests/**',
         '!**/*.test.mo',
         '!**/*.Test.mo',
+        '!bench/**',
+        '!benchmark/**',
+        '!**/*.bench.mo',
+        '!**/*.Bench.mo',
     ];
     let files = config.package.files || ['**/*.mo'];
     files = [...files, ...defaultFiles];

package/dist/commands/sources.d.ts

@@ -1,3 +1,4 @@
-export declare function sources({ verbose }?: {
+export declare function sources({ verbose, cwd }?: {
     verbose?: boolean | undefined;
+    cwd?: string | undefined;
 }): Promise<(string | undefined)[]>;

package/dist/commands/sources.js

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import { checkConfigFile, formatDir, formatGithubDir, getDependencyType, readConfig } from '../mops.js';
 import { resolvePackages } from '../resolve-packages.js';
 // TODO: resolve conflicts
-export async function sources({ verbose = false } = {}) {
+export async function sources({ verbose = false, cwd = process.cwd() } = {}) {
     if (!checkConfigFile()) {
         return [];
     }
@@ -13,13 +13,13 @@ export async function sources({ verbose = false } = {}) {
         let depType = getDependencyType(version);
         let pkgDir;
         if (depType === 'local') {
-            pkgDir = path.relative(process.cwd(), version);
+            pkgDir = path.relative(cwd, version);
         }
         else if (depType === 'github') {
-            pkgDir = path.relative(process.cwd(), formatGithubDir(name, version));
+            pkgDir = path.relative(cwd, formatGithubDir(name, version));
         }
         else if (depType === 'mops') {
-            pkgDir = path.relative(process.cwd(), formatDir(name, version));
+            pkgDir = path.relative(cwd, formatDir(name, version));
         }
         else {
             return;

package/dist/declarations/bench/bench.did

@@ -0,0 +1,26 @@
+type anon_class_10_1 = 
+ service {
+   getSchema: () -> (BenchSchema) query;
+   getStats: () -> (BenchResult) query;
+   init: () -> (BenchSchema);
+   runCellQuery: (nat, nat) -> (BenchResult) query;
+   runCellUpdate: (nat, nat) -> (BenchResult);
+   runCellUpdateAwait: (nat, nat) -> (BenchResult);
+ };
+type BenchSchema = 
+ record {
+   cols: vec text;
+   description: text;
+   name: text;
+   rows: vec text;
+ };
+type BenchResult = 
+ record {
+   instructions: int;
+   rts_collector_instructions: int;
+   rts_heap_size: int;
+   rts_memory_size: int;
+   rts_mutator_instructions: int;
+   rts_total_allocation: int;
+ };
+service : () -> anon_class_10_1

package/dist/declarations/bench/bench.did.d.ts

@@ -0,0 +1,26 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+
+export interface BenchResult {
+  'instructions' : bigint,
+  'rts_memory_size' : bigint,
+  'rts_total_allocation' : bigint,
+  'rts_collector_instructions' : bigint,
+  'rts_mutator_instructions' : bigint,
+  'rts_heap_size' : bigint,
+}
+export interface BenchSchema {
+  'cols' : Array<string>,
+  'name' : string,
+  'rows' : Array<string>,
+  'description' : string,
+}
+export interface anon_class_10_1 {
+  'getSchema' : ActorMethod<[], BenchSchema>,
+  'getStats' : ActorMethod<[], BenchResult>,
+  'init' : ActorMethod<[], BenchSchema>,
+  'runCellQuery' : ActorMethod<[bigint, bigint], BenchResult>,
+  'runCellUpdate' : ActorMethod<[bigint, bigint], BenchResult>,
+  'runCellUpdateAwait' : ActorMethod<[bigint, bigint], BenchResult>,
+}
+export interface _SERVICE extends anon_class_10_1 {}

package/dist/declarations/bench/bench.did.js

@@ -0,0 +1,26 @@
+export const idlFactory = ({ IDL }) => {
+  const BenchSchema = IDL.Record({
+    'cols' : IDL.Vec(IDL.Text),
+    'name' : IDL.Text,
+    'rows' : IDL.Vec(IDL.Text),
+    'description' : IDL.Text,
+  });
+  const BenchResult = IDL.Record({
+    'instructions' : IDL.Int,
+    'rts_memory_size' : IDL.Int,
+    'rts_total_allocation' : IDL.Int,
+    'rts_collector_instructions' : IDL.Int,
+    'rts_mutator_instructions' : IDL.Int,
+    'rts_heap_size' : IDL.Int,
+  });
+  const anon_class_10_1 = IDL.Service({
+    'getSchema' : IDL.Func([], [BenchSchema], ['query']),
+    'getStats' : IDL.Func([], [BenchResult], ['query']),
+    'init' : IDL.Func([], [BenchSchema], []),
+    'runCellQuery' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], ['query']),
+    'runCellUpdate' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], []),
+    'runCellUpdateAwait' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], []),
+  });
+  return anon_class_10_1;
+};
+export const init = ({ IDL }) => { return []; };

package/dist/declarations/bench/index.d.ts

@@ -0,0 +1,50 @@
+import type {
+  ActorSubclass,
+  HttpAgentOptions,
+  ActorConfig,
+  Agent,
+} from "@dfinity/agent";
+import type { Principal } from "@dfinity/principal";
+import type { IDL } from "@dfinity/candid";
+
+import { _SERVICE } from './bench.did';
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const canisterId: string;
+
+export declare interface CreateActorOptions {
+  /**
+   * @see {@link Agent}
+   */
+  agent?: Agent;
+  /**
+   * @see {@link HttpAgentOptions}
+   */
+  agentOptions?: HttpAgentOptions;
+  /**
+   * @see {@link ActorConfig}
+   */
+  actorOptions?: ActorConfig;
+}
+
+/**
+ * Intializes an {@link ActorSubclass}, configured with the provided SERVICE interface of a canister.
+ * @constructs {@link ActorSubClass}
+ * @param {string | Principal} canisterId - ID of the canister the {@link Actor} will talk to
+ * @param {CreateActorOptions} options - see {@link CreateActorOptions}
+ * @param {CreateActorOptions["agent"]} options.agent - a pre-configured agent you'd like to use. Supercedes agentOptions
+ * @param {CreateActorOptions["agentOptions"]} options.agentOptions - options to set up a new agent
+ * @see {@link HttpAgentOptions}
+ * @param {CreateActorOptions["actorOptions"]} options.actorOptions - options for the Actor
+ * @see {@link ActorConfig}
+ */
+export declare const createActor: (
+  canisterId: string | Principal,
+  options?: CreateActorOptions
+) => ActorSubclass<_SERVICE>;
+
+/**
+ * Intialized Actor using default settings, ready to talk to a canister using its candid interface
+ * @constructs {@link ActorSubClass}
+ */
+export declare const bench: ActorSubclass<_SERVICE>;

package/dist/declarations/bench/index.js

@@ -0,0 +1,41 @@
+import { Actor, HttpAgent } from "@dfinity/agent";
+
+// Imports and re-exports candid interface
+import { idlFactory } from "./bench.did.js";
+export { idlFactory } from "./bench.did.js";
+
+/* CANISTER_ID is replaced by webpack based on node environment
+ * Note: canister environment variable will be standardized as
+ * process.env.CANISTER_ID_<CANISTER_NAME_UPPERCASE>
+ * beginning in dfx 0.15.0
+ */
+export const canisterId =
+  process.env.CANISTER_ID_BENCH ||
+  process.env.BENCH_CANISTER_ID;
+
+export const createActor = (canisterId, options = {}) => {
+  const agent = options.agent || new HttpAgent({ ...options.agentOptions });
+
+  if (options.agent && options.agentOptions) {
+    console.warn(
+      "Detected both agent and agentOptions passed to createActor. Ignoring agentOptions and proceeding with the provided agent."
+    );
+  }
+
+  // Fetch root key for certificate validation during development
+  if (process.env.DFX_NETWORK !== "ic") {
+    agent.fetchRootKey().catch((err) => {
+      console.warn(
+        "Unable to fetch root key. Check to ensure that your local replica is running"
+      );
+      console.error(err);
+    });
+  }
+
+  // Creates an actor with using the candid interface and the HttpAgent
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+    ...options.actorOptions,
+  });
+};

package/dist/helpers/get-dfx-version.d.ts

@@ -0,0 +1 @@
+export declare function getDfxVersion(): string;

package/dist/helpers/get-dfx-version.js

@@ -0,0 +1,9 @@
+import { execSync } from 'node:child_process';
+export function getDfxVersion() {
+    try {
+        let res = execSync('dfx --version').toString();
+        return res.trim().split('dfx ')[1] || '';
+    }
+    catch { }
+    return '';
+}

package/dist/helpers/get-moc-path.d.ts

@@ -0,0 +1 @@
+export declare function getMocPath(): string;

package/dist/helpers/get-moc-path.js

@@ -0,0 +1,11 @@
+import { execSync } from 'node:child_process';
+export function getMocPath() {
+    let mocPath = process.env.DFX_MOC_PATH;
+    if (!mocPath) {
+        mocPath = execSync('dfx cache show').toString().trim() + '/moc';
+    }
+    if (!mocPath) {
+        mocPath = 'moc';
+    }
+    return mocPath;
+}

package/dist/helpers/get-moc-version.d.ts

@@ -0,0 +1 @@
+export declare function getMocVersion(): string;

package/dist/helpers/get-moc-version.js

@@ -0,0 +1,7 @@
+import { execSync } from 'node:child_process';
+import { getMocPath } from './get-moc-path.js';
+export function getMocVersion() {
+    let mocPath = getMocPath();
+    let match = execSync(mocPath).toString().trim().match(/Motoko compiler ([^\s]+) .*/);
+    return match?.[1] || '';
+}