ic-mops 0.36.1 → 0.37.0

package/dist/pic-js/examples/todo/tests/src/todo.spec.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const agent_1 = require("@dfinity/agent");
+const pic_1 = require("@hadronous/pic");
+const todo_1 = require("../todo");
+const WASM_PATH = (0, node_path_1.resolve)(__dirname, '..', '..', '..', '..', '.dfx', 'local', 'canisters', 'todo', 'todo.wasm');
+describe('Todo', () => {
+    let pic;
+    let actor;
+    let canisterId;
+    const alice = (0, pic_1.createIdentity)('superSecretAlicePassword');
+    const bob = (0, pic_1.createIdentity)('superSecretBobPassword');
+    beforeEach(async () => {
+        pic = await pic_1.PocketIc.create();
+        const fixture = await pic.setupCanister(todo_1.idlFactory, WASM_PATH);
+        actor = fixture.actor;
+        canisterId = fixture.canisterId;
+    });
+    afterEach(async () => {
+        await pic.tearDown();
+    });
+    describe('with an anonymous user', () => {
+        const identity = new agent_1.AnonymousIdentity();
+        const expectedError = 'Anonymous principals are not allowed to call this method';
+        beforeEach(() => {
+            actor.setIdentity(identity);
+        });
+        it('should prevent creating a todo', async () => {
+            await expect(actor.create_todo({
+                text: 'Learn Rust',
+            })).rejects.toThrow(expectedError);
+        });
+        it('should prevent getting todos', async () => {
+            await expect(actor.get_todos()).rejects.toThrow(expectedError);
+        });
+        it('should prevent updating a todo', async () => {
+            await expect(actor.update_todo(1n, {
+                text: ['Learn Rust'],
+                done: [],
+            })).rejects.toThrow(expectedError);
+        });
+        it('should prevent deleting a todo', async () => {
+            await expect(actor.delete_todo(1n)).rejects.toThrow(expectedError);
+        });
+    });
+    describe('with alice', () => {
+        beforeEach(() => {
+            actor.setIdentity(alice);
+        });
+        it('should allow creating a todo', async () => {
+            const initialGetResponse = await actor.get_todos();
+            const createResponse = await actor.create_todo({ text: 'Learn Rust' });
+            const getResponse = await actor.get_todos();
+            expect(initialGetResponse.todos).toHaveLength(0);
+            expect(getResponse.todos).toHaveLength(1);
+            expect(getResponse.todos).toContainEqual({
+                id: createResponse.id,
+                text: 'Learn Rust',
+                done: false,
+            });
+        });
+        it('should allow updating a todo', async () => {
+            const initialGetResponse = await actor.get_todos();
+            const createResponse = await actor.create_todo({
+                text: 'Learn Rust',
+            });
+            const afterCreateGetResponse = await actor.get_todos();
+            await actor.update_todo(createResponse.id, {
+                text: ['Learn Rust and WebAssembly'],
+                done: [],
+            });
+            const afterUpdateGetResponse = await actor.get_todos();
+            expect(initialGetResponse.todos).toHaveLength(0);
+            expect(afterCreateGetResponse.todos).toHaveLength(1);
+            expect(afterCreateGetResponse.todos).toContainEqual({
+                id: createResponse.id,
+                text: 'Learn Rust',
+                done: false,
+            });
+            expect(afterUpdateGetResponse.todos).toHaveLength(1);
+            expect(afterUpdateGetResponse.todos).toContainEqual({
+                id: createResponse.id,
+                text: 'Learn Rust and WebAssembly',
+                done: false,
+            });
+        });
+        it('should allow deleting a todo', async () => {
+            const initialGetResponse = await actor.get_todos();
+            const createResponse = await actor.create_todo({
+                text: 'Learn Rust',
+            });
+            const afterCreateGetResponse = await actor.get_todos();
+            await actor.delete_todo(createResponse.id);
+            const afterDeleteGetResponse = await actor.get_todos();
+            expect(initialGetResponse.todos).toHaveLength(0);
+            expect(afterCreateGetResponse.todos).toHaveLength(1);
+            expect(afterCreateGetResponse.todos).toContainEqual({
+                id: createResponse.id,
+                text: 'Learn Rust',
+                done: false,
+            });
+            expect(afterDeleteGetResponse.todos).toHaveLength(0);
+        });
+    });
+    describe('with alice and bob', () => {
+        it("should return alice's todos to alice and bob's todos to bob", async () => {
+            actor.setIdentity(alice);
+            const aliceCreateResponse = await actor.create_todo({
+                text: 'Learn Rust',
+            });
+            const aliceAfterCreateGetResponse = await actor.get_todos();
+            actor.setIdentity(bob);
+            const bobCreateResponse = await actor.create_todo({
+                text: 'Learn WebAssembly',
+            });
+            const bobAfterCreateGetResponse = await actor.get_todos();
+            expect(aliceAfterCreateGetResponse.todos).toHaveLength(1);
+            expect(aliceAfterCreateGetResponse.todos).toContainEqual({
+                id: aliceCreateResponse.id,
+                text: 'Learn Rust',
+                done: false,
+            });
+            expect(bobAfterCreateGetResponse.todos).toHaveLength(1);
+            expect(bobAfterCreateGetResponse.todos).toContainEqual({
+                id: bobCreateResponse.id,
+                text: 'Learn WebAssembly',
+                done: false,
+            });
+        });
+        it("should prevent bob from updating alice's todo", async () => {
+            actor.setIdentity(alice);
+            const aliceCreateResponse = await actor.create_todo({
+                text: 'Learn Rust',
+            });
+            actor.setIdentity(bob);
+            await expect(actor.update_todo(aliceCreateResponse.id, {
+                text: ['Learn Rust and WebAssembly'],
+                done: [],
+            })).rejects.toThrow(`Caller with principal ${bob
+                .getPrincipal()
+                .toText()} does not own todo with id ${aliceCreateResponse.id}`);
+        });
+        it('should prevent bob from deleting alices todo', async () => {
+            actor.setIdentity(alice);
+            const aliceCreateResponse = await actor.create_todo({
+                text: 'Learn Rust',
+            });
+            actor.setIdentity(bob);
+            await expect(actor.delete_todo(aliceCreateResponse.id)).rejects.toThrow(`Caller with principal ${bob
+                .getPrincipal()
+                .toText()} does not own todo with id ${aliceCreateResponse.id}`);
+        });
+        it('should survive an upgrade', async () => {
+            actor.setIdentity(alice);
+            const aliceCreateResponse = await actor.create_todo({
+                text: 'Learn Rust',
+            });
+            actor.setIdentity(bob);
+            const bobCreateResponse = await actor.create_todo({
+                text: 'Learn WebAssembly',
+            });
+            await pic.upgradeCanister(canisterId, WASM_PATH);
+            actor.setIdentity(alice);
+            const aliceAfterUpgradeGetResponse = await actor.get_todos();
+            actor.setIdentity(bob);
+            const bobAfterUpgradeGetResponse = await actor.get_todos();
+            expect(aliceAfterUpgradeGetResponse.todos).toHaveLength(1);
+            expect(aliceAfterUpgradeGetResponse.todos).toContainEqual({
+                id: aliceCreateResponse.id,
+                text: 'Learn Rust',
+                done: false,
+            });
+            expect(bobAfterUpgradeGetResponse.todos).toHaveLength(1);
+            expect(bobAfterUpgradeGetResponse.todos).toContainEqual({
+                id: bobCreateResponse.id,
+                text: 'Learn WebAssembly',
+                done: false,
+            });
+        });
+        it('should survive a reset and stable memory restore', async () => {
+            actor.setIdentity(alice);
+            const aliceCreateResponse = await actor.create_todo({
+                text: 'Learn Rust',
+            });
+            actor.setIdentity(bob);
+            const bobCreateResponse = await actor.create_todo({
+                text: 'Learn WebAssembly',
+            });
+            const stableMemory = await pic.getStableMemory(canisterId);
+            await pic.reinstallCode(canisterId, WASM_PATH);
+            await pic.setStableMemory(canisterId, stableMemory);
+            actor.setIdentity(alice);
+            const aliceAfterUpgradeGetResponse = await actor.get_todos();
+            actor.setIdentity(bob);
+            const bobAfterUpgradeGetResponse = await actor.get_todos();
+            expect(aliceAfterUpgradeGetResponse.todos).toHaveLength(1);
+            expect(aliceAfterUpgradeGetResponse.todos).toContainEqual({
+                id: aliceCreateResponse.id,
+                text: 'Learn Rust',
+                done: false,
+            });
+            expect(bobAfterUpgradeGetResponse.todos).toHaveLength(1);
+            expect(bobAfterUpgradeGetResponse.todos).toContainEqual({
+                id: bobCreateResponse.id,
+                text: 'Learn WebAssembly',
+                done: false,
+            });
+        });
+    });
+});

package/dist/pic-js/examples/todo/tests/todo/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pic-js/examples/todo/tests/todo/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.idlFactory = void 0;
+var todo_did_1 = require("../../declarations/todo.did");
+Object.defineProperty(exports, "idlFactory", { enumerable: true, get: function () { return todo_did_1.idlFactory; } });

package/dist/pic-js/packages/pic/src/error.d.ts

@@ -0,0 +1,12 @@
+export declare class BinStartError extends Error {
+    constructor(cause: Error);
+}
+export declare class BinStartMacOSArmError extends Error {
+    constructor(cause: Error);
+}
+export declare class BinNotFoundError extends Error {
+    constructor(picBinPath: string);
+}
+export declare class BinTimeoutError extends Error {
+    constructor();
+}

package/dist/pic-js/packages/pic/src/error.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinTimeoutError = exports.BinNotFoundError = exports.BinStartMacOSArmError = exports.BinStartError = void 0;
+class BinStartError extends Error {
+    constructor(cause) {
+        super(`There was an error starting the PocketIC Binary.
+
+Original error: ${cause.name} ${cause.message}.
+${cause.stack}`, { cause });
+    }
+}
+exports.BinStartError = BinStartError;
+class BinStartMacOSArmError extends Error {
+    constructor(cause) {
+        super(`There was an error starting the PocketIC Binary.
+
+It seems you are running on an Apple Silicon Mac. The PocketIC binary can not run with the ARM architecture on Apple Silicon Macs.
+Please install and enable Rosetta if it is not enabled and try again.
+
+Original error: ${cause.name} ${cause.message}.
+${cause.stack}`, { cause });
+    }
+}
+exports.BinStartMacOSArmError = BinStartMacOSArmError;
+class BinNotFoundError extends Error {
+    constructor(picBinPath) {
+        super(`Could not find the PocketIC binary. The PocketIC binary could not be found at ${picBinPath}. Please try installing @hadronous/pic again.`);
+    }
+}
+exports.BinNotFoundError = BinNotFoundError;
+class BinTimeoutError extends Error {
+    constructor() {
+        super('The PocketIC binary took too long to start. Please try again.');
+    }
+}
+exports.BinTimeoutError = BinTimeoutError;

package/dist/pic-js/packages/pic/src/http-client.d.ts

@@ -0,0 +1,15 @@
+export type HeadersInit = Record<string, string>;
+export interface GetOptions {
+    headers?: HeadersInit;
+}
+export interface PostOptions<P> {
+    body?: P;
+    headers?: HeadersInit;
+}
+export declare const JSON_HEADER: HeadersInit;
+export declare class HttpClient {
+    private constructor();
+    static get<R>(url: string, options?: GetOptions): Promise<R>;
+    static post<P, R>(url: string, options?: PostOptions<P>): Promise<R>;
+}
+export declare function handleFetchError(response: Response): void;

package/dist/pic-js/packages/pic/src/http-client.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleFetchError = exports.HttpClient = exports.JSON_HEADER = void 0;
+exports.JSON_HEADER = {
+    'Content-Type': 'application/json',
+};
+class HttpClient {
+    constructor() { }
+    static async get(url, options) {
+        const headers = options?.headers ?? {};
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: { ...headers, ...exports.JSON_HEADER },
+        });
+        handleFetchError(response);
+        return (await response.json());
+    }
+    static async post(url, options) {
+        const body = options?.body ? JSON.stringify(options.body) : null;
+        const headers = options?.headers ?? {};
+        const response = await fetch(url, {
+            method: 'POST',
+            body,
+            headers: { ...headers, ...exports.JSON_HEADER },
+        });
+        handleFetchError(response);
+        return (await response.json());
+    }
+}
+exports.HttpClient = HttpClient;
+function handleFetchError(response) {
+    if (!response.ok) {
+        console.error('Error response', response.url, response.statusText);
+        throw new Error(`${response.url} ${response.statusText}`);
+    }
+}
+exports.handleFetchError = handleFetchError;

package/dist/pic-js/packages/pic/src/identity.d.ts

@@ -0,0 +1,66 @@
+import { Identity } from '@dfinity/agent';
+/**
+ * Create an Identity from a seed phrase.
+ * The seed phrase can be any arbitrary string.
+ *
+ * The Identity is generated deterministically from the seed phrase,
+ * so subsequent calls to this function with the same seed phrase will
+ * produce the same Identity.
+ *
+ * This is useful for tests where a persistent Identity is necessary
+ * but it's easier to store the seed phrase than the Identity itself.
+ *
+ * @category API
+ * @param seedPhrase The seed phrase to create the identity from. Can be any arbitrary string.
+ * @returns An identity created from the seed phrase.
+ *
+ * @see [Identity](https://agent-js.icp.xyz/agent/interfaces/Identity.html)
+ *
+ * @example
+ * ```ts
+ * import { PocketIc, createIdentity } from '@hadronous/pic';
+ * import { AnonymousIdentity } from '@dfinity/agent';
+ * import { _SERVICE, idlFactory } from '../declarations';
+ *
+ * const wasmPath = resolve('..', '..', 'canister.wasm');
+ *
+ * const pic = await PocketIc.create();
+ * const fixture = await pic.setupCanister<_SERVICE>(idlFactory, wasmPath);
+ * const { actor } = fixture;
+ *
+ * const bob = createIdentity('SuperSecretSeedPhraseForBob');
+ * actor.setIdentity(bob);
+ * ```
+ */
+export declare function createIdentity(seedPhrase: string): Identity;
+/**
+ * Create an Identity from a randomly generated bip39 seed phrase.
+ * Subsequent calls to this function will produce different Identities
+ * with an extremely low probability of collision.
+ *
+ * This is useful for tests where it is important to avoid conflicts arising
+ * from multiple identities accessing the same canister and maintaining
+ * the necessary seed phrases would become cumbersome.
+ *
+ * @category API
+ * @returns An identity created from a random seed phrase.
+ *
+ * @see [Identity](https://agent-js.icp.xyz/agent/interfaces/Identity.html)
+ *
+ * @example
+ * ```ts
+ * import { PocketIc, generateRandomIdentity } from '@hadronous/pic';
+ * import { AnonymousIdentity } from '@dfinity/agent';
+ * import { _SERVICE, idlFactory } from '../declarations';
+ *
+ * const wasmPath = resolve('..', '..', 'canister.wasm');
+ *
+ * const pic = await PocketIc.create();
+ * const fixture = await pic.setupCanister<_SERVICE>(idlFactory, wasmPath);
+ * const { actor } = fixture;
+ *
+ * const bob = generateRandomIdentity();
+ * actor.setIdentity(bob);
+ * ```
+ */
+export declare function generateRandomIdentity(): Identity;

package/dist/pic-js/packages/pic/src/identity.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomIdentity = exports.createIdentity = void 0;
+const node_crypto_1 = require("node:crypto");
+const bip39_1 = require("bip39");
+const identity_1 = require("@dfinity/identity");
+/**
+ * Create an Identity from a seed phrase.
+ * The seed phrase can be any arbitrary string.
+ *
+ * The Identity is generated deterministically from the seed phrase,
+ * so subsequent calls to this function with the same seed phrase will
+ * produce the same Identity.
+ *
+ * This is useful for tests where a persistent Identity is necessary
+ * but it's easier to store the seed phrase than the Identity itself.
+ *
+ * @category API
+ * @param seedPhrase The seed phrase to create the identity from. Can be any arbitrary string.
+ * @returns An identity created from the seed phrase.
+ *
+ * @see [Identity](https://agent-js.icp.xyz/agent/interfaces/Identity.html)
+ *
+ * @example
+ * ```ts
+ * import { PocketIc, createIdentity } from '@hadronous/pic';
+ * import { AnonymousIdentity } from '@dfinity/agent';
+ * import { _SERVICE, idlFactory } from '../declarations';
+ *
+ * const wasmPath = resolve('..', '..', 'canister.wasm');
+ *
+ * const pic = await PocketIc.create();
+ * const fixture = await pic.setupCanister<_SERVICE>(idlFactory, wasmPath);
+ * const { actor } = fixture;
+ *
+ * const bob = createIdentity('SuperSecretSeedPhraseForBob');
+ * actor.setIdentity(bob);
+ * ```
+ */
+function createIdentity(seedPhrase) {
+    const hash = (0, node_crypto_1.createHash)('sha256');
+    hash.update(seedPhrase);
+    const digest = hash.digest('hex').slice(0, 32);
+    const encodedDigest = new TextEncoder().encode(digest);
+    return identity_1.Ed25519KeyIdentity.generate(encodedDigest);
+}
+exports.createIdentity = createIdentity;
+function generateMnemonic() {
+    const entropy = (0, node_crypto_1.randomBytes)(16);
+    return (0, bip39_1.entropyToMnemonic)(entropy);
+}
+/**
+ * Create an Identity from a randomly generated bip39 seed phrase.
+ * Subsequent calls to this function will produce different Identities
+ * with an extremely low probability of collision.
+ *
+ * This is useful for tests where it is important to avoid conflicts arising
+ * from multiple identities accessing the same canister and maintaining
+ * the necessary seed phrases would become cumbersome.
+ *
+ * @category API
+ * @returns An identity created from a random seed phrase.
+ *
+ * @see [Identity](https://agent-js.icp.xyz/agent/interfaces/Identity.html)
+ *
+ * @example
+ * ```ts
+ * import { PocketIc, generateRandomIdentity } from '@hadronous/pic';
+ * import { AnonymousIdentity } from '@dfinity/agent';
+ * import { _SERVICE, idlFactory } from '../declarations';
+ *
+ * const wasmPath = resolve('..', '..', 'canister.wasm');
+ *
+ * const pic = await PocketIc.create();
+ * const fixture = await pic.setupCanister<_SERVICE>(idlFactory, wasmPath);
+ * const { actor } = fixture;
+ *
+ * const bob = generateRandomIdentity();
+ * actor.setIdentity(bob);
+ * ```
+ */
+function generateRandomIdentity() {
+    const mnemonic = generateMnemonic();
+    return createIdentity(mnemonic);
+}
+exports.generateRandomIdentity = generateRandomIdentity;

package/dist/pic-js/packages/pic/src/index.d.ts

@@ -0,0 +1,4 @@
+export { createIdentity, generateRandomIdentity } from './identity';
+export type { Actor, ActorInterface, ActorMethod } from './pocket-ic-actor';
+export { PocketIc } from './pocket-ic';
+export type { CanisterFixture, CreateCanisterOptions } from './pocket-ic-types';

package/dist/pic-js/packages/pic/src/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PocketIc = exports.generateRandomIdentity = exports.createIdentity = void 0;
+var identity_1 = require("./identity");
+Object.defineProperty(exports, "createIdentity", { enumerable: true, get: function () { return identity_1.createIdentity; } });
+Object.defineProperty(exports, "generateRandomIdentity", { enumerable: true, get: function () { return identity_1.generateRandomIdentity; } });
+var pocket_ic_1 = require("./pocket-ic");
+Object.defineProperty(exports, "PocketIc", { enumerable: true, get: function () { return pocket_ic_1.PocketIc; } });

package/dist/pic-js/packages/pic/src/management-canister.d.ts

@@ -0,0 +1,30 @@
+import { IDL } from '@dfinity/candid';
+import { Principal } from '@dfinity/principal';
+export declare const MANAGEMENT_CANISTER_ID: Principal;
+export interface CanisterSettings {
+    controllers: Principal[];
+    compute_allocation: [] | [bigint];
+    memory_allocation: [] | [bigint];
+    freezing_threshold: [] | [bigint];
+}
+export declare const CanisterSettings: IDL.OptClass<Record<string, any>>;
+export interface CreateCanisterRequest {
+    settings: [] | [CanisterSettings];
+    amount: [] | [bigint];
+}
+export declare function encodeCreateCanisterRequest(arg: CreateCanisterRequest): Uint8Array;
+export interface CreateCanisterResponse {
+    canister_id: Principal;
+}
+export declare function decodeCreateCanisterResponse(arg: Uint8Array): CreateCanisterResponse;
+export interface InstallCodeRequest {
+    arg: Uint8Array;
+    wasm_module: Uint8Array;
+    mode: {
+        reinstall?: null;
+        upgrade?: null;
+        install?: null;
+    };
+    canister_id: Principal;
+}
+export declare function encodeInstallCodeRequest(arg: InstallCodeRequest): Uint8Array;

package/dist/pic-js/packages/pic/src/management-canister.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeInstallCodeRequest = exports.decodeCreateCanisterResponse = exports.encodeCreateCanisterRequest = exports.CanisterSettings = exports.MANAGEMENT_CANISTER_ID = void 0;
+const candid_1 = require("@dfinity/candid");
+const principal_1 = require("@dfinity/principal");
+exports.MANAGEMENT_CANISTER_ID = principal_1.Principal.fromText('aaaaa-aa');
+exports.CanisterSettings = candid_1.IDL.Opt(candid_1.IDL.Record({
+    controllers: candid_1.IDL.Opt(candid_1.IDL.Vec(candid_1.IDL.Principal)),
+    compute_allocation: candid_1.IDL.Opt(candid_1.IDL.Nat),
+    memory_allocation: candid_1.IDL.Opt(candid_1.IDL.Nat),
+    freezing_threshold: candid_1.IDL.Opt(candid_1.IDL.Nat),
+}));
+const CreateCanisterRequest = candid_1.IDL.Record({
+    settings: exports.CanisterSettings,
+    amount: candid_1.IDL.Opt(candid_1.IDL.Nat),
+});
+function encodeCreateCanisterRequest(arg) {
+    return new Uint8Array(candid_1.IDL.encode([CreateCanisterRequest], [arg]));
+}
+exports.encodeCreateCanisterRequest = encodeCreateCanisterRequest;
+const CreateCanisterResponse = candid_1.IDL.Record({
+    canister_id: candid_1.IDL.Principal,
+});
+function decodeCreateCanisterResponse(arg) {
+    const [payload] = candid_1.IDL.decode([CreateCanisterResponse], arg);
+    // [TODO] - type check?
+    return payload;
+}
+exports.decodeCreateCanisterResponse = decodeCreateCanisterResponse;
+const InstallCodeRequest = candid_1.IDL.Record({
+    arg: candid_1.IDL.Vec(candid_1.IDL.Nat8),
+    wasm_module: candid_1.IDL.Vec(candid_1.IDL.Nat8),
+    mode: candid_1.IDL.Variant({
+        reinstall: candid_1.IDL.Null,
+        upgrade: candid_1.IDL.Null,
+        install: candid_1.IDL.Null,
+    }),
+    canister_id: candid_1.IDL.Principal,
+});
+function encodeInstallCodeRequest(arg) {
+    return new Uint8Array(candid_1.IDL.encode([InstallCodeRequest], [arg]));
+}
+exports.encodeInstallCodeRequest = encodeInstallCodeRequest;

package/dist/pic-js/packages/pic/src/pocket-ic-actor.d.ts

@@ -0,0 +1,83 @@
+import { IDL } from '@dfinity/candid';
+import { Principal } from '@dfinity/principal';
+import { Identity } from '@dfinity/agent';
+import { PocketIcClient } from './pocket-ic-client';
+/**
+ * Typesafe method of a canister.
+ *
+ * @category Types
+ */
+export interface ActorMethod<Args extends unknown[] = unknown[], Ret = unknown> {
+    (...args: Args): Promise<Ret>;
+}
+/**
+ * Candid interface of a canister.
+ *
+ * @category Types
+ */
+export type ActorInterface = Record<string, ActorMethod>;
+/**
+ * A typesafe class that implements the Candid interface of a canister.
+ * This is acquired by calling {@link PocketIc.setupCanister | setupCanister}
+ * or {@link PocketIc.createActor | createActor}.
+ *
+ * @category API
+ * @typeparam T The type of the {@link Actor}. Must implement {@link ActorInterface}.
+ * @interface
+ */
+export type Actor<T = ActorInterface> = T & {
+    /**
+     * @ignore
+     */
+    new (): Actor<T>;
+    /**
+     * Set a Principal to be used as sender for all calls to the canister.
+     *
+     * @param principal The Principal to set.
+     *
+     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
+     *
+     * @example
+     * ```ts
+     * import { PocketIc } from '@hadronous/pic';
+     * import { Principal } from '@dfinity/principal';
+     * import { _SERVICE, idlFactory } from '../declarations';
+     *
+     * const wasmPath = resolve('..', '..', 'canister.wasm');
+     *
+     * const pic = await PocketIc.create();
+     * const fixture = await pic.setupCanister<_SERVICE>(idlFactory, wasmPath);
+     * const { actor } = fixture;
+     *
+     * actor.setPrincipal(Principal.anonymous());
+     * ```
+     */
+    setPrincipal(principal: Principal): void;
+    /**
+     * Set a Principal to be used as sender for all calls to the canister.
+     * This is a convenience method over {@link setPrincipal} that accepts an
+     * Identity and internally extracts the Principal.
+     *
+     * @param identity The identity to set.
+     *
+     * @see [Identity](https://agent-js.icp.xyz/agent/interfaces/Identity.html)
+     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
+     *
+     * @example
+     * ```ts
+     * import { PocketIc } from '@hadronous/pic';
+     * import { AnonymousIdentity } from '@dfinity/agent';
+     * import { _SERVICE, idlFactory } from '../declarations';
+     *
+     * const wasmPath = resolve('..', '..', 'canister.wasm');
+     *
+     * const pic = await PocketIc.create();
+     * const fixture = await pic.setupCanister<_SERVICE>(idlFactory, wasmPath);
+     * const { actor } = fixture;
+     *
+     * actor.setIdentity(new AnonymousIdentity());
+     * ```
+     */
+    setIdentity(identity: Identity): void;
+};
+export declare function createActorClass<T = ActorInterface>(interfaceFactory: IDL.InterfaceFactory, canisterId: Principal, pocketIcClient: PocketIcClient): Actor<T>;