@tdxvolt/volt-client-grpc 0.1.1 → 0.1.2

package/src/volt-client.js

@@ -1,501 +1,556 @@
 import debug from "debug";
 import EventEmitter from "events";
-import {VoltCrypto} from "./volt-crypto.js";
+import { VoltCredential } from "./volt-credential.js";
 import path from "path";
-import {getServiceDescriptors} from "./proto-utils.js";
-import {createClient as createGrpcClient} from "./grpc-utils.js";
+import { getServiceDescriptors } from "./proto-utils.js";
+import { createClient as createGrpcClient } from "./grpc-utils.js";
 import {
-  bindInternal,
-  connectInternal,
-  fetchVoltConfig,
-  getVoltAPIClientInternal,
-  unaryCall,
+	bindInternal,
+	connectInternal,
+	fetchVoltConfig,
+	fetchVoltConfigFromDID,
+	getVoltAPIClientInternal,
+	unaryCall,
 } from "./volt-client-internal.js";
 import fs from "fs";
 import GRPCCall from "./grpc-call.js";
 
-const {readFile} = fs.promises;
+const { readFile } = fs.promises;
 const log = debug("volt-client-grpc:volt-client");
 
 export class VoltClient extends EventEmitter {
-  /**
-   * @param {object} grpc - an instance of the grpc module (see https://www.npmjs.com/package/grpc)
-   */
-  constructor(grpc) {
-    super();
-
-    if (!grpc) {
-      throw new Error("invalid arguments, grpc is required");
-    }
-    this._grpc = grpc;
-    this._cachedClient = null;
-    this._cachedRemoteClient = null;
-    this._session = null;
-    this._config = null;
-    this._options = null;
-    this._voltConnection = null;
-  }
-
-  get config() {
-    return this._config;
-  }
-
-  get crypto() {
-    return this._crypto;
-  }
-
-  get grpc() {
-    return this._grpc;
-  }
-
-  get options() {
-    return this._options;
-  }
-
-  /**
-   * Initialises a binding and connection to the volt.
-   * @param {string} [config] - the location of the Volt configuration file, or a configuration object
-   */
-  async initialise(config, extras = {}) {
-    try {
-      if (!config) {
-        throw new Error("configPath argument is required to be a non-empty string");
-      }
-
-      let configPath;
-      let configJSON;
-      if (typeof config === "string") {
-        configPath = path.resolve(config);
-        log("Attempt to load config from file %s", configPath);
-        try {
-          const configContents = await readFile(new URL(configPath, import.meta.url));
-          configJSON = JSON.parse(configContents);
-        } catch (err) {
-          log("failure loading config file %s [%s]", configPath, err.message);
-          throw new Error(`failed to load configuration - check JSON format in ${configPath}`);
-        }
-      } else if (typeof config === "object") {
-        configJSON = config;
-      } else {
-        throw new Error("config must be either a file path or a config object");
-      }
-
-      if (!configJSON || typeof configJSON !== "object") {
-        throw new Error("config argument is required to be an object");
-      }
-
-      if (!configJSON.client_name || typeof configJSON.client_name !== "string") {
-        throw new Error("client_name property required in config");
-      }
-
-      this._config = {...configJSON, ...extras};
-
-      if (this._config.volt_did && !this._config.volt) {
-        // No Volt configuration, attempt to discover it via the given DID.
-        const didConfig = await fetchVoltConfig.call(this, this._config.volt_did);
-        log("resolved config from DID: %s", JSON.stringify(didConfig, null, 2));
-        this._config = {...this._config, ...didConfig};
-      }
-
-      this._options = this._config.volt;
-
-      if (!this._options || typeof this._options !== "object") {
-        throw new Error("configuration is missing the 'volt' object");
-      }
-
-      if (!this._options.id || typeof this._options.id !== "string") {
-        throw new Error("'id' property is missing in Volt configuration");
-      }
-
-      this._crypto = new VoltCrypto(this._config, configPath);
-
-      await this._crypto.initialise();
-
-      if (!this.isRemote) {
-        // If we're not connecting via a tunnel, we must have the address and CA.
-        if (!this._options.local_address || typeof this._options.local_address !== "string") {
-          throw new Error("'local_address' property missing in Volt configuration");
-        }
-
-        if (!this._options.ca_pem || typeof this._options.ca_pem !== "string") {
-          throw new Error("'ca_pPem' property missing in Volt configuration");
-        }
-      }
-
-      let isBound;
-      if (!this._crypto._cryptoCache.cert) {
-        // No certificate present in the cache yet => we need to bind.
-        try {
-          isBound = await bindInternal.call(this);
-        } catch (bindErr) {
-          if (bindErr.message === "invalid arguments") {
-            // This is usually the result of a missing challenge signature or credential.
-            log("failure binding to Volt - did you supply a challenge code or verified credential?");
-            throw bindErr;
-          }
-        }
-      } else {
-        isBound = true;
-      }
-
-      if (!isBound) {
-        // This is usually because of request being denied.
-        throw new Error("Volt binding failed");
-      }
-
-      return Promise.resolve();
-    } catch (err) {
-      log("Failure starting Volt client [%s]", err.message);
-      throw err;
-    }
-  }
-
-  initialiseAndConnect(configPath, extras = {}) {
-    return this.initialise(configPath, extras)
-      .then(() => {
-        return connectInternal.call(this);
-      })
-      .catch((err) => {
-        log("startAndConnect failure: %s", err.message);
-        return Promise.reject(err);
-      });
-  }
-
-  /**
-   * Creates a GRPC client for the given Volt service description.
-   *
-   * Automatically handles remote connections.
-   *
-   * n.b. for this javascript client Protobuf definitions should conform to the recommended
-   * structure, which is that a package proto file resides in a folder path that matches the
-   * package name, and services contained in the package are named in in Pascal Case and using
-   * the suffix 'API'. For example the WebcamControlAPI in package tdx.volt_api.webcam.v1 should reside
-   * in a protobuf file at tdx/api/webcam/v1/webcam_control_api.proto
-   *
-   * @param {object} service a service description.
-   * @param {object} descriptors the service descriptors, must be specified unless the service
-   * packages are well-known Volt APIs.
-   */
-  createServiceClient(service, descriptors) {
-    const pkg = service.service_description.service_api;
-
-    let serviceDescriptors;
-    if (!descriptors) {
-      serviceDescriptors = {};
-      pkg.forEach((svc) => {
-        log("adding service %s to service client", svc);
-        const packageDescriptors = getServiceDescriptors(this._grpc, svc);
-        serviceDescriptors = {...serviceDescriptors, ...packageDescriptors};
-      });
-    } else {
-      serviceDescriptors = descriptors;
-    }
-
-    if (this.isRemote) {
-      if (!this._crypto.cache.tunnel_address) {
-        throw new Error("Remote connection enabled but no tunnel address - have you called start()?");
-      }
-
-      // In remote mode => create a client using the discovered tunnel address **and** passing the service reourceId
-      return createGrpcClient(
-        this._grpc,
-        serviceDescriptors,
-        this._crypto.cache.tunnel_address,
-        this._crypto.cache,
-        false,
-        service.volt_id,
-        service.id
-      );
-    } else {
-      return createGrpcClient(
-        this._grpc,
-        serviceDescriptors,
-        service.service_description.local_address,
-        this._crypto.cache
-      );
-    }
-  }
-
-  get isRemote() {
-    return (this._config.cloud_host || this._config.tunnel_host) && this._options.id;
-  }
-
-  get isVoltTunnel() {
-    return this.isRemote && this._config.tunnel_host;
-  }
-
-  connect() {
-    return connectInternal.call(this);
-  }
-
-  disconnect() {
-    if (this._voltConnection) {
-      this._voltConnection.disconnect();
-      this._voltConnection = null;
-    }
-  }
-
-  getVoltAPIClient() {
-    return getVoltAPIClientInternal.call(this);
-  }
-
-  /**
-   * Request resource access.
-   * @param {*} targetResourceId
-   * @param {*} accessType - see vault.proto for enum values.
-   */
-  async RequestAccessBlocking(targetResourceId, accessType = "VOLT_ACCESS_READ") {
-    try {
-      const accessRequest = {
-        access: accessType,
-        resource_id: targetResourceId,
-      };
-
-      // This will block while the request is pending.
-      // TODO - implement streamed rpc on volt? Not sure there is a need really...
-      const pollInterval = 10000;
-      let decision = "";
-      do {
-        if (decision) {
-          await new Promise((resolve) => setTimeout(resolve, pollInterval));
-        }
-        const accessResponse = await this.RequestAccess(accessRequest);
-        decision = accessResponse.decision;
-        log("access decision: %s", decision);
-      } while (decision === "POLICY_DECISION_PROMPT" || decision === "POLICY_DECISION_PENDING");
-
-      log("requestResourceAccess result is %j", decision);
-      return decision === "POLICY_DECISION_PERMIT";
-    } catch (err) {
-      log("failure requesting resource access [%s]", err.message);
-      return Promise.reject(err);
-    }
-  }
-
-  /**
-   * VoltAPI - resource management
-   */
-
-  CanAccessResource(request) {
-    return unaryCall.call(this, "CanAccessResource", request);
-  }
-
-  DeleteResource(request) {
-    return unaryCall.call(this, "DeleteResource", request);
-  }
-
-  DiscoverServices(request) {
-    return unaryCall.call(this, "DiscoverServices", request);
-  }
-
-  GetResource(request) {
-    return unaryCall.call(this, "GetResource", request);
-  }
-
-  GetResources(request) {
-    return unaryCall.call(this, "GetResources", request);
-  }
-
-  GetResourceAncestors(request) {
-    return unaryCall.call(this, "GetResourceAncestors", request);
-  }
-
-  GetResourceDescendants(request) {
-    return unaryCall.call(this, "GetResourceDescendants", request);
-  }
-
-  RequestAccess(request) {
-    return unaryCall.call(this, "RequestAccess", request);
-  }
-
-  SaveResource(request) {
-    return unaryCall.call(this, "SaveResource", request);
-  }
-
-  SaveResourceAttribute(request) {
-    return unaryCall.call(this, "SaveResourceAttribute", request);
-  }
-
-  SetServiceStatus(request) {
-    return unaryCall.call(this, "SetServiceStatus", request);
-  }
-
-  /**
-   * VoltAPI - volt management
-   */
-
-  Bind(request) {
-    return unaryCall.call(this, "Bind", request);
-  }
-
-  DeleteAccess(request) {
-    return unaryCall.call(this, "DeleteAccess", request);
-  }
-
-  DeleteVolt(request) {
-    return unaryCall.call(this, "DeleteVolt", request);
-  }
-
-  GetAccess(request) {
-    return unaryCall.call(this, "GetAccess", request);
-  }
-
-  GetBindings(request) {
-    return unaryCall.call(this, "GetBindings", request);
-  }
-
-  GetIdentities(request) {
-    return unaryCall.call(this, "GetIdentities", request);
-  }
-
-  GetIdentity(request) {
-    return unaryCall.call(this, "GetIdentity", request);
-  }
-
-  GetIdentityToken(request) {
-    return unaryCall.call(this, "GetIdentityToken", request);
-  }
-
-  GetPolicy(request) {
-    return unaryCall.call(this, "GetPolicy", request);
-  }
-
-  GetSettings(request) {
-    return unaryCall.call(this, "GetSettings", request);
-  }
-
-  SaveAccess(request) {
-    return unaryCall.call(this, "SaveAccess", request);
-  }
-
-  SaveCloudConnection(request) {
-    return unaryCall.call(this, "SaveCloudConnection", request);
-  }
-
-  SaveIdentity(request) {
-    return unaryCall.call(this, "SaveIdentity", request);
-  }
-
-  SaveSettings(request) {
-    return unaryCall.call(this, "SaveSettings", request);
-  }
-
-  SetAccessRequestDecision(request) {
-    return unaryCall.call(this, "SetAccessRequestDecision", request);
-  }
-
-  SetBindingDecision(request) {
-    return unaryCall.call(this, "SetBindingDecision", request);
-  }
-
-  Shutdown(request) {
-    return unaryCall.call(this, "Shutdown", request);
-  }
-
-  SignVerify(request) {
-    return unaryCall.call(this, "SignVerify", request);
-  }
-
-  /**
-   * FileAPI
-   */
-  GetFileDescendants(request) {
-    return unaryCall.call(this, "GetFileDescendants", request);
-  }
-
-  /**
-   * Asynchronous file download
-   * @param {*} request
-   * @returns stream
-   */
-  DownloadFile(request) {
-    const grpcClient = this.getVoltAPIClient();
-
-    return new Promise((resolve, reject) => {
-      const meta = this._crypto.getIdentityMetadata(this._grpc, this._options.id, this.isRemote);
-      resolve(grpcClient.DownloadFile(request, meta.metadata));
-    }).catch((err) => {
-      log("error during %s [%s]", method, err.message);
-      return Promise.reject(err);
-    });
-  }
-
-  UploadFile(request, callback) {
-    const grpcClient = this.getVoltAPIClient();
-
-    const uploadCall = new GRPCCall(this, "UploadFile", "METHOD_TYPE_BIDI");
-    return uploadCall.start(grpcClient, request, callback);
-  }
-
-  /**
-   * Synchronous file download
-   * @param {*} request
-   * @returns file buffer, base64 encoded
-   */
-  DownloadFileSync(request) {
-    const grpcClient = this.getVoltAPIClient();
-
-    const blocks = [];
-
-    const call = new GRPCCall(this, "DownloadFile", "METHOD_TYPE_SERVER_STREAM");
-    call.start(grpcClient, request, (err, response) => {
-      if (err) {
-        return call.reject(err);
-      }
-
-      switch (response.payload) {
-        case "block":
-          blocks.push(response.block);
-          break;
-        case "status":
-          if (response.status.message) {
-            return call.reject(new Error(response.status.message));
-          } else {
-            // Non-error response status => do nothing and wait for the stream to end.
-          }
-          break;
-        default:
-          log("unrecognised response payload %s", response.payload);
-          break;
-      }
-    });
-
-    return call
-      .wait()
-      .then(() => {
-        log("Download finished");
-        return {buffer: Buffer.concat(blocks).toString("base64")};
-      })
-      .catch((err) => {
-        log("error during DownloadFile [%s]", err.message);
-        return Promise.reject(err);
-      });
-  }
-
-  /**
-   * SqliteDatabaseAPI
-   */
-  SqlExecute(request, callback) {
-    const grpcClient = this.getVoltAPIClient();
-
-    const subscribeCall = new GRPCCall(this, "Execute", "METHOD_TYPE_BIDI");
-    return subscribeCall.start(grpcClient, request, callback);
-  }
-
-  /**
-   * WireAPI
-   */
-  PublishWire(request, callback) {
-    const grpcClient = this.getVoltAPIClient();
-
-    const publishCall = new GRPCCall(this, "PublishWire", "METHOD_TYPE_CLIENT_STREAM");
-    return publishCall.start(grpcClient, request, callback);
-  }
-
-  SubscribeWire(request, callback) {
-    const grpcClient = this.getVoltAPIClient();
-
-    const subscribeCall = new GRPCCall(this, "SubscribeWire", "METHOD_TYPE_BIDI");
-    return subscribeCall.start(grpcClient, request, callback);
-  }
+	/**
+	 * @param {object} grpc - an instance of the grpc module (see https://www.npmjs.com/package/grpc)
+	 */
+	constructor(grpc) {
+		super();
+
+		if (!grpc) {
+			throw new Error("invalid arguments, grpc is required");
+		}
+		this._grpc = grpc;
+		this._cachedClient = null;
+		this._cachedRemoteClient = null;
+		this._session = null;
+		this._config = null;
+		this._voltConfig = null;
+		this._voltConnection = null;
+	}
+
+	get config() {
+		return this._config;
+	}
+
+	get credential() {
+		return this._credential;
+	}
+
+	get grpc() {
+		return this._grpc;
+	}
+
+	get voltConfig() {
+		return this._voltConfig;
+	}
+
+	/**
+	 * Initialises a binding and connection to the volt.
+	 * @param {string} [config] - the location of the Volt configuration file, or a configuration object
+	 */
+	async initialise(config, extras = {}) {
+		try {
+			if (!config) {
+				throw new Error(
+					"configPath argument is required to be a non-empty string",
+				);
+			}
+
+			let configPath;
+			let configJSON;
+			if (typeof config === "string") {
+				configPath = path.resolve(config);
+				log("Attempt to load config from file %s", configPath);
+				try {
+					const configContents = await readFile(
+						new URL(configPath, import.meta.url),
+					);
+					configJSON = JSON.parse(configContents);
+				} catch (err) {
+					log("failure loading config file %s [%s]", configPath, err.message);
+					throw new Error(
+						`failed to load configuration - check JSON format in ${configPath}`,
+					);
+				}
+			} else if (typeof config === "object") {
+				configJSON = config;
+			} else {
+				throw new Error("config must be either a file path or a config object");
+			}
+
+			if (!configJSON || typeof configJSON !== "object") {
+				throw new Error("config argument is required to be an object");
+			}
+
+			if (
+				!configJSON.client_name ||
+				typeof configJSON.client_name !== "string"
+			) {
+				throw new Error("client_name property required in config");
+			}
+
+			this._config = { ...configJSON, ...extras };
+
+			let voltDID = "";
+			let voltDiscovery = "";
+			if (typeof this._config.volt === "string") {
+				if (this._config.volt.indexOf("did:") === 0) {
+					voltDID = this._config.volt;
+				} else {
+					voltDiscovery = this._config.volt;
+				}
+			} else if (typeof this._config.volt !== "object") {
+				throw new Error("configuration is missing the 'volt' object");
+			} else {
+				voltDID = this._config.volt.did;
+				voltDiscovery = this._config.volt.discovery_url;
+			}
+
+			if (voltDID) {
+				const didConfig = await fetchVoltConfigFromDID.call(this, voltDID);
+				this._config = { ...this._config, ...didConfig };
+				log("resolved config from DID: %s", JSON.stringify(didConfig, null, 2));
+			} else if (voltDiscovery) {
+				const discoConfig = await fetchVoltConfig.call(this, voltDiscovery);
+				this._config = { ...this._config, ...discoConfig };
+			}
+
+			this._voltConfig = this._config.volt;
+			this._voltConfig.did = voltDID;
+			this._voltConfig.discovery_url = voltDiscovery;
+
+			if (!this._voltConfig.id || typeof this._voltConfig.id !== "string") {
+				throw new Error("'id' property is missing in Volt configuration");
+			}
+
+			this._credential = new VoltCredential(this._config, configPath);
+
+			await this._credential.initialise();
+
+			if (!this.isRemote) {
+				// If we're not connecting via a Relay, we must have the address and CA.
+				if (
+					!this._voltConfig.address ||
+					typeof this._voltConfig.address !== "string"
+				) {
+					throw new Error("'address' property missing in Volt configuration");
+				}
+
+				if (
+					!this._voltConfig.ca_pem ||
+					typeof this._voltConfig.ca_pem !== "string"
+				) {
+					throw new Error("'ca_pPem' property missing in Volt configuration");
+				}
+			}
+
+			let isBound;
+			if (this._credential._cryptoCache.cert) {
+				isBound = true;
+			} else {
+				// No certificate present in the cache yet => we need to bind.
+				try {
+					isBound = await bindInternal.call(this);
+				} catch (bindErr) {
+					if (bindErr.message === "invalid arguments") {
+						// This is usually the result of a missing challenge signature or credential.
+						log(
+							"failure binding to Volt - did you supply a challenge code or verified credential?",
+						);
+						throw bindErr;
+					}
+				}
+			}
+
+			if (!isBound) {
+				// This is usually because of request being denied.
+				throw new Error("Volt binding failed");
+			}
+
+			return Promise.resolve();
+		} catch (err) {
+			log("Failure starting Volt client [%s]", err.message);
+			throw err;
+		}
+	}
+
+	initialiseAndConnect(configPath, extras = {}) {
+		return this.initialise(configPath, extras)
+			.then(() => {
+				return connectInternal.call(this);
+			})
+			.catch((err) => {
+				log("initialiseAndConnect failure: %s", err.message);
+				return Promise.reject(err);
+			});
+	}
+
+	/**
+	 * Creates a GRPC client for the given Volt service description.
+	 *
+	 * Automatically handles remote connections.
+	 *
+	 * n.b. for this javascript client Protobuf definitions should conform to the recommended
+	 * structure, which is that a package proto file resides in a folder path that matches the
+	 * package name, and services contained in the package are named in in Pascal Case and using
+	 * the suffix 'API'. For example the WebcamControlAPI in package tdx.volt_api.webcam.v1 should reside
+	 * in a protobuf file at tdx/api/webcam/v1/webcam_control_api.proto
+	 *
+	 * @param {object} service a service description.
+	 * @param {object} descriptors the service descriptors, must be specified unless the service
+	 * packages are well-known Volt APIs.
+	 */
+	createServiceClient(service, descriptors) {
+		const pkg = service.service_description.service_api;
+
+		let serviceDescriptors;
+		if (descriptors) {
+			serviceDescriptors = descriptors;
+		} else {
+			serviceDescriptors = {};
+			pkg.forEach((svc) => {
+				log("adding service %s to service client", svc);
+				const packageDescriptors = getServiceDescriptors(this._grpc, svc);
+				serviceDescriptors = { ...serviceDescriptors, ...packageDescriptors };
+			});
+		}
+
+		if (this.isRemote) {
+			if (!this._config?.relay?.address) {
+				throw new Error(
+					"Remote connection enabled but no Relay address - have you called start()?",
+				);
+			}
+
+			// In remote mode => create a client using the discovered Relay address **and** passing the service reourceId
+			return createGrpcClient(
+				this._grpc,
+				serviceDescriptors,
+				this._config.relay.address,
+				this._credential,
+				false,
+				service.volt_id,
+				service.id,
+			);
+		} else {
+			return createGrpcClient(
+				this._grpc,
+				serviceDescriptors,
+				service.service_description.address,
+				this._credential,
+			);
+		}
+	}
+
+	get isRemote() {
+		return !!(this._config?.relay && this._voltConfig.id);
+	}
+
+	get isVoltRelay() {
+		return this.isRemote && !this._config?.relay.cloud_relay;
+	}
+
+	connect() {
+		return connectInternal.call(this);
+	}
+
+	disconnect() {
+		if (this._voltConnection) {
+			this._voltConnection.disconnect();
+			this._voltConnection = null;
+		}
+	}
+
+	getVoltAPIClient() {
+		return getVoltAPIClientInternal.call(this);
+	}
+
+	/**
+	 * Request resource access.
+	 * @param {*} targetResourceId
+	 * @param {*} accessType - see vault.proto for enum values.
+	 */
+	async RequestAccessBlocking(
+		targetResourceId,
+		accessType = "VOLT_ACCESS_READ",
+	) {
+		try {
+			const accessRequest = {
+				access: accessType,
+				resource_id: targetResourceId,
+			};
+
+			// This will block while the request is pending.
+			// TODO - implement streamed rpc on volt? Not sure there is a need really...
+			const pollInterval = 10000;
+			let decision = "";
+			do {
+				if (decision) {
+					await new Promise((resolve) => setTimeout(resolve, pollInterval));
+				}
+				const accessResponse = await this.RequestAccess(accessRequest);
+				decision = accessResponse.decision;
+				log("access decision: %s", decision);
+			} while (
+				decision === "POLICY_DECISION_PROMPT" ||
+				decision === "POLICY_DECISION_PENDING"
+			);
+
+			log("requestResourceAccess result is %j", decision);
+			return decision === "POLICY_DECISION_PERMIT";
+		} catch (err) {
+			log("failure requesting resource access [%s]", err.message);
+			return Promise.reject(err);
+		}
+	}
+
+	/**
+	 * VoltAPI - resource management
+	 */
+
+	CanAccessResource(request) {
+		return unaryCall.call(this, "CanAccessResource", request);
+	}
+
+	DeleteResource(request) {
+		return unaryCall.call(this, "DeleteResource", request);
+	}
+
+	DiscoverServices(request) {
+		return unaryCall.call(this, "DiscoverServices", request);
+	}
+
+	GetResource(request) {
+		return unaryCall.call(this, "GetResource", request);
+	}
+
+	GetResources(request) {
+		return unaryCall.call(this, "GetResources", request);
+	}
+
+	GetResourceAncestors(request) {
+		return unaryCall.call(this, "GetResourceAncestors", request);
+	}
+
+	GetResourceDescendants(request) {
+		return unaryCall.call(this, "GetResourceDescendants", request);
+	}
+
+	RequestAccess(request) {
+		return unaryCall.call(this, "RequestAccess", request);
+	}
+
+	SaveResource(request) {
+		return unaryCall.call(this, "SaveResource", request);
+	}
+
+	SaveResourceAttribute(request) {
+		return unaryCall.call(this, "SaveResourceAttribute", request);
+	}
+
+	SetServiceStatus(request) {
+		return unaryCall.call(this, "SetServiceStatus", request);
+	}
+
+	/**
+	 * VoltAPI - volt management
+	 */
+
+	Bind(request) {
+		return unaryCall.call(this, "Bind", request);
+	}
+
+	DeleteAccess(request) {
+		return unaryCall.call(this, "DeleteAccess", request);
+	}
+
+	DeleteVolt(request) {
+		return unaryCall.call(this, "DeleteVolt", request);
+	}
+
+	GetAccess(request) {
+		return unaryCall.call(this, "GetAccess", request);
+	}
+
+	GetBindings(request) {
+		return unaryCall.call(this, "GetBindings", request);
+	}
+
+	GetIdentities(request) {
+		return unaryCall.call(this, "GetIdentities", request);
+	}
+
+	GetIdentity(request) {
+		return unaryCall.call(this, "GetIdentity", request);
+	}
+
+	GetIdentityToken(request) {
+		return unaryCall.call(this, "GetIdentityToken", request);
+	}
+
+	GetPolicy(request) {
+		return unaryCall.call(this, "GetPolicy", request);
+	}
+
+	GetSettings(request) {
+		return unaryCall.call(this, "GetSettings", request);
+	}
+
+	SaveAccess(request) {
+		return unaryCall.call(this, "SaveAccess", request);
+	}
+
+	SaveCloudConnection(request) {
+		return unaryCall.call(this, "SaveCloudConnection", request);
+	}
+
+	SaveIdentity(request) {
+		return unaryCall.call(this, "SaveIdentity", request);
+	}
+
+	SaveSettings(request) {
+		return unaryCall.call(this, "SaveSettings", request);
+	}
+
+	SetAccessRequestDecision(request) {
+		return unaryCall.call(this, "SetAccessRequestDecision", request);
+	}
+
+	SetBindingDecision(request) {
+		return unaryCall.call(this, "SetBindingDecision", request);
+	}
+
+	Shutdown(request) {
+		return unaryCall.call(this, "Shutdown", request);
+	}
+
+	SignVerify(request) {
+		return unaryCall.call(this, "SignVerify", request);
+	}
+
+	/**
+	 * FileAPI
+	 */
+	GetFileDescendants(request) {
+		return unaryCall.call(this, "GetFileDescendants", request);
+	}
+
+	/**
+	 * Asynchronous file download
+	 * @param {*} request
+	 * @returns stream
+	 */
+	DownloadFile(request) {
+		const grpcClient = this.getVoltAPIClient();
+
+		return new Promise((resolve, reject) => {
+			const meta = this._credential.getIdentityMetadata(
+				this._grpc,
+				this._voltConfig.id,
+				this.isRemote,
+			);
+			resolve(grpcClient.DownloadFile(request, meta.metadata));
+		}).catch((err) => {
+			log("error during %s [%s]", method, err.message);
+			return Promise.reject(err);
+		});
+	}
+
+	UploadFile(request, callback) {
+		const grpcClient = this.getVoltAPIClient();
+
+		const uploadCall = new GRPCCall(this, "UploadFile", "METHOD_TYPE_BIDI");
+		return uploadCall.start(grpcClient, request, callback);
+	}
+
+	/**
+	 * Synchronous file download
+	 * @param {*} request
+	 * @returns file buffer, base64 encoded
+	 */
+	DownloadFileSync(request) {
+		const grpcClient = this.getVoltAPIClient();
+
+		const blocks = [];
+
+		const call = new GRPCCall(
+			this,
+			"DownloadFile",
+			"METHOD_TYPE_SERVER_STREAM",
+		);
+		call.start(grpcClient, request, (err, response) => {
+			if (err) {
+				return call.reject(err);
+			}
+
+			switch (response.payload) {
+				case "block": {
+					blocks.push(response.block);
+					break;
+				}
+				case "status": {
+					if (response.status.message) {
+						return call.reject(new Error(response.status.message));
+					} else {
+						// Non-error response status => do nothing and wait for the stream to end.
+					}
+					break;
+				}
+				default:
+					log("unrecognised response payload %s", response.payload);
+					break;
+			}
+		});
+
+		return call
+			.wait()
+			.then(() => {
+				log("Download finished");
+				return { buffer: Buffer.concat(blocks).toString("base64") };
+			})
+			.catch((err) => {
+				log("error during DownloadFile [%s]", err.message);
+				return Promise.reject(err);
+			});
+	}
+
+	/**
+	 * SqliteDatabaseAPI
+	 */
+	SqlExecute(request, callback) {
+		const grpcClient = this.getVoltAPIClient();
+
+		const subscribeCall = new GRPCCall(this, "Execute", "METHOD_TYPE_BIDI");
+		return subscribeCall.start(grpcClient, request, callback);
+	}
+
+	/**
+	 * WireAPI
+	 */
+	PublishWire(request, callback) {
+		const grpcClient = this.getVoltAPIClient();
+
+		const publishCall = new GRPCCall(this, "PublishWire", "METHOD_TYPE_BIDI");
+		return publishCall.start(grpcClient, request, callback);
+	}
+
+	SubscribeWire(request, callback) {
+		const grpcClient = this.getVoltAPIClient();
+
+		const subscribeCall = new GRPCCall(
+			this,
+			"SubscribeWire",
+			"METHOD_TYPE_BIDI",
+		);
+		return subscribeCall.start(grpcClient, request, callback);
+	}
 }