ic-mops 0.45.4-pre.0 → 1.0.0

package/dist/commands/test/test.js

@@ -17,6 +17,8 @@ import { FilesReporter } from './reporters/files-reporter.js';
 import { CompactReporter } from './reporters/compact-reporter.js';
 import { SilentReporter } from './reporters/silent-reporter.js';
 import { toolchain } from '../toolchain/index.js';
+import { Replica } from '../replica.js';
+import { PassThrough } from 'node:stream';
 let ignore = [
     '**/node_modules/**',
     '**/.mops/**',
@@ -27,15 +29,43 @@ let globConfig = {
     nocase: true,
     ignore: ignore,
 };
-export async function test(filter = '', { watch = false, reporter = 'verbose', mode = 'interpreter' } = {}) {
+let replica = new Replica();
+let replicaStartPromise;
+async function startReplicaOnce(replica, type) {
+    if (!replicaStartPromise) {
+        replicaStartPromise = new Promise((resolve) => {
+            replica.start({ type, silent: true }).then(resolve);
+        });
+    }
+    return replicaStartPromise;
+}
+export async function test(filter = '', options = {}) {
+    let config = readConfig();
     let rootDir = getRootDir();
-    if (watch) {
+    let replicaType = options.replica ?? (config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx');
+    replica.type = replicaType;
+    if (options.watch) {
+        replica.ttl = 60 * 15; // 15 minutes
+        let sigint = false;
+        process.on('SIGINT', () => {
+            if (sigint) {
+                console.log('Force exit');
+                process.exit(0);
+            }
+            sigint = true;
+            if (replicaStartPromise) {
+                console.log('Stopping replica...');
+                replica.stop(true).then(() => {
+                    process.exit(0);
+                });
+            }
+        });
         // todo: run only changed for *.test.mo?
         // todo: run all for *.mo?
         let run = debounce(async () => {
             console.clear();
             process.stdout.write('\x1Bc');
-            await runAll(reporter, filter, mode);
+            await runAll(options.reporter, filter, options.mode, replicaType, true);
             console.log('-'.repeat(50));
             console.log('Waiting for file changes...');
             console.log(chalk.gray((`Press ${chalk.gray('Ctrl+C')} to exit.`)));
@@ -53,7 +83,7 @@ export async function test(filter = '', { watch = false, reporter = 'verbose', m
         run();
     }
     else {
-        let passed = await runAll(reporter, filter, mode);
+        let passed = await runAll(options.reporter, filter, options.mode, replicaType);
         if (!passed) {
             process.exit(1);
         }
@@ -61,24 +91,11 @@ export async function test(filter = '', { watch = false, reporter = 'verbose', m
 }
 let mocPath = '';
 let wasmtimePath = '';
-export async function runAll(reporterName = 'verbose', filter = '', mode = 'interpreter') {
-    let reporter;
-    if (reporterName == 'compact') {
-        reporter = new CompactReporter;
-    }
-    else if (reporterName == 'files') {
-        reporter = new FilesReporter;
-    }
-    else if (reporterName == 'silent') {
-        reporter = new SilentReporter;
-    }
-    else {
-        reporter = new VerboseReporter;
-    }
-    let done = await testWithReporter(reporter, filter, mode);
+async function runAll(reporterName, filter = '', mode = 'interpreter', replicaType, watch = false) {
+    let done = await testWithReporter(reporterName, filter, mode, replicaType, watch);
     return done;
 }
-export async function testWithReporter(reporter, filter = '', mode = 'interpreter') {
+export async function testWithReporter(reporterName, filter = '', defaultMode = 'interpreter', replicaType, watch = false) {
     let rootDir = getRootDir();
     let files = [];
     let libFiles = globSync('**/test?(s)/lib.mo', globConfig);
@@ -101,18 +118,48 @@ export async function testWithReporter(reporter, filter = '', mode = 'interprete
         console.log('Put your tests in \'test\' directory in *.test.mo files');
         return false;
     }
+    let reporter;
+    if (!reporterName || typeof reporterName === 'string') {
+        if (!reporterName) {
+            reporterName = files.length > 1 ? 'files' : 'verbose';
+        }
+        if (reporterName == 'compact') {
+            reporter = new CompactReporter;
+        }
+        else if (reporterName == 'files') {
+            reporter = new FilesReporter;
+        }
+        else if (reporterName == 'silent') {
+            reporter = new SilentReporter;
+        }
+        else {
+            reporter = new VerboseReporter;
+        }
+    }
+    else {
+        reporter = reporterName;
+    }
     reporter.addFiles(files);
     let config = readConfig();
     let sourcesArr = await sources();
     if (!mocPath) {
         mocPath = await toolchain.bin('moc', { fallback: true });
     }
-    let wasmDir = `${getRootDir()}/.mops/.test/`;
-    fs.mkdirSync(wasmDir, { recursive: true });
+    let testTempDir = path.join(getRootDir(), '.mops/.test/');
+    replica.dir = testTempDir;
+    fs.mkdirSync(testTempDir, { recursive: true });
     await parallel(os.cpus().length, files, async (file) => {
         let mmf = new MMF1('store', absToRel(file));
-        let wasiMode = mode === 'wasi' || fs.readFileSync(file, 'utf8').startsWith('// @testmode wasi');
-        if (wasiMode && !wasmtimePath) {
+        // mode overrides
+        let lines = fs.readFileSync(file, 'utf8').split('\n');
+        let mode = defaultMode;
+        if (lines.includes('// @testmode wasi')) {
+            mode = 'wasi';
+        }
+        else if (lines.includes('actor {') || lines.includes('// @testmode replica')) {
+            mode = 'replica';
+        }
+        if (mode === 'wasi' && !wasmtimePath) {
             // ensure wasmtime is installed or specified in config
             if (config.toolchain?.wasmtime) {
                 wasmtimePath = await toolchain.bin('wasmtime');
@@ -126,9 +173,14 @@ export async function testWithReporter(reporter, filter = '', mode = 'interprete
         }
         let promise = new Promise((resolve) => {
             let mocArgs = ['--hide-warnings', '--error-detail=2', ...sourcesArr.join(' ').split(' '), file].filter(x => x);
+            // interpret
+            if (mode === 'interpreter') {
+                let proc = spawn(mocPath, ['-r', '-ref-system-api', ...mocArgs]);
+                pipeMMF(proc, mmf).then(resolve);
+            }
             // build and run wasm
-            if (wasiMode) {
-                let wasmFile = `${path.join(wasmDir, path.parse(file).name)}.wasm`;
+            else if (mode === 'wasi') {
+                let wasmFile = `${path.join(testTempDir, path.parse(file).name)}.wasm`;
                 // build
                 let buildProc = spawn(mocPath, [`-o=${wasmFile}`, '-wasi-system-api', ...mocArgs]);
                 pipeMMF(buildProc, mmf).then(async () => {
@@ -149,13 +201,8 @@ export async function testWithReporter(reporter, filter = '', mode = 'interprete
                         ];
                     }
                     else {
-                        wasmtimeArgs = [
-                            '--max-wasm-stack=4000000',
-                            '--enable-cranelift-nan-canonicalization',
-                            '--wasm-features',
-                            'multi-memory,bulk-memory',
-                            wasmFile,
-                        ];
+                        console.error(chalk.red('Minimum wasmtime version is 14.0.0. Please update wasmtime to the latest version'));
+                        process.exit(1);
                     }
                     let proc = spawn(wasmtimePath, wasmtimeArgs);
                     await pipeMMF(proc, mmf);
@@ -163,64 +210,110 @@ export async function testWithReporter(reporter, filter = '', mode = 'interprete
                     fs.rmSync(wasmFile, { force: true });
                 }).then(resolve);
             }
-            // interpret
-            else {
-                let proc = spawn(mocPath, ['-r', '-ref-system-api', ...mocArgs]);
-                pipeMMF(proc, mmf).then(resolve);
+            // build and execute in replica
+            else if (mode === 'replica') {
+                // mmf.strategy = 'print'; // because we run replica tests one-by-one
+                let wasmFile = `${path.join(testTempDir, path.parse(file).name)}.wasm`;
+                // build
+                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, ...mocArgs]);
+                pipeMMF(buildProc, mmf).then(async () => {
+                    if (mmf.failed > 0) {
+                        return;
+                    }
+                    await startReplicaOnce(replica, replicaType);
+                    let canisterName = path.parse(file).name;
+                    let idlFactory = ({ IDL }) => {
+                        return IDL.Service({ 'runTests': IDL.Func([], [], []) });
+                    };
+                    let { stream } = await replica.deploy(canisterName, wasmFile, idlFactory);
+                    pipeStdoutToMMF(stream, mmf);
+                    let actor = await replica.getActor(canisterName);
+                    try {
+                        if (globalThis.mopsReplicaTestRunning) {
+                            await new Promise((resolve) => {
+                                let timerId = setInterval(() => {
+                                    if (!globalThis.mopsReplicaTestRunning) {
+                                        resolve();
+                                        clearInterval(timerId);
+                                    }
+                                }, Math.random() * 1000 | 0);
+                            });
+                        }
+                        globalThis.mopsReplicaTestRunning = true;
+                        await actor.runTests();
+                        globalThis.mopsReplicaTestRunning = false;
+                        mmf.pass();
+                    }
+                    catch (e) {
+                        let stderrStream = new PassThrough();
+                        pipeStderrToMMF(stderrStream, mmf, path.dirname(file));
+                        stderrStream.write(e.message);
+                    }
+                }).finally(async () => {
+                    fs.rmSync(wasmFile, { force: true });
+                }).then(resolve);
             }
         });
-        reporter.addRun(file, mmf, promise, wasiMode);
+        reporter.addRun(file, mmf, promise, mode);
         await promise;
     });
-    fs.rmSync(wasmDir, { recursive: true, force: true });
+    if (replicaStartPromise && !watch) {
+        await replica.stop();
+        fs.rmSync(testTempDir, { recursive: true, force: true });
+    }
     return reporter.done();
 }
-function pipeMMF(proc, mmf) {
-    return new Promise((resolve) => {
-        // stdout
-        proc.stdout.on('data', (data) => {
-            for (let line of data.toString().split('\n')) {
-                line = line.trim();
-                if (line) {
-                    mmf.parseLine(line);
-                }
+function pipeStdoutToMMF(stdout, mmf) {
+    stdout.on('data', (data) => {
+        for (let line of data.toString().split('\n')) {
+            line = line.trim();
+            if (line) {
+                mmf.parseLine(line);
             }
-        });
-        // stderr
-        proc.stderr.on('data', (data) => {
-            let text = data.toString().trim();
-            let failedLine = '';
-            text = text.replace(/([\w+._/-]+):(\d+).(\d+)(-\d+.\d+)/g, (_m0, m1, m2, m3) => {
-                // change absolute file path to relative
-                // change :line:col-line:col to :line:col to work in vscode
-                let res = `${absToRel(m1)}:${m2}:${m3}`;
-                if (!fs.existsSync(m1)) {
-                    return res;
-                }
-                // show failed line
-                let content = fs.readFileSync(m1);
-                let lines = content.toString().split('\n') || [];
-                failedLine += chalk.dim('\n   ...');
-                let lineBefore = lines[+m2 - 2];
-                if (lineBefore) {
-                    failedLine += chalk.dim(`\n   ${+m2 - 1}\t| ${lineBefore.replaceAll('\t', '  ')}`);
-                }
-                failedLine += `\n${chalk.redBright `->`} ${m2}\t| ${lines[+m2 - 1]?.replaceAll('\t', '  ')}`;
-                if (lines.length > +m2) {
-                    failedLine += chalk.dim(`\n   ${+m2 + 1}\t| ${lines[+m2]?.replaceAll('\t', '  ')}`);
-                }
-                failedLine += chalk.dim('\n   ...');
+        }
+    });
+}
+function pipeStderrToMMF(stderr, mmf, dir = '') {
+    stderr.on('data', (data) => {
+        let text = data.toString().trim();
+        let failedLine = '';
+        text = text.replace(/([\w+._/-]+):(\d+).(\d+)(-\d+.\d+)/g, (_m0, m1, m2, m3) => {
+            // change absolute file path to relative
+            // change :line:col-line:col to :line:col to work in vscode
+            let res = `${absToRel(m1)}:${m2}:${m3}`;
+            let file = path.join(dir, m1);
+            if (!fs.existsSync(file)) {
                 return res;
-            });
-            if (failedLine) {
-                text += failedLine;
             }
-            mmf.fail(text);
+            // show failed line
+            let content = fs.readFileSync(file);
+            let lines = content.toString().split('\n') || [];
+            failedLine += chalk.dim('\n   ...');
+            let lineBefore = lines[+m2 - 2];
+            if (lineBefore) {
+                failedLine += chalk.dim(`\n   ${+m2 - 1}\t| ${lineBefore.replaceAll('\t', '  ')}`);
+            }
+            failedLine += `\n${chalk.redBright `->`} ${m2}\t| ${lines[+m2 - 1]?.replaceAll('\t', '  ')}`;
+            if (lines.length > +m2) {
+                failedLine += chalk.dim(`\n   ${+m2 + 1}\t| ${lines[+m2]?.replaceAll('\t', '  ')}`);
+            }
+            failedLine += chalk.dim('\n   ...');
+            return res;
         });
+        if (failedLine) {
+            text += failedLine;
+        }
+        mmf.fail(text);
+    });
+}
+function pipeMMF(proc, mmf) {
+    return new Promise((resolve) => {
+        pipeStdoutToMMF(proc.stdout, mmf);
+        pipeStderrToMMF(proc.stderr, mmf);
         // exit
         proc.on('close', (code) => {
             if (code === 0) {
-                mmf.pass();
+                mmf.strategy !== 'print' && mmf.pass();
             }
             else if (code !== 1) {
                 mmf.fail(`unknown exit code: ${code}`);

package/dist/commands/user.d.ts

@@ -1,2 +1,8 @@
 export declare function getUserProp(prop: string): Promise<void>;
 export declare function setUserProp(prop: string, value: string): Promise<void>;
+export declare function getPrincipal(): Promise<void>;
+type ImportIdentityOptions = {
+    encrypt: boolean;
+};
+export declare function importPem(data: string, options?: ImportIdentityOptions): Promise<void>;
+export {};

package/dist/commands/user.js

@@ -1,7 +1,13 @@
 import process from 'node:process';
 import chalk from 'chalk';
-import { getIdentity } from '../mops.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { Buffer } from 'node:buffer';
+import prompts from 'prompts';
+import { deleteSync } from 'del';
 import { mainActor } from '../api/actors.js';
+import { getIdentity, globalConfigDir } from '../mops.js';
+import { encrypt } from '../pem.js';
 export async function getUserProp(prop) {
     let actor = await mainActor();
     let identity = await getIdentity();
@@ -24,3 +30,55 @@ export async function setUserProp(prop, value) {
         console.log(chalk.red('Error: ') + res.err);
     }
 }
+export async function getPrincipal() {
+    let identity = await getIdentity();
+    if (identity) {
+        console.log(identity.getPrincipal().toText());
+    }
+    else {
+        console.log(chalk.red('Error: ') + 'identity not found. Run ' + chalk.greenBright('mops user import') + ' command.');
+    }
+}
+export async function importPem(data, options = { encrypt: true }) {
+    try {
+        if (!fs.existsSync(globalConfigDir)) {
+            fs.mkdirSync(globalConfigDir);
+        }
+        let password = '';
+        if (options.encrypt) {
+            let res = await prompts({
+                type: 'invisible',
+                name: 'password',
+                message: 'Enter password to encrypt identity.pem',
+            });
+            password = res.password;
+            if (!password) {
+                let res = await prompts({
+                    type: 'confirm',
+                    name: 'ok',
+                    message: 'Are you sure you don\'t want to protect your identity.pem with a password?',
+                });
+                if (!res.ok) {
+                    console.log('aborted');
+                    return;
+                }
+            }
+        }
+        let identityPem = path.resolve(globalConfigDir, 'identity.pem');
+        let identityPemEncrypted = path.resolve(globalConfigDir, 'identity.pem.encrypted');
+        deleteSync([identityPem, identityPemEncrypted], { force: true });
+        // encrypted
+        if (password) {
+            let encrypted = await encrypt(Buffer.from(data), password);
+            fs.writeFileSync(identityPemEncrypted, encrypted);
+        }
+        // unencrypted
+        else {
+            fs.writeFileSync(identityPem, data);
+        }
+        console.log(chalk.green('Success'));
+    }
+    catch (err) {
+        console.log(chalk.red('Error: ') + err);
+    }
+}

package/dist/declarations/bench/bench.did

@@ -1,4 +1,4 @@
-type _anon_class_10_1 = 
+type _anon_class_13_1 = 
  service {
    getSchema: () -> (BenchSchema) query;
    getStats: () -> (BenchResult) query;
@@ -19,8 +19,12 @@ type BenchResult =
    instructions: int;
    rts_collector_instructions: int;
    rts_heap_size: int;
+   rts_logical_stable_memory_size: int;
    rts_memory_size: int;
    rts_mutator_instructions: int;
+   rts_reclaimed: int;
+   rts_stable_memory_size: int;
    rts_total_allocation: int;
+   stable_memory_size: int;
  };
-service : () -> _anon_class_10_1
+service : () -> _anon_class_13_1

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

@@ -3,12 +3,16 @@ import type { ActorMethod } from '@dfinity/agent';
 import type { IDL } from '@dfinity/candid';
 
 export interface BenchResult {
+  'rts_stable_memory_size' : bigint,
+  'stable_memory_size' : bigint,
   'instructions' : bigint,
   'rts_memory_size' : bigint,
   'rts_total_allocation' : bigint,
   'rts_collector_instructions' : bigint,
   'rts_mutator_instructions' : bigint,
+  'rts_logical_stable_memory_size' : bigint,
   'rts_heap_size' : bigint,
+  'rts_reclaimed' : bigint,
 }
 export interface BenchSchema {
   'cols' : Array<string>,
@@ -16,7 +20,7 @@ export interface BenchSchema {
   'rows' : Array<string>,
   'description' : string,
 }
-export interface _anon_class_10_1 {
+export interface _anon_class_13_1 {
   'getSchema' : ActorMethod<[], BenchSchema>,
   'getStats' : ActorMethod<[], BenchResult>,
   'init' : ActorMethod<[], BenchSchema>,
@@ -24,6 +28,6 @@ export interface _anon_class_10_1 {
   'runCellUpdate' : ActorMethod<[bigint, bigint], BenchResult>,
   'runCellUpdateAwait' : ActorMethod<[bigint, bigint], BenchResult>,
 }
-export interface _SERVICE extends _anon_class_10_1 {}
+export interface _SERVICE extends _anon_class_13_1 {}
 export declare const idlFactory: IDL.InterfaceFactory;
 export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];

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

@@ -6,14 +6,18 @@ export const idlFactory = ({ IDL }) => {
     'description' : IDL.Text,
   });
   const BenchResult = IDL.Record({
+    'rts_stable_memory_size' : IDL.Int,
+    'stable_memory_size' : IDL.Int,
     'instructions' : IDL.Int,
     'rts_memory_size' : IDL.Int,
     'rts_total_allocation' : IDL.Int,
     'rts_collector_instructions' : IDL.Int,
     'rts_mutator_instructions' : IDL.Int,
+    'rts_logical_stable_memory_size' : IDL.Int,
     'rts_heap_size' : IDL.Int,
+    'rts_reclaimed' : IDL.Int,
   });
-  const _anon_class_10_1 = IDL.Service({
+  const _anon_class_13_1 = IDL.Service({
     'getSchema' : IDL.Func([], [BenchSchema], ['query']),
     'getStats' : IDL.Func([], [BenchResult], ['query']),
     'init' : IDL.Func([], [BenchSchema], []),
@@ -21,6 +25,6 @@ export const idlFactory = ({ IDL }) => {
     'runCellUpdate' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], []),
     'runCellUpdateAwait' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], []),
   });
-  return _anon_class_10_1;
+  return _anon_class_13_1;
 };
 export const init = ({ IDL }) => { return []; };

package/dist/mops.d.ts

@@ -11,7 +11,7 @@ export declare function setNetwork(network: string): void;
 export declare let getIdentity: () => Promise<Identity | undefined>;
 export declare function getClosestConfigFile(dir?: string): string;
 export declare function getRootDir(): string;
-export declare function checkConfigFile(): boolean;
+export declare function checkConfigFile(exit?: boolean): boolean;
 export declare function progressBar(step: number, total: number): string;
 export declare function parseGithubURL(href: string): {
     org: string;

package/dist/mops.js

@@ -4,7 +4,6 @@ import fs from 'node:fs';
 import TOML from '@iarna/toml';
 import chalk from 'chalk';
 import prompts from 'prompts';
-import ncp from 'ncp';
 import fetch from 'node-fetch';
 import { decodeFile } from './pem.js';
 import { mainActor, storageActor } from './api/actors.js';
@@ -38,32 +37,6 @@ if (process.env.XDG_CONFIG_HOME) {
 if (process.env.XDG_CACHE_HOME) {
     globalCacheDir = path.join(process.env.XDG_CACHE_HOME, 'mops');
 }
-// temp: move old config to new location
-let oldGlobalConfigDir = path.resolve(process.env.HOME || process.env.APPDATA || '/', 'mops');
-if (fs.existsSync(oldGlobalConfigDir) && !fs.existsSync(globalConfigDir)) {
-    fs.mkdirSync(globalConfigDir, { recursive: true });
-    if (fs.existsSync(path.join(oldGlobalConfigDir, 'identity.pem'))) {
-        fs.copyFileSync(path.join(oldGlobalConfigDir, 'identity.pem'), path.join(globalConfigDir, 'identity.pem'));
-    }
-    if (fs.existsSync(path.join(oldGlobalConfigDir, 'identity.pem.encrypted'))) {
-        fs.copyFileSync(path.join(oldGlobalConfigDir, 'identity.pem.encrypted'), path.join(globalConfigDir, 'identity.pem.encrypted'));
-    }
-    console.log('Moved config to ' + chalk.green(globalConfigDir));
-}
-// temp: move old cache to new location
-if (fs.existsSync(oldGlobalConfigDir) && !fs.existsSync(globalCacheDir)) {
-    fs.mkdirSync(globalCacheDir, { recursive: true });
-    ncp.ncp(path.join(oldGlobalConfigDir, 'packages'), path.join(globalCacheDir, 'packages'), {
-        stopOnErr: true,
-        clobber: false,
-    }, (err) => {
-        if (err) {
-            console.log('Error moving config: ', err);
-            fs.rmSync(globalCacheDir, { recursive: true, force: true });
-        }
-    });
-    console.log('Moved cache to ' + chalk.green(globalCacheDir));
-}
 export function getNetworkFile() {
     let networkFile = '';
     try {
@@ -110,10 +83,13 @@ export function getRootDir() {
     }
     return path.dirname(configFile);
 }
-export function checkConfigFile() {
+export function checkConfigFile(exit = false) {
     let configFile = getClosestConfigFile();
     if (!configFile) {
         console.log(chalk.red('Error: ') + `Config file 'mops.toml' not found. Please run ${chalk.green('mops init')} first`);
+        if (exit) {
+            process.exit(1);
+        }
         return false;
     }
     return true;
@@ -211,7 +187,7 @@ export function formatDir(name, version) {
 }
 export function formatGithubDir(name, repo) {
     const { branch, commitHash } = parseGithubURL(repo);
-    return path.join(getRootDir(), '.mops/_github', `${name}#${branch}` + (commitHash ? `@${commitHash}` : ''));
+    return path.join(getRootDir(), '.mops/_github', `${name}#${branch.replaceAll('/', '___')}` + (commitHash ? `@${commitHash}` : ''));
 }
 export function readDfxJson() {
     let dir = process.cwd();

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "0.45.4-pre.0",
+  "version": "1.0.0",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",
@@ -10,6 +10,10 @@
   "files": [
     "*",
     "!network.txt",
+    "!Dockerfile",
+    "!verify.sh",
+    "!build.sh",
+    "!DEVELOPMENT.md",
     "!.mops",
     "/templates"
   ],
@@ -24,13 +28,13 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@dfinity/agent": "2.0.0",
-    "@dfinity/candid": "2.0.0",
-    "@dfinity/identity": "2.0.0",
-    "@dfinity/identity-secp256k1": "2.0.0",
-    "@dfinity/principal": "2.0.0",
+    "@dfinity/agent": "2.1.0",
+    "@dfinity/candid": "2.1.0",
+    "@dfinity/identity": "2.1.0",
+    "@dfinity/identity-secp256k1": "2.1.0",
+    "@dfinity/principal": "2.1.0",
     "@iarna/toml": "2.2.5",
-    "@noble/hashes": "1.4.0",
+    "@noble/hashes": "1.5.0",
     "as-table": "1.0.55",
     "buffer": "6.0.3",
     "cacheable-request": "12.0.1",
@@ -38,12 +42,13 @@
     "chalk": "5.3.0",
     "chokidar": "3.6.0",
     "commander": "12.1.0",
-    "debounce": "2.1.0",
+    "debounce": "2.1.1",
     "decomp-tarxz": "0.1.1",
     "decompress": "4.2.1",
     "del": "7.1.0",
     "dhall-to-json-cli": "1.7.6",
-    "execa": "9.3.0",
+    "execa": "9.3.1",
+    "filesize": "10.1.6",
     "fs-extra": "11.2.0",
     "get-folder-size": "5.0.0",
     "glob": "11.0.0",
@@ -58,7 +63,7 @@
     "node-fetch": "3.3.2",
     "octokit": "3.1.2",
     "pem-file": "1.0.1",
-    "pic-ic": "0.3.3",
+    "pic-ic": "0.5.3",
     "prompts": "2.4.2",
     "semver": "7.6.3",
     "stream-to-promise": "3.0.0",
@@ -72,21 +77,15 @@
     "@types/fs-extra": "11.0.4",
     "@types/glob": "8.1.0",
     "@types/ncp": "2.0.8",
-    "@types/node": "22.0.2",
+    "@types/node": "22.5.4",
     "@types/prompts": "2.4.9",
     "@types/semver": "7.5.8",
     "@types/stream-to-promise": "2.2.4",
     "@types/tar": "6.1.13",
+    "bun": "1.1.27",
+    "esbuild": "0.23.1",
     "eslint": "8.57.0",
-    "bun": "1.0.35",
-    "esbuild": "0.23.0",
-    "tsx": "4.16.5",
-    "typescript": "5.5.4"
-  },
-  "overrides": {
-    "@dfinity/agent": "2.0.0",
-    "@dfinity/identity": "2.0.0",
-    "@dfinity/principal": "2.0.0",
-    "@dfinity/candid": "2.0.0"
+    "tsx": "4.19.1",
+    "typescript": "5.6.2"
   }
 }