@holochain/client 0.17.0-dev.8 → 0.18.0-dev.0

package/lib/api/app/websocket.js

@@ -1,41 +1,63 @@
-import { hashZomeCall } from "@holochain/serialization";
+import Emittery from "emittery";
+import { omit } from "lodash-es";
+import { CellType } from "../admin/index.js";
+import { catchError, DEFAULT_TIMEOUT, getBaseRoleNameFromCloneId, HolochainError, isCloneId, promiseTimeout, requesterTransformer, } from "../common.js";
+import { getHostZomeCallSigner, getLauncherEnvironment, } from "../../environments/launcher.js";
 import { decode, encode } from "@msgpack/msgpack";
+import { getNonceExpiration, getSigningCredentials, randomNonce, } from "../zome-call-signing.js";
+import { encodeHashToBase64 } from "../../utils/index.js";
+import { hashZomeCall } from "@holochain/serialization";
 import _sodium from "libsodium-wrappers";
-import Emittery from "emittery";
-import { getLauncherEnvironment, signZomeCallTauri, signZomeCallElectron, getHostZomeCallSigner, } from "../../environments/launcher.js";
-import { encodeHashToBase64 } from "../../utils/base64.js";
 import { WsClient } from "../client.js";
-import { DEFAULT_TIMEOUT, catchError, promiseTimeout, requesterTransformer, HolochainError, } from "../common.js";
-import { getNonceExpiration, getSigningCredentials, randomNonce, } from "../zome-call-signing.js";
 /**
- * A class to establish a websocket connection to an App interface of a
- * Holochain conductor.
+ * A class to establish a websocket connection to an App interface, for a
+ * specific agent and app.
  *
  * @public
  */
-export class AppWebsocket extends Emittery {
+export class AppWebsocket {
     client;
+    myPubKey;
     defaultTimeout;
-    overrideInstalledAppId;
-    constructor(client, defaultTimeout, overrideInstalledAppId) {
-        super();
+    emitter;
+    cachedAppInfo;
+    appInfoRequester;
+    callZomeRequester;
+    createCloneCellRequester;
+    enableCloneCellRequester;
+    disableCloneCellRequester;
+    networkInfoRequester;
+    constructor(client, appInfo, defaultTimeout) {
+        this.client = client;
+        this.myPubKey = appInfo.agent_pub_key;
+        this.defaultTimeout = defaultTimeout ?? DEFAULT_TIMEOUT;
+        this.emitter = new Emittery();
+        this.cachedAppInfo = appInfo;
+        this.appInfoRequester = AppWebsocket.requester(this.client, "app_info", this.defaultTimeout);
+        this.callZomeRequester = AppWebsocket.requester(this.client, "call_zome", this.defaultTimeout, callZomeTransform);
+        this.createCloneCellRequester = AppWebsocket.requester(this.client, "create_clone_cell", this.defaultTimeout);
+        this.enableCloneCellRequester = AppWebsocket.requester(this.client, "enable_clone_cell", this.defaultTimeout);
+        this.disableCloneCellRequester = AppWebsocket.requester(this.client, "disable_clone_cell", this.defaultTimeout);
+        this.networkInfoRequester = AppWebsocket.requester(this.client, "network_info", this.defaultTimeout);
         // Ensure all super methods are bound to this instance because Emittery relies on `this` being the instance.
         // Please retain until the upstream is fixed https://github.com/sindresorhus/emittery/issues/86.
         Object.getOwnPropertyNames(Emittery.prototype).forEach((name) => {
-            const to_bind = this[name];
+            const to_bind = this.emitter[name];
             if (typeof to_bind === "function") {
-                this[name] =
-                    to_bind.bind(this);
+                this.emitter[name] =
+                    to_bind.bind(this.emitter);
+            }
+        });
+        this.client.on("signal", (signal) => {
+            if (this.containsCell(signal.cell_id)) {
+                this.emitter.emit("signal", signal).catch(console.error);
             }
         });
-        this.client = client;
-        this.defaultTimeout =
-            defaultTimeout === undefined ? DEFAULT_TIMEOUT : defaultTimeout;
-        this.overrideInstalledAppId = overrideInstalledAppId;
     }
     /**
-     * Instance factory for creating AppWebsockets.
+     * Instance factory for creating an {@link AppWebsocket}.
      *
+     * @param token - A token to authenticate the websocket connection. Get a token using AdminWebsocket#issueAppAuthenticationToken.
      * @param options - {@link (WebsocketConnectionOptions:interface)}
      * @returns A new instance of an AppWebsocket.
      */
@@ -43,25 +65,70 @@ export class AppWebsocket extends Emittery {
         // Check if we are in the launcher's environment, and if so, redirect the url to connect to
         const env = getLauncherEnvironment();
         if (env?.APP_INTERFACE_PORT) {
-            options.url = new URL(`ws://127.0.0.1:${env.APP_INTERFACE_PORT}`);
+            options.url = new URL(`ws://localhost:${env.APP_INTERFACE_PORT}`);
         }
         if (!options.url) {
             throw new HolochainError("ConnectionUrlMissing", `unable to connect to Conductor API - no url provided and not in a launcher environment.`);
         }
-        const wsClient = await WsClient.connect(options.url, options.wsClientOptions);
-        const appWebsocket = new AppWebsocket(wsClient, options.defaultTimeout, env?.INSTALLED_APP_ID);
-        wsClient.on("signal", (signal) => appWebsocket.emit("signal", signal));
-        return appWebsocket;
-    }
-    _requester(tag, transformer) {
-        return requesterTransformer((req, timeout) => promiseTimeout(this.client.request(req), tag, timeout || this.defaultTimeout).then(catchError), tag, transformer);
+        const client = await WsClient.connect(options.url, options.wsClientOptions);
+        if (env?.APP_INTERFACE_TOKEN) {
+            // Note: This will only work for multiple connections if a single_use = false token is provided
+            await client.authenticate({ token: env.APP_INTERFACE_TOKEN });
+        }
+        else {
+            if (!options.token) {
+                throw new HolochainError("AppAuthenticationTokenMissing", `unable to connect to Conductor API - no app authentication token provided.`);
+            }
+            await client.authenticate({ token: options.token });
+        }
+        const appInfo = await this.requester(client, "app_info", DEFAULT_TIMEOUT)(null);
+        if (!appInfo) {
+            throw new HolochainError("AppNotFound", `The app your connection token was issued for was not found. The app needs to be installed and enabled.`);
+        }
+        return new AppWebsocket(client, appInfo, options.defaultTimeout);
     }
     /**
      * Request the app's info, including all cell infos.
      *
+     * @param timeout - A timeout to override the default.
      * @returns The app's {@link AppInfo}.
      */
-    appInfo = this._requester("app_info", appInfoTransform(this));
+    async appInfo(timeout) {
+        const appInfo = await this.appInfoRequester(null, timeout);
+        if (!appInfo) {
+            throw new HolochainError("AppNotFound", `App info not found. App needs to be installed and enabled.`);
+        }
+        this.cachedAppInfo = appInfo;
+        return appInfo;
+    }
+    /**
+     * Get a cell id by its role name or clone id.
+     *
+     * @param roleName - The role name or clone id of the cell.
+     * @param appInfo - The app info containing all cell infos.
+     * @returns The cell id or throws an error if not found.
+     */
+    getCellIdFromRoleName(roleName, appInfo) {
+        if (isCloneId(roleName)) {
+            const baseRoleName = getBaseRoleNameFromCloneId(roleName);
+            if (!(baseRoleName in appInfo.cell_info)) {
+                throw new HolochainError("NoCellForRoleName", `no cell found with role_name ${roleName}`);
+            }
+            const cloneCell = appInfo.cell_info[baseRoleName].find((c) => CellType.Cloned in c && c[CellType.Cloned].clone_id === roleName);
+            if (!cloneCell || !(CellType.Cloned in cloneCell)) {
+                throw new HolochainError("NoCellForCloneId", `no clone cell found with clone id ${roleName}`);
+            }
+            return cloneCell[CellType.Cloned].cell_id;
+        }
+        if (!(roleName in appInfo.cell_info)) {
+            throw new HolochainError("NoCellForRoleName", `no cell found with role_name ${roleName}`);
+        }
+        const cell = appInfo.cell_info[roleName].find((c) => CellType.Provisioned in c);
+        if (!cell || !(CellType.Provisioned in cell)) {
+            throw new HolochainError("NoProvisionedCellForRoleName", `no provisioned cell found with role_name ${roleName}`);
+        }
+        return cell[CellType.Provisioned].cell_id;
+    }
     /**
      * Call a zome.
      *
@@ -69,31 +136,105 @@ export class AppWebsocket extends Emittery {
      * @param timeout - A timeout to override the default.
      * @returns The zome call's response.
      */
-    callZome = this._requester("call_zome", callZomeTransform);
+    async callZome(request, timeout) {
+        if (!("provenance" in request)) {
+            request = {
+                ...request,
+                provenance: this.myPubKey,
+            };
+        }
+        if ("role_name" in request && request.role_name) {
+            const appInfo = this.cachedAppInfo || (await this.appInfo());
+            const cell_id = this.getCellIdFromRoleName(request.role_name, appInfo);
+            const zomeCallPayload = {
+                ...omit(request, "role_name"),
+                provenance: this.myPubKey,
+                cell_id: [cell_id[0], cell_id[1]],
+            };
+            return this.callZomeRequester(zomeCallPayload, timeout);
+        }
+        else if ("cell_id" in request && request.cell_id) {
+            return this.callZomeRequester(request, timeout);
+        }
+        throw new HolochainError("MissingRoleNameOrCellId", "callZome requires a role_name or cell_id argument");
+    }
     /**
      * Clone an existing provisioned cell.
      *
      * @param args - Specify the cell to clone.
      * @returns The created clone cell.
      */
-    createCloneCell = this._requester("create_clone_cell");
+    async createCloneCell(args) {
+        const clonedCell = this.createCloneCellRequester({
+            ...args,
+        });
+        this.cachedAppInfo = undefined;
+        return clonedCell;
+    }
     /**
      * Enable a disabled clone cell.
      *
      * @param args - Specify the clone cell to enable.
      * @returns The enabled clone cell.
      */
-    enableCloneCell = this._requester("enable_clone_cell");
+    async enableCloneCell(args) {
+        return this.enableCloneCellRequester({
+            ...args,
+        });
+    }
     /**
      * Disable an enabled clone cell.
      *
      * @param args - Specify the clone cell to disable.
      */
-    disableCloneCell = this._requester("disable_clone_cell");
+    async disableCloneCell(args) {
+        return this.disableCloneCellRequester({
+            ...args,
+        });
+    }
     /**
      * Request network info about gossip status.
+     *  @param args - Specify the DNAs for which you want network info
+     *  @returns Network info for the specified DNAs
+     */
+    async networkInfo(args) {
+        return this.networkInfoRequester({
+            ...args,
+            agent_pub_key: this.myPubKey,
+        });
+    }
+    /**
+     * Register an event listener for signals.
+     *
+     * @param eventName - Event name to listen to (currently only "signal").
+     * @param listener - The function to call when event is triggered.
+     * @returns A function to unsubscribe the event listener.
      */
-    networkInfo = this._requester("network_info");
+    on(eventName, listener) {
+        return this.emitter.on(eventName, listener);
+    }
+    static requester(client, tag, defaultTimeout, transformer) {
+        return requesterTransformer((req, timeout) => promiseTimeout(client.request(req), tag, timeout || defaultTimeout).then(catchError), tag, transformer);
+    }
+    containsCell(cellId) {
+        const appInfo = this.cachedAppInfo;
+        if (!appInfo) {
+            return false;
+        }
+        for (const roleName of Object.keys(appInfo.cell_info)) {
+            for (const cellInfo of appInfo.cell_info[roleName]) {
+                const currentCellId = CellType.Provisioned in cellInfo
+                    ? cellInfo[CellType.Provisioned].cell_id
+                    : CellType.Cloned in cellInfo
+                        ? cellInfo[CellType.Cloned].cell_id
+                        : undefined;
+                if (currentCellId && isSameCell(currentCellId, cellId)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
 }
 const callZomeTransform = {
     input: async (request) => {
@@ -105,29 +246,13 @@ const callZomeTransform = {
             return hostSigner.signZomeCall(request);
         }
         else {
-            const env = getLauncherEnvironment();
-            if (!env) {
-                return signZomeCall(request);
-            }
-            if (env.FRAMEWORK === "electron") {
-                return signZomeCallElectron(request);
-            }
-            return signZomeCallTauri(request);
+            return signZomeCall(request);
         }
     },
     output: (response) => decode(response),
 };
-const appInfoTransform = (appWs) => ({
-    input: (request) => {
-        if (appWs.overrideInstalledAppId) {
-            return {
-                installed_app_id: appWs.overrideInstalledAppId,
-            };
-        }
-        return request;
-    },
-    output: (response) => response,
-});
+const isSameCell = (cellId1, cellId2) => cellId1[0].every((byte, index) => byte === cellId2[0][index]) &&
+    cellId1[1].every((byte, index) => byte === cellId2[1][index]);
 /**
  * @public
  */

package/lib/api/client.d.ts

@@ -2,6 +2,13 @@
 import Emittery from "emittery";
 import IsoWebSocket from "isomorphic-ws";
 import { WsClientOptions } from "./common.js";
+import { AppAuthenticationToken } from "./admin/index.js";
+/**
+ * @public
+ */
+export interface AppAuthenticationRequest {
+    token: AppAuthenticationToken;
+}
 /**
  * A WebSocket client which can make requests and receive responses,
  * as well as send and receive signals.
@@ -22,6 +29,7 @@ export declare class WsClient extends Emittery {
      * Instance factory for creating WsClients.
      *
      * @param url - The WebSocket URL to connect to.
+     * @param options - Options for the WsClient.
      * @returns An new instance of the WsClient.
      */
     static connect(url: URL, options?: WsClientOptions): Promise<WsClient>;
@@ -31,6 +39,14 @@ export declare class WsClient extends Emittery {
      * @param data - Data to send.
      */
     emitSignal(data: unknown): void;
+    /**
+     * Authenticate the client with the conductor.
+     *
+     * This is only relevant for app websockets.
+     *
+     * @param request - The authentication request, containing an app authentication token.
+     */
+    authenticate(request: AppAuthenticationRequest): Promise<void>;
     /**
      * Send requests to the connected websocket.
      *
@@ -38,6 +54,7 @@ export declare class WsClient extends Emittery {
      * @returns
      */
     request<Response>(request: unknown): Promise<Response>;
+    private exchange;
     private sendMessage;
     private handleResponse;
     /**

package/lib/api/client.js

@@ -1,8 +1,8 @@
 import { decode, encode } from "@msgpack/msgpack";
 import Emittery from "emittery";
 import IsoWebSocket from "isomorphic-ws";
-import { SignalType } from "./app/types.js";
 import { HolochainError } from "./common.js";
+import { SignalType } from "./app/index.js";
 /**
  * A WebSocket client which can make requests and receive responses,
  * as well as send and receive signals.
@@ -87,6 +87,7 @@ export class WsClient extends Emittery {
      * Instance factory for creating WsClients.
      *
      * @param url - The WebSocket URL to connect to.
+     * @param options - Options for the WsClient.
      * @returns An new instance of the WsClient.
      */
     static connect(url, options) {
@@ -113,6 +114,24 @@ export class WsClient extends Emittery {
         });
         this.socket.send(encodedMsg);
     }
+    /**
+     * Authenticate the client with the conductor.
+     *
+     * This is only relevant for app websockets.
+     *
+     * @param request - The authentication request, containing an app authentication token.
+     */
+    async authenticate(request) {
+        return this.exchange(request, (request, resolve) => {
+            const encodedMsg = encode({
+                type: "authenticate",
+                data: encode(request),
+            });
+            this.socket.send(encodedMsg);
+            // Message just needs to be sent first, no need to wait for a response or even require a flush
+            resolve(null);
+        });
+    }
     /**
      * Send requests to the connected websocket.
      *
@@ -120,27 +139,15 @@ export class WsClient extends Emittery {
      * @returns
      */
     async request(request) {
+        return this.exchange(request, this.sendMessage.bind(this));
+    }
+    exchange(request, sendHandler) {
         if (this.socket.readyState === this.socket.OPEN) {
             const promise = new Promise((resolve, reject) => {
-                this.sendMessage(request, resolve, reject);
+                sendHandler(request, resolve, reject);
             });
             return promise;
         }
-        else if (this.url) {
-            const response = new Promise((resolve, reject) => {
-                // typescript forgets in this promise scope that this.url is not undefined
-                const socket = new IsoWebSocket(this.url, this.options);
-                this.socket = socket;
-                socket.onerror = (errorEvent) => {
-                    reject(new HolochainError("ConnectionError", `could not connect to Holochain Conductor API at ${this.url} - ${errorEvent.error}`));
-                };
-                socket.onopen = () => {
-                    this.sendMessage(request, resolve, reject);
-                };
-                this.setupSocket();
-            });
-            return response;
-        }
         else {
             return Promise.reject(new Error("Socket is not open"));
         }

package/lib/api/common.d.ts

@@ -16,14 +16,12 @@ export type Requester<Req, Res> = (req: Req, timeout?: number) => Promise<Res>;
 /**
  * @public
  */
-export type RequesterUnit<Res> = () => Promise<Res>;
+export type RequesterNoArg<Res> = (timeout?: number) => Promise<Res>;
 /**
  * @public
  */
 export type Tagged<T> = {
-    type: {
-        [tag: string]: null;
-    };
+    type: string;
     data: T;
 };
 /**
@@ -42,7 +40,7 @@ export declare const requesterTransformer: <ReqI, ReqO, ResI, ResO>(requester: R
 export declare class HolochainError extends Error {
     constructor(name: string, message: string);
 }
-export declare const catchError: (res: any) => Promise<any>;
+export declare const catchError: (response: any) => Promise<any>;
 export declare const promiseTimeout: (promise: Promise<unknown>, tag: string, ms: number) => Promise<unknown>;
 /**
  * Check if a cell's role name is a valid clone id.

package/lib/api/common.js

@@ -9,10 +9,9 @@ export const DEFAULT_TIMEOUT = 60000;
  */
 export const requesterTransformer = (requester, tag, transform = identityTransformer) => async (req, timeout) => {
     const transformedInput = await transform.input(req);
-    const input = { type: { [tag]: null }, data: transformedInput };
+    const input = { type: tag, data: transformedInput };
     const response = await requester(input, timeout);
-    const output = transform.output(response.data);
-    return output;
+    return transform.output(response.data);
 };
 const identity = (x) => x;
 const identityTransformer = {
@@ -32,31 +31,29 @@ export class HolochainError extends Error {
     }
 }
 // this determines the error format of all error responses
-export const catchError = (res) => {
-    if (ERROR_TYPE in res.type) {
-        const errorName = Object.keys(res.data.type)[0];
-        const error = new HolochainError(errorName, res.data.data);
+export const catchError = (response) => {
+    if (response.type === ERROR_TYPE) {
+        const errorName = response.data.type;
+        const error = new HolochainError(errorName, response.data.data);
         return Promise.reject(error);
     }
     else {
-        return Promise.resolve(res);
+        return Promise.resolve(response);
     }
 };
 export const promiseTimeout = (promise, tag, ms) => {
     let id;
     const timeout = new Promise((_, reject) => {
-        id = setTimeout(() => reject(new Error(`Timed out in ${ms}ms: ${tag}`)), ms);
-    });
-    return new Promise((res, rej) => {
-        Promise.race([promise, timeout])
-            .then((a) => {
-            clearTimeout(id);
-            return res(a);
-        })
-            .catch((e) => {
-            return rej(e);
-        });
+        id = setTimeout(() => reject(new Error(`Request timed out in ${ms} ms: ${tag}`)), ms);
     });
+    return new Promise((res, rej) => Promise.race([promise, timeout])
+        .then((a) => {
+        clearTimeout(id);
+        return res(a);
+    })
+        .catch((e) => {
+        return rej(e);
+    }));
 };
 const CLONE_ID_DELIMITER = ".";
 /**

package/lib/api/index.d.ts

@@ -1,7 +1,6 @@
 export { hashZomeCall } from "@holochain/serialization";
 export * from "./admin/index.js";
-export * from "./app-agent/index.js";
 export * from "./app/index.js";
-export { IsoWebSocket, WsClient } from "./client.js";
-export { CloneId, HolochainError, Requester, Transformer, WebsocketConnectionOptions, WsClientOptions, getBaseRoleNameFromCloneId, isCloneId, } from "./common.js";
+export { IsoWebSocket, WsClient, type AppAuthenticationRequest, } from "./client.js";
+export { CloneId, HolochainError, getBaseRoleNameFromCloneId, isCloneId, type Requester, type Transformer, type WebsocketConnectionOptions, type WsClientOptions, } from "./common.js";
 export * from "./zome-call-signing.js";

package/lib/api/index.js

@@ -1,7 +1,6 @@
 export { hashZomeCall } from "@holochain/serialization";
 export * from "./admin/index.js";
-export * from "./app-agent/index.js";
 export * from "./app/index.js";
-export { IsoWebSocket, WsClient } from "./client.js";
+export { IsoWebSocket, WsClient, } from "./client.js";
 export { CloneId, HolochainError, getBaseRoleNameFromCloneId, isCloneId, } from "./common.js";
 export * from "./zome-call-signing.js";

package/lib/environments/launcher.d.ts

@@ -1,11 +1,11 @@
-import { CallZomeRequest } from "../api/app/types.js";
-import { CallZomeRequestSigned, CallZomeRequestUnsigned } from "../api/app/websocket.js";
+import { AppAuthenticationToken, CallZomeRequest } from "../api/index.js";
+import { CallZomeRequestSigned, CallZomeRequestUnsigned } from "../api/index.js";
 import { InstalledAppId } from "../types.js";
 export interface LauncherEnvironment {
     APP_INTERFACE_PORT?: number;
     ADMIN_INTERFACE_PORT?: number;
     INSTALLED_APP_ID?: InstalledAppId;
-    FRAMEWORK?: "tauri" | "electron";
+    APP_INTERFACE_TOKEN?: AppAuthenticationToken;
 }
 export interface HostZomeCallSigner {
     signZomeCall: (request: CallZomeRequest) => Promise<CallZomeRequestSigned>;
@@ -40,6 +40,4 @@ interface CallZomeRequestUnsignedElectron extends Omit<CallZomeRequestUnsigned,
     nonce: Array<number>;
     expiresAt: number;
 }
-export declare const signZomeCallTauri: (request: CallZomeRequest) => Promise<CallZomeRequestSigned>;
-export declare const signZomeCallElectron: (request: CallZomeRequest) => Promise<CallZomeRequestSigned>;
 export {};

package/lib/environments/launcher.js

@@ -1,65 +1,5 @@
-import { encode } from "@msgpack/msgpack";
-import { invoke } from "@tauri-apps/api/tauri";
-import { getNonceExpiration, randomNonce } from "../api/zome-call-signing.js";
 const __HC_LAUNCHER_ENV__ = "__HC_LAUNCHER_ENV__";
 const __HC_ZOME_CALL_SIGNER__ = "__HC_ZOME_CALL_SIGNER__";
 export const isLauncher = () => globalThis.window && __HC_LAUNCHER_ENV__ in globalThis.window;
 export const getLauncherEnvironment = () => isLauncher() ? globalThis.window[__HC_LAUNCHER_ENV__] : undefined;
 export const getHostZomeCallSigner = () => globalThis.window && globalThis.window[__HC_ZOME_CALL_SIGNER__];
-export const signZomeCallTauri = async (request) => {
-    const zomeCallUnsigned = {
-        provenance: Array.from(request.provenance),
-        cell_id: [Array.from(request.cell_id[0]), Array.from(request.cell_id[1])],
-        zome_name: request.zome_name,
-        fn_name: request.fn_name,
-        payload: Array.from(encode(request.payload)),
-        nonce: Array.from(await randomNonce()),
-        expires_at: getNonceExpiration(),
-    };
-    const signedZomeCallTauri = await invoke("sign_zome_call", { zomeCallUnsigned });
-    const signedZomeCall = {
-        provenance: Uint8Array.from(signedZomeCallTauri.provenance),
-        cap_secret: null,
-        cell_id: [
-            Uint8Array.from(signedZomeCallTauri.cell_id[0]),
-            Uint8Array.from(signedZomeCallTauri.cell_id[1]),
-        ],
-        zome_name: signedZomeCallTauri.zome_name,
-        fn_name: signedZomeCallTauri.fn_name,
-        payload: Uint8Array.from(signedZomeCallTauri.payload),
-        signature: Uint8Array.from(signedZomeCallTauri.signature),
-        expires_at: signedZomeCallTauri.expires_at,
-        nonce: Uint8Array.from(signedZomeCallTauri.nonce),
-    };
-    return signedZomeCall;
-};
-export const signZomeCallElectron = async (request) => {
-    if (!window.electronAPI) {
-        throw Error("Unable to signZomeCallElectron. window.electronAPI not defined");
-    }
-    const zomeCallUnsignedElectron = {
-        provenance: Array.from(request.provenance),
-        cellId: [Array.from(request.cell_id[0]), Array.from(request.cell_id[1])],
-        zomeName: request.zome_name,
-        fnName: request.fn_name,
-        payload: Array.from(encode(request.payload)),
-        nonce: Array.from(await randomNonce()),
-        expiresAt: getNonceExpiration(),
-    };
-    const zomeCallSignedElectron = await window.electronAPI.signZomeCall(zomeCallUnsignedElectron);
-    const zomeCallSigned = {
-        provenance: Uint8Array.from(zomeCallSignedElectron.provenance),
-        cap_secret: null,
-        cell_id: [
-            Uint8Array.from(zomeCallSignedElectron.cellId[0]),
-            Uint8Array.from(zomeCallSignedElectron.cellId[1]),
-        ],
-        zome_name: zomeCallSignedElectron.zomeName,
-        fn_name: zomeCallSignedElectron.fnName,
-        payload: Uint8Array.from(zomeCallSignedElectron.payload),
-        signature: Uint8Array.from(zomeCallSignedElectron.signature),
-        expires_at: zomeCallSignedElectron.expiresAt,
-        nonce: Uint8Array.from(zomeCallSignedElectron.nonce),
-    };
-    return zomeCallSigned;
-};

package/lib/hdk/capabilities.d.ts

@@ -1,4 +1,4 @@
-import { FunctionName, ZomeName } from "../api/admin/types.js";
+import { FunctionName, ZomeName } from "../api/admin/index.js";
 import { AgentPubKey } from "../types.js";
 /**
  * @public
@@ -22,9 +22,7 @@ export declare enum GrantedFunctionsType {
 /**
  * @public
  */
-export type GrantedFunctions = {
-    [GrantedFunctionsType.All]: null;
-} | {
+export type GrantedFunctions = GrantedFunctionsType.All | {
     [GrantedFunctionsType.Listed]: [ZomeName, FunctionName][];
 };
 /**
@@ -46,9 +44,7 @@ export declare enum CapAccessType {
 /**
  * @public
  */
-export type CapAccess = {
-    [CapAccessType.Unrestricted]: null;
-} | {
+export type CapAccess = [CapAccessType.Unrestricted] | {
     [CapAccessType.Transferable]: {
         secret: CapSecret;
     };

package/lib/hdk/entry.d.ts

@@ -4,11 +4,7 @@ import { CounterSigningSessionData } from "./countersigning.js";
 /**
  * @public
  */
-export type EntryVisibility = {
-    Public: null;
-} | {
-    Private: null;
-};
+export type EntryVisibility = "Public" | "Private";
 /**
  * @public
  */

package/lib/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.43.0"
+      "packageVersion": "7.43.1"
     }
   ]
 }