ic-mops 0.28.1 → 0.28.3

package/commands/init.ts

@@ -174,15 +174,22 @@ async function applyInit({type, config, setupWorkflow, addTest, copyrightOwner}
 	let dfxJsonData;
 	if (existsSync(dfxJson)) {
 		let dfxJsonText = readFileSync(dfxJson).toString();
-		dfxJsonData = JSON.parse(dfxJsonText);
-		console.log('Setting packtool in dfx.json...');
-		dfxJsonData.defaults = dfxJsonData.defaults || {};
-		dfxJsonData.defaults.build = dfxJsonData.defaults.build || {};
-		if (dfxJsonData.defaults.build.packtool !== 'mops sources') {
-			dfxJsonData.defaults.build.packtool = 'mops sources';
-			let indent = dfxJsonText.match(/([ \t]+)"/)?.[1] || '  ';
-			writeFileSync(path.join(process.cwd(), 'dfx.json'), JSON.stringify(dfxJsonData, null, indent));
-			console.log(chalk.green('packtool set to "mops sources"'));
+		try {
+			dfxJsonData = JSON.parse(dfxJsonText);
+		}
+		catch (err) {
+			console.log(chalk.yellow('Failed to parse dfx.json'));
+		}
+		if (dfxJsonData) {
+			console.log('Setting packtool in dfx.json...');
+			dfxJsonData.defaults = dfxJsonData.defaults || {};
+			dfxJsonData.defaults.build = dfxJsonData.defaults.build || {};
+			if (dfxJsonData.defaults.build.packtool !== 'mops sources') {
+				dfxJsonData.defaults.build.packtool = 'mops sources';
+				let indent = dfxJsonText.match(/([ \t]+)"/)?.[1] || '  ';
+				writeFileSync(path.join(process.cwd(), 'dfx.json'), JSON.stringify(dfxJsonData, null, indent));
+				console.log(chalk.green('packtool set to "mops sources"'));
+			}
 		}
 	}
 

package/declarations/main/main.did

@@ -41,6 +41,20 @@ type TestStats =
    passed: nat;
    passedNames: vec text;
  };
+type StreamingToken = blob;
+type StreamingStrategy = variant {
+                           Callback:
+                            record {
+                              callback: StreamingCallback;
+                              token: StreamingToken;
+                            };};
+type StreamingCallbackResponse = 
+ record {
+   body: blob;
+   token: opt StreamingToken;
+ };
+type StreamingCallback = func (StreamingToken) ->
+                          (opt StreamingCallbackResponse) query;
 type StorageStats = 
  record {
    cyclesBalance: nat;
@@ -102,6 +116,22 @@ type Result =
    err: Err;
    ok;
  };
+type Response = 
+ record {
+   body: blob;
+   headers: vec Header;
+   status_code: nat16;
+   streaming_strategy: opt StreamingStrategy;
+   upgrade: opt bool;
+ };
+type Request = 
+ record {
+   body: blob;
+   certificate_version: opt nat16;
+   headers: vec Header;
+   method: text;
+   url: text;
+ };
 type PublishingId = text;
 type PublishingErr = text;
 type PageCount = nat;
@@ -232,6 +262,11 @@ type PackageChanges =
    notes: text;
    tests: TestsChanges;
  };
+type Header = 
+ record {
+   text;
+   text;
+ };
 type FileId = text;
 type Err = text;
 type DownloadsSnapshot__1 = 
@@ -300,6 +335,7 @@ service : {
   getTotalDownloads: () -> (nat) query;
   getTotalPackages: () -> (nat) query;
   getUser: (principal) -> (opt User__1) query;
+  http_request: (Request) -> (Response) query;
   notifyInstall: (PackageName__1, PackageVersion) -> () oneway;
   notifyInstalls: (vec record {
                          PackageName__1;

package/declarations/main/main.did.d.ts

@@ -23,6 +23,7 @@ export interface DownloadsSnapshot__1 {
 }
 export type Err = string;
 export type FileId = string;
+export type Header = [string, string];
 export interface PackageChanges {
   'tests' : TestsChanges,
   'deps' : Array<DepChange>,
@@ -142,6 +143,20 @@ export type PackageVersion = string;
 export type PageCount = bigint;
 export type PublishingErr = string;
 export type PublishingId = string;
+export interface Request {
+  'url' : string,
+  'method' : string,
+  'body' : Uint8Array | number[],
+  'headers' : Array<Header>,
+  'certificate_version' : [] | [number],
+}
+export interface Response {
+  'body' : Uint8Array | number[],
+  'headers' : Array<Header>,
+  'upgrade' : [] | [boolean],
+  'streaming_strategy' : [] | [StreamingStrategy],
+  'status_code' : number,
+}
 export type Result = { 'ok' : null } |
   { 'err' : Err };
 export type Result_1 = { 'ok' : PublishingId } |
@@ -168,6 +183,18 @@ export interface StorageStats {
   'cyclesBalance' : bigint,
   'memorySize' : bigint,
 }
+export type StreamingCallback = ActorMethod<
+  [StreamingToken],
+  [] | [StreamingCallbackResponse]
+>;
+export interface StreamingCallbackResponse {
+  'token' : [] | [StreamingToken],
+  'body' : Uint8Array | number[],
+}
+export type StreamingStrategy = {
+    'Callback' : { 'token' : StreamingToken, 'callback' : StreamingCallback }
+  };
+export type StreamingToken = Uint8Array | number[];
 export interface TestStats { 'passedNames' : Array<string>, 'passed' : bigint }
 export interface TestStats__1 {
   'passedNames' : Array<string>,
@@ -246,6 +273,7 @@ export interface _SERVICE {
   'getTotalDownloads' : ActorMethod<[], bigint>,
   'getTotalPackages' : ActorMethod<[], bigint>,
   'getUser' : ActorMethod<[Principal], [] | [User__1]>,
+  'http_request' : ActorMethod<[Request], Response>,
   'notifyInstall' : ActorMethod<[PackageName__1, PackageVersion], undefined>,
   'notifyInstalls' : ActorMethod<
     [Array<[PackageName__1, PackageVersion]>],

package/declarations/main/main.did.js

@@ -174,6 +174,37 @@ export const idlFactory = ({ IDL }) => {
     'githubVerified' : IDL.Bool,
     'github' : IDL.Text,
   });
+  const Header = IDL.Tuple(IDL.Text, IDL.Text);
+  const Request = IDL.Record({
+    'url' : IDL.Text,
+    'method' : IDL.Text,
+    'body' : IDL.Vec(IDL.Nat8),
+    'headers' : IDL.Vec(Header),
+    'certificate_version' : IDL.Opt(IDL.Nat16),
+  });
+  const StreamingToken = IDL.Vec(IDL.Nat8);
+  const StreamingCallbackResponse = IDL.Record({
+    'token' : IDL.Opt(StreamingToken),
+    'body' : IDL.Vec(IDL.Nat8),
+  });
+  const StreamingCallback = IDL.Func(
+      [StreamingToken],
+      [IDL.Opt(StreamingCallbackResponse)],
+      ['query'],
+    );
+  const StreamingStrategy = IDL.Variant({
+    'Callback' : IDL.Record({
+      'token' : StreamingToken,
+      'callback' : StreamingCallback,
+    }),
+  });
+  const Response = IDL.Record({
+    'body' : IDL.Vec(IDL.Nat8),
+    'headers' : IDL.Vec(Header),
+    'upgrade' : IDL.Opt(IDL.Bool),
+    'streaming_strategy' : IDL.Opt(StreamingStrategy),
+    'status_code' : IDL.Nat16,
+  });
   const PageCount = IDL.Nat;
   const Result_3 = IDL.Variant({ 'ok' : IDL.Null, 'err' : IDL.Text });
   const Result_2 = IDL.Variant({ 'ok' : FileId, 'err' : Err });
@@ -270,6 +301,7 @@ export const idlFactory = ({ IDL }) => {
     'getTotalDownloads' : IDL.Func([], [IDL.Nat], ['query']),
     'getTotalPackages' : IDL.Func([], [IDL.Nat], ['query']),
     'getUser' : IDL.Func([IDL.Principal], [IDL.Opt(User__1)], ['query']),
+    'http_request' : IDL.Func([Request], [Response], ['query']),
     'notifyInstall' : IDL.Func(
         [PackageName__1, PackageVersion],
         [],

package/dist/bench/$USER_BENCH_FILE.mo

@@ -0,0 +1,45 @@
+import Nat "mo:base/Nat";
+import Iter "mo:base/Iter";
+import Buffer "mo:base/Buffer";
+import Vector "mo:vector/Class";
+// import Bench "./bench";
+import Bench "mo:bench";
+
+module {
+	public func init() : Bench.Bench {
+		let bench = Bench.Bench();
+
+		bench.setName("Add items one-by-one");
+
+		bench.addRow("Vector");
+		bench.addRow("Buffer");
+
+		bench.addCol("10");
+		bench.addCol("10000");
+		bench.addCol("1000000");
+
+		bench.setRunner(func(row, col) {
+			let ?n = Nat.fromText(col);
+
+			// Vector
+			if (row == "Vector") {
+				let vec = Vector.Vector<Nat>();
+				for (i in Iter.range(1, n)) {
+					vec.add(i);
+				};
+			}
+			// Buffer
+			else if (row == "Buffer") {
+				let buf = Buffer.Buffer<Nat>(0);
+				for (i in Iter.range(1, n)) {
+					buf.add(i);
+				};
+			};
+		});
+
+		// bench.table(["Vector", "Buffer"], ["10", "10000", "1000000"], func(row, col) {
+		// });
+
+		bench;
+	};
+};

package/dist/bench/bench-canister.mo

@@ -0,0 +1,57 @@
+import Nat64 "mo:base/Nat64";
+import Debug "mo:base/Debug";
+import ExperimentalInternetComputer "mo:base/ExperimentalInternetComputer";
+import Prim "mo:prim";
+
+// import Bench "./bench";
+import Bench "mo:bench";
+
+import UserBench "$USER_BENCH_FILE";
+
+actor class() {
+	var benchOpt : ?Bench.Bench = null;
+
+	public func init() : async Bench.BenchSchema {
+		let bench = UserBench.init();
+		benchOpt := ?bench;
+		bench.getSchema();
+	};
+
+	// public composite query func noop() : async () {};
+
+	public func runCell(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+		let ?bench = benchOpt else Debug.trap("bench not initialized");
+
+		let rts_heap_size_before = Prim.rts_heap_size();
+		let rts_memory_size_before = Prim.rts_memory_size();
+		let rts_total_allocation_before = Prim.rts_total_allocation();
+		let rts_mutator_instructions_before = Prim.rts_mutator_instructions();
+		let rts_collector_instructions_before = Prim.rts_collector_instructions();
+
+		let mode : Bench.BenchMode = #replica;
+		let instructions = switch(mode) {
+			case (#replica) {
+				ExperimentalInternetComputer.countInstructions(func() {
+					bench.runCell(rowIndex, colIndex, #replica);
+				});
+			};
+			case (#wasi) {
+				bench.runCell(rowIndex, colIndex, #replica);
+				0 : Nat64;
+			};
+		};
+
+		// await noop();
+
+		// await (func() : async () {})();
+
+		{
+			instructions = Nat64.toNat(instructions);
+			rts_heap_size = Prim.rts_heap_size() - rts_heap_size_before;
+			rts_memory_size = Prim.rts_memory_size() - rts_memory_size_before;
+			rts_total_allocation = Prim.rts_total_allocation() - rts_total_allocation_before;
+			rts_mutator_instructions = Prim.rts_mutator_instructions() - rts_mutator_instructions_before;
+			rts_collector_instructions = Prim.rts_collector_instructions() - rts_collector_instructions_before;
+		}
+	};
+};

package/dist/commands/bench/$USER_BENCH_FILE.mo

@@ -0,0 +1,45 @@
+import Nat "mo:base/Nat";
+import Iter "mo:base/Iter";
+import Buffer "mo:base/Buffer";
+import Vector "mo:vector/Class";
+// import Bench "./bench";
+import Bench "mo:bench";
+
+module {
+	public func init() : Bench.Bench {
+		let bench = Bench.Bench();
+
+		bench.setName("Add items one-by-one");
+
+		bench.addRow("Vector");
+		bench.addRow("Buffer");
+
+		bench.addCol("10");
+		bench.addCol("10000");
+		bench.addCol("1000000");
+
+		bench.setRunner(func(row, col) {
+			let ?n = Nat.fromText(col);
+
+			// Vector
+			if (row == "Vector") {
+				let vec = Vector.Vector<Nat>();
+				for (i in Iter.range(1, n)) {
+					vec.add(i);
+				};
+			}
+			// Buffer
+			else if (row == "Buffer") {
+				let buf = Buffer.Buffer<Nat>(0);
+				for (i in Iter.range(1, n)) {
+					buf.add(i);
+				};
+			};
+		});
+
+		// bench.table(["Vector", "Buffer"], ["10", "10000", "1000000"], func(row, col) {
+		// });
+
+		bench;
+	};
+};

package/dist/commands/bench/bench/$USER_BENCH_FILE.mo

@@ -0,0 +1,45 @@
+import Nat "mo:base/Nat";
+import Iter "mo:base/Iter";
+import Buffer "mo:base/Buffer";
+import Vector "mo:vector/Class";
+// import Bench "./bench";
+import Bench "mo:bench";
+
+module {
+	public func init() : Bench.Bench {
+		let bench = Bench.Bench();
+
+		bench.setName("Add items one-by-one");
+
+		bench.addRow("Vector");
+		bench.addRow("Buffer");
+
+		bench.addCol("10");
+		bench.addCol("10000");
+		bench.addCol("1000000");
+
+		bench.setRunner(func(row, col) {
+			let ?n = Nat.fromText(col);
+
+			// Vector
+			if (row == "Vector") {
+				let vec = Vector.Vector<Nat>();
+				for (i in Iter.range(1, n)) {
+					vec.add(i);
+				};
+			}
+			// Buffer
+			else if (row == "Buffer") {
+				let buf = Buffer.Buffer<Nat>(0);
+				for (i in Iter.range(1, n)) {
+					buf.add(i);
+				};
+			};
+		});
+
+		// bench.table(["Vector", "Buffer"], ["10", "10000", "1000000"], func(row, col) {
+		// });
+
+		bench;
+	};
+};

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

@@ -0,0 +1,57 @@
+import Nat64 "mo:base/Nat64";
+import Debug "mo:base/Debug";
+import ExperimentalInternetComputer "mo:base/ExperimentalInternetComputer";
+import Prim "mo:prim";
+
+// import Bench "./bench";
+import Bench "mo:bench";
+
+import UserBench "$USER_BENCH_FILE";
+
+actor class() {
+	var benchOpt : ?Bench.Bench = null;
+
+	public func init() : async Bench.BenchSchema {
+		let bench = UserBench.init();
+		benchOpt := ?bench;
+		bench.getSchema();
+	};
+
+	// public composite query func noop() : async () {};
+
+	public func runCell(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+		let ?bench = benchOpt else Debug.trap("bench not initialized");
+
+		let rts_heap_size_before = Prim.rts_heap_size();
+		let rts_memory_size_before = Prim.rts_memory_size();
+		let rts_total_allocation_before = Prim.rts_total_allocation();
+		let rts_mutator_instructions_before = Prim.rts_mutator_instructions();
+		let rts_collector_instructions_before = Prim.rts_collector_instructions();
+
+		let mode : Bench.BenchMode = #replica;
+		let instructions = switch(mode) {
+			case (#replica) {
+				ExperimentalInternetComputer.countInstructions(func() {
+					bench.runCell(rowIndex, colIndex, #replica);
+				});
+			};
+			case (#wasi) {
+				bench.runCell(rowIndex, colIndex, #replica);
+				0 : Nat64;
+			};
+		};
+
+		// await noop();
+
+		// await (func() : async () {})();
+
+		{
+			instructions = Nat64.toNat(instructions);
+			rts_heap_size = Prim.rts_heap_size() - rts_heap_size_before;
+			rts_memory_size = Prim.rts_memory_size() - rts_memory_size_before;
+			rts_total_allocation = Prim.rts_total_allocation() - rts_total_allocation_before;
+			rts_mutator_instructions = Prim.rts_mutator_instructions() - rts_mutator_instructions_before;
+			rts_collector_instructions = Prim.rts_collector_instructions() - rts_collector_instructions_before;
+		}
+	};
+};

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

@@ -0,0 +1,85 @@
+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();
+	};
+
+	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 _runCell(rowIndex : Nat, colIndex : Nat) : Bench.BenchResult {
+		let ?bench = benchOpt else Debug.trap("bench not initialized");
+		let statsBefore = _getStats();
+
+		let instructions = ExperimentalInternetComputer.countInstructions(func() {
+			bench.runCell(rowIndex, colIndex);
+		});
+
+		// await (func() : async () {})();
+
+		let statsAfter = _getStats();
+
+		{
+			instructions = Nat64.toNat(instructions);
+			rts_heap_size = statsAfter.rts_heap_size - statsBefore.rts_heap_size;
+			rts_memory_size = statsAfter.rts_memory_size - statsBefore.rts_memory_size;
+			rts_total_allocation = statsAfter.rts_total_allocation - statsBefore.rts_total_allocation;
+			rts_mutator_instructions = statsAfter.rts_mutator_instructions - statsBefore.rts_mutator_instructions;
+			rts_collector_instructions = statsAfter.rts_collector_instructions - statsBefore.rts_collector_instructions;
+		}
+	};
+
+	func _runCellAwait(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+		let ?bench = benchOpt else Debug.trap("bench not initialized");
+		let statsBefore = _getStats();
+
+		let instructions = ExperimentalInternetComputer.countInstructions(func() {
+			bench.runCell(rowIndex, colIndex);
+		});
+
+		await (func() : async () {})();
+
+		let statsAfter = _getStats();
+
+		{
+			instructions = Nat64.toNat(instructions);
+			rts_heap_size = statsAfter.rts_heap_size - statsBefore.rts_heap_size;
+			rts_memory_size = statsAfter.rts_memory_size - statsBefore.rts_memory_size;
+			rts_total_allocation = statsAfter.rts_total_allocation - statsBefore.rts_total_allocation;
+			rts_mutator_instructions = statsAfter.rts_mutator_instructions - statsBefore.rts_mutator_instructions;
+			rts_collector_instructions = statsAfter.rts_collector_instructions - statsBefore.rts_collector_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 {
+		await _runCellAwait(rowIndex, colIndex);
+	};
+};

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

@@ -0,0 +1,6 @@
+export function idlFactory({ IDL }: {
+    IDL: any;
+}): any;
+export function init({ IDL }: {
+    IDL: any;
+}): never[];

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

@@ -0,0 +1,22 @@
+export const idlFactory = ({ IDL }) => {
+    const BenchSchema = IDL.Record({
+        'title': IDL.Text,
+        'cols': IDL.Vec(IDL.Text),
+        'rows': IDL.Vec(IDL.Text),
+        'description': IDL.Text,
+    });
+    const BenchResult = IDL.Record({
+        'instructions': IDL.Nat,
+        'rts_memory_size': IDL.Nat,
+        'rts_total_allocation': IDL.Nat,
+        'rts_collector_instructions': IDL.Nat,
+        'rts_mutator_instructions': IDL.Nat,
+        'rts_heap_size': IDL.Nat,
+    });
+    const anon_class_11_1 = IDL.Service({
+        'init': IDL.Func([], [BenchSchema], []),
+        'runCell': IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], []),
+    });
+    return anon_class_11_1;
+};
+export const init = ({ IDL }) => { return []; };

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

@@ -0,0 +1,2 @@
+export const canisterId: string | undefined;
+export function createActor(canisterId: any, options?: {}): import("@dfinity/agent").ActorSubclass<Record<string, import("@dfinity/agent").ActorMethod<unknown[], unknown>>>;

package/dist/commands/bench/declarations/bench/index.js

@@ -0,0 +1,30 @@
+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/commands/bench/declarations/main/index.d.ts

@@ -0,0 +1,2 @@
+export const canisterId: string | undefined;
+export function createActor(canisterId: any, options?: {}): import("@dfinity/agent").ActorSubclass<Record<string, import("@dfinity/agent").ActorMethod<unknown[], unknown>>>;

package/dist/commands/bench/declarations/main/index.js

@@ -0,0 +1,30 @@
+import { Actor, HttpAgent } from "@dfinity/agent";
+// Imports and re-exports candid interface
+import { idlFactory } from "./main.did.js";
+export { idlFactory } from "./main.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_MAIN ||
+    process.env.MAIN_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/commands/bench/declarations/main/main.did.d.ts

@@ -0,0 +1,6 @@
+export function idlFactory({ IDL }: {
+    IDL: any;
+}): any;
+export function init({ IDL }: {
+    IDL: any;
+}): never[];