ic-mops 0.36.1 → 0.37.0

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActorClass = void 0;
+const candid_1 = require("@dfinity/candid");
+const principal_1 = require("@dfinity/principal");
+function createActorClass(interfaceFactory, canisterId, pocketIcClient) {
+    const service = interfaceFactory({ IDL: candid_1.IDL });
+    let sender = null;
+    function decodeReturnValue(types, msg) {
+        const returnValues = candid_1.IDL.decode(types, msg);
+        switch (returnValues.length) {
+            case 0:
+                return undefined;
+            case 1:
+                return returnValues[0];
+            default:
+                return returnValues;
+        }
+    }
+    function createActorMethod(methodName, func) {
+        if (func.annotations.includes('query') ||
+            func.annotations.includes('composite_query')) {
+            return createQueryMethod(methodName, func);
+        }
+        return createCallMethod(methodName, func);
+    }
+    function getSender() {
+        return sender ?? principal_1.Principal.anonymous();
+    }
+    function createQueryMethod(methodName, func) {
+        return async function (...args) {
+            const arg = candid_1.IDL.encode(func.argTypes, args);
+            const sender = getSender();
+            const response = await pocketIcClient.queryCall(canisterId, sender, methodName, new Uint8Array(arg));
+            return decodeReturnValue(func.retTypes, response);
+        };
+    }
+    function createCallMethod(methodName, func) {
+        return async function (...args) {
+            const arg = candid_1.IDL.encode(func.argTypes, args);
+            const sender = getSender();
+            const response = await pocketIcClient.updateCall(canisterId, sender, methodName, new Uint8Array(arg));
+            return decodeReturnValue(func.retTypes, response);
+        };
+    }
+    function Actor() { }
+    Actor.prototype.setPrincipal = function (newSender) {
+        sender = newSender;
+    };
+    Actor.prototype.setIdentity = function (identity) {
+        sender = identity.getPrincipal();
+    };
+    service._fields.forEach(([methodName, func]) => {
+        Actor.prototype[methodName] = createActorMethod(methodName, func);
+    });
+    return Actor;
+}
+exports.createActorClass = createActorClass;

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

@@ -0,0 +1,61 @@
+export interface CreateInstanceSuccessResponse {
+    Created: {
+        instance_id: number;
+    };
+}
+export interface CreateInstanceErrorResponse {
+    Error: {
+        message: string;
+    };
+}
+export type CreateInstanceResponse = CreateInstanceSuccessResponse | CreateInstanceErrorResponse;
+export interface CanisterCallRequest {
+    sender: string;
+    canister_id: string;
+    method: string;
+    payload: string;
+}
+export interface CanisterCallSuccessResponse {
+    Ok: {
+        Reply: string;
+    };
+}
+export interface CanisterCallErrorResponse {
+    Err: {
+        code: string;
+        description: string;
+    };
+}
+export type CanisterCallResponse = CanisterCallSuccessResponse | CanisterCallErrorResponse;
+export interface GetTimeResponse {
+    nanos_since_epoch: number;
+}
+export interface SetTimeRequest {
+    nanos_since_epoch: number;
+}
+export interface CheckCanisterExistsRequest {
+    canister_id: string;
+}
+export interface GetCanisterCyclesBalanceRequest {
+    canister_id: string;
+}
+export interface GetCanisterCyclesBalanceResponse {
+    cycles: number;
+}
+export interface AddCanisterCyclesRequest {
+    canister_id: string;
+    amount: number;
+}
+export interface AddCanisterCyclesResponse {
+    cycles: number;
+}
+export interface SetStableMemoryRequest {
+    canister_id: string;
+    blob_id: number[];
+}
+export interface GetStableMemoryRequest {
+    canister_id: string;
+}
+export interface GetStableMemoryResponse {
+    blob: string;
+}

package/dist/pic-js/packages/pic/src/pocket-ic-client-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,24 @@
+import { Principal } from '@dfinity/principal';
+export declare class PocketIcClient {
+    private readonly instanceUrl;
+    private readonly serverUrl;
+    private constructor();
+    static create(url: string): Promise<PocketIcClient>;
+    private static createInstance;
+    deleteInstance(): Promise<void>;
+    tick(): Promise<void>;
+    getTime(): Promise<number>;
+    setTime(time: number): Promise<void>;
+    fetchRootKey(): Promise<Uint8Array>;
+    checkCanisterExists(canisterId: Principal): Promise<boolean>;
+    getCyclesBalance(canisterId: Principal): Promise<number>;
+    addCycles(canisterId: Principal, amount: number): Promise<number>;
+    uploadBlob(blob: Uint8Array): Promise<Uint8Array>;
+    setStableMemory(canisterId: Principal, blobId: Uint8Array): Promise<void>;
+    getStableMemory(canisterId: Principal): Promise<Uint8Array>;
+    updateCall(canisterId: Principal, sender: Principal, method: string, payload: Uint8Array): Promise<Uint8Array>;
+    queryCall(canisterId: Principal, sender: Principal, method: string, payload: Uint8Array): Promise<Uint8Array>;
+    private canisterCall;
+    private post;
+    private get;
+}

package/dist/pic-js/packages/pic/src/pocket-ic-client.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PocketIcClient = void 0;
+const util_1 = require("./util");
+const http_client_1 = require("./http-client");
+const PROCESSING_TIME_HEADER = 'processing-timeout-ms';
+const PROCESSING_TIME_VALUE_MS = 300000;
+const PROCESSING_HEADER = {
+    [PROCESSING_TIME_HEADER]: PROCESSING_TIME_VALUE_MS.toString(),
+};
+class PocketIcClient {
+    constructor(instanceUrl, serverUrl) {
+        this.instanceUrl = instanceUrl;
+        this.serverUrl = serverUrl;
+    }
+    static async create(url) {
+        const instanceId = await PocketIcClient.createInstance(url);
+        return new PocketIcClient(`${url}/instances/${instanceId}`, url);
+    }
+    static async createInstance(url) {
+        const response = await http_client_1.HttpClient.post(`${url}/instances`);
+        if ('Error' in response) {
+            throw new Error(response.Error.message);
+        }
+        return response.Created.instance_id;
+    }
+    async deleteInstance() {
+        await fetch(this.instanceUrl, {
+            method: 'DELETE',
+        });
+    }
+    async tick() {
+        return await this.post('/update/tick');
+    }
+    async getTime() {
+        const response = await this.get('/read/get_time');
+        return response.nanos_since_epoch / 1000000;
+    }
+    async setTime(time) {
+        await this.post('/update/set_time', {
+            nanos_since_epoch: time * 1000000,
+        });
+    }
+    async fetchRootKey() {
+        return await this.post('/read/root_key');
+    }
+    async checkCanisterExists(canisterId) {
+        return await this.post('/read/canister_exists', { canister_id: (0, util_1.base64EncodePrincipal)(canisterId) });
+    }
+    async getCyclesBalance(canisterId) {
+        const response = await this.post('/read/get_cycles', {
+            canister_id: (0, util_1.base64EncodePrincipal)(canisterId),
+        });
+        return response.cycles;
+    }
+    async addCycles(canisterId, amount) {
+        const response = await this.post('/update/add_cycles', {
+            canister_id: (0, util_1.base64EncodePrincipal)(canisterId),
+            amount,
+        });
+        return response.cycles;
+    }
+    async uploadBlob(blob) {
+        const response = await fetch(`${this.serverUrl}/blobstore`, {
+            method: 'POST',
+            body: blob,
+        });
+        const responseText = await response.text();
+        return new Uint8Array((0, util_1.hexDecode)(responseText));
+    }
+    async setStableMemory(canisterId, blobId) {
+        const request = {
+            canister_id: (0, util_1.base64EncodePrincipal)(canisterId),
+            blob_id: Array.from(blobId),
+        };
+        const response = await fetch(`${this.instanceUrl}/update/set_stable_memory`, {
+            method: 'POST',
+            headers: {
+                ...http_client_1.JSON_HEADER,
+                ...PROCESSING_HEADER,
+            },
+            body: JSON.stringify(request),
+        });
+        (0, http_client_1.handleFetchError)(response);
+    }
+    async getStableMemory(canisterId) {
+        const response = await this.post('/read/get_stable_memory', {
+            canister_id: (0, util_1.base64EncodePrincipal)(canisterId),
+        });
+        return (0, util_1.base64Decode)(response.blob);
+    }
+    async updateCall(canisterId, sender, method, payload) {
+        return await this.canisterCall('/update/execute_ingress_message', canisterId, sender, method, payload);
+    }
+    async queryCall(canisterId, sender, method, payload) {
+        return await this.canisterCall('/read/query', canisterId, sender, method, payload);
+    }
+    async canisterCall(endpoint, canisterId, sender, method, payload) {
+        let rawCanisterCall = {
+            sender: (0, util_1.base64EncodePrincipal)(sender),
+            canister_id: (0, util_1.base64EncodePrincipal)(canisterId),
+            method,
+            payload: (0, util_1.base64Encode)(payload),
+        };
+        const response = await this.post(endpoint, rawCanisterCall);
+        if ('Err' in response) {
+            throw new Error(response.Err.description);
+        }
+        return (0, util_1.base64Decode)(response.Ok.Reply);
+    }
+    async post(endpoint, body) {
+        return await http_client_1.HttpClient.post(`${this.instanceUrl}${endpoint}`, {
+            body,
+            headers: PROCESSING_HEADER,
+        });
+    }
+    async get(endpoint) {
+        return await http_client_1.HttpClient.get(`${this.instanceUrl}${endpoint}`, {
+            headers: PROCESSING_HEADER,
+        });
+    }
+}
+exports.PocketIcClient = PocketIcClient;

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

@@ -0,0 +1,10 @@
+export declare class PocketIcServer {
+    private readonly serverProcess;
+    private readonly url;
+    private constructor();
+    static start(): Promise<PocketIcServer>;
+    getUrl(): string;
+    stop(): void;
+    private static getBinPath;
+    private static assertBinExists;
+}

package/dist/pic-js/packages/pic/src/pocket-ic-server.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PocketIcServer = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const error_1 = require("./error");
+const util_1 = require("./util");
+class PocketIcServer {
+    constructor(serverProcess, portNumber) {
+        this.serverProcess = serverProcess;
+        this.url = `http://127.0.0.1:${portNumber}`;
+    }
+    static async start() {
+        const binPath = this.getBinPath();
+        await this.assertBinExists(binPath);
+        const pid = process.ppid;
+        const picFilePrefix = `pocket_ic_${pid}`;
+        const portFilePath = (0, util_1.tmpFile)(`${picFilePrefix}.port`);
+        const readyFilePath = (0, util_1.tmpFile)(`${picFilePrefix}.ready`);
+        const serverProcess = (0, node_child_process_1.spawn)(binPath, ['--pid', pid.toString()], {
+            stdio: 'ignore',
+        });
+        serverProcess.on('error', error => {
+            if ((0, util_1.isArm)() && (0, util_1.isDarwin)()) {
+                throw new error_1.BinStartMacOSArmError(error);
+            }
+            throw new error_1.BinStartError(error);
+        });
+        return await (0, util_1.poll)(async () => {
+            const isPocketIcReady = await (0, util_1.exists)(readyFilePath);
+            if (isPocketIcReady) {
+                const portString = await (0, util_1.readFileAsString)(portFilePath);
+                const port = parseInt(portString);
+                return new PocketIcServer(serverProcess, port);
+            }
+            throw new error_1.BinTimeoutError();
+        });
+    }
+    getUrl() {
+        return this.url;
+    }
+    stop() {
+        this.serverProcess.unref();
+    }
+    static getBinPath() {
+        return (0, node_path_1.resolve)(__dirname, '..', 'pocket-ic');
+    }
+    static async assertBinExists(binPath) {
+        const binExists = await (0, util_1.exists)(binPath);
+        if (!binExists) {
+            throw new error_1.BinNotFoundError(binPath);
+        }
+    }
+}
+exports.PocketIcServer = PocketIcServer;

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

@@ -0,0 +1,40 @@
+import { Principal } from '@dfinity/principal';
+import { ActorInterface, Actor } from './pocket-ic-actor';
+/**
+ * A canister testing fixture for PocketIC that provides essential testing primitives
+ * such as an {@link Actor} and CanisterId.
+ *
+ * @category Types
+ * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
+ */
+export interface CanisterFixture<T = ActorInterface> {
+    /**
+     * The {@link Actor} instance.
+     */
+    actor: Actor<T>;
+    /**
+     * The Principal of the canister.
+     */
+    canisterId: Principal;
+}
+/**
+ * Options for creating a canister.
+ *
+ * @param cycles The amount of cycles to send to the canister.
+ *  Defaults to 1_000_000_000_000_000_000n.
+ * @param controllers The controllers of the canister.
+ *  Defaults to the sender, which defaults to the anonymous principal.
+ * @param computeAllocation The compute allocation of the canister.
+ * @param memoryAllocation The memory allocation of the canister.
+ * @param freezingThreshold The freezing threshold of the canister.
+ *
+ * @category Types
+ * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
+ */
+export interface CreateCanisterOptions {
+    cycles?: bigint;
+    controllers?: Principal[];
+    computeAllocation?: bigint;
+    memoryAllocation?: bigint;
+    freezingThreshold?: bigint;
+}

package/dist/pic-js/packages/pic/src/pocket-ic-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });