ic-mops 0.31.1 → 0.32.0

package/cli.ts

@@ -24,6 +24,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';
 
@@ -198,6 +199,19 @@ program
 		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/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/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/commands/bench.ts

@@ -0,0 +1,335 @@
+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 {BenchResult, BenchSchema, _SERVICE} from '../declarations/bench/bench.did.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,
+};
+
+type BenchOptions = {
+	dfx?: string,
+	moc?: string,
+	gc?: 'copying' | 'compacting' | 'generational' | 'incremental',
+	forceGc?: boolean,
+	save?: boolean,
+	compare?: boolean,
+	verbose?: boolean,
+};
+
+export async function bench(filter = '', options: BenchOptions = {}): Promise<boolean> {
+	let defaultOptions: BenchOptions = {
+		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: string) => {
+		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: string) => {
+		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: BenchOptions): string {
+	let args = '';
+	if (options.forceGc) {
+		args += ' --force-gc';
+	}
+	if (options.gc) {
+		args += ` --${options.gc}-gc`;
+	}
+	return args;
+}
+
+function dfxJson(canisterName: string, options: BenchOptions = {}) {
+	options || console.log(options);
+
+	let canisters: Record<string, any> = {};
+	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: string, options: BenchOptions = {}): Promise<void> {
+	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: _SERVICE = await createActor(canisterId, {
+		agentOptions: {
+			host: 'http://127.0.0.1:4944',
+		},
+	});
+	await actor.init();
+	options.verbose && console.timeEnd(`init ${canisterName}`);
+}
+
+type RunBenchFileResult = {
+	schema: BenchSchema,
+	results: Map<string, BenchResult>,
+};
+
+async function runBenchFile(file: string, options: BenchOptions = {}): Promise<RunBenchFileResult> {
+	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: _SERVICE = await createActor(canisterId, {
+		agentOptions: {
+			host: 'http://127.0.0.1:4944',
+		},
+	});
+
+	let schema = await actor.getSchema();
+
+	// load previous results
+	let prevResults: Map<string, BenchResult> | undefined;
+	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<string, BenchResult>();
+
+	let formatNumber = (n: bigint | number): string => {
+		return n.toLocaleString('en-US').replaceAll(',', '_');
+	};
+
+	let getTable = (prop: keyof BenchResult): string => {
+		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: Record<any, any> = {
+			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/commands/publish.ts

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

package/commands/sources.ts

@@ -4,7 +4,7 @@ import {checkConfigFile, formatDir, formatGithubDir, getDependencyType, readConf
 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 [];
 	}
@@ -17,13 +17,13 @@ export async function sources({verbose = false} = {}) {
 
 		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/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/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/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/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/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,
+  });
+};