@tdxvolt/volt-client-grpc 0.1.2 → 0.11.0

package/lib/index.cjs

@@ -789,260 +789,283 @@ var protoUtils = /*#__PURE__*/Object.freeze({
 
 const log$3 = debug__default["default"]("volt-client-grpc:grpc-call");
 
-function _prepareInvokeRequest(request, method, methodType = "METHOD_TYPE_UNARY") {
-  const meta = this._voltClient.credential.getIdentityMetadata(
-    this._voltClient.grpc,
-    this._voltClient.voltConfig.id,
-    this._voltClient.isRemote
-  );
-  let invokeRequest;
-  let callMethod = method;
-
-  if (this._voltClient.isVoltRelay) {
-    let requestPayload;
-    if (request) {
-      requestPayload = this._grpcClient[method].requestSerialize(request);
-    } else if (request !== null) {
-      log$3("****************LOOKOUT****************** - empty request");
-    } else {
-      log$3("explicit empty request payload");
-    }
-
-    const tunnelMethod = this._grpcClient.Tunnel;
-
-    const tunnelResp = {
-      method_invoke: {
-        method_name: this._grpcClient[method].path,
-        method_type: methodType,
-        token: meta.token,
-        request: requestPayload,
-      },
-    };
-
-    const invokePayload = VoltCredential.aesEncrypt(
-      tunnelMethod.responseSerialize(tunnelResp),
-      meta.sharedKey.key,
-      meta.sharedKey.iv
-    );
-
-    log$3("target volt is %s", this._voltClient.credential.voltFingerprint);
-
-    invokeRequest = {
-      identity_fingerprint: this._voltClient.credential.voltFingerprint,
-      payload: invokePayload,
-    };
-
-    callMethod = "Invoke";
-  } else if (this._voltClient.isRemote && meta.sharedKey.key) {
-    const requestPayload = this._grpcClient[method].requestSerializeOriginal(request);
-    invokeRequest = VoltCredential.aesEncrypt(requestPayload, meta.sharedKey.key, meta.sharedKey.iv);
-  } else {
-    invokeRequest = request;
-  }
-
-  return {
-    meta,
-    method: callMethod,
-    methodName: method,
-    request: invokeRequest,
-  };
+function _prepareInvokeRequest(
+	request,
+	method,
+	methodType = "METHOD_TYPE_UNARY",
+) {
+	const meta = this._voltClient.credential.getIdentityMetadata(
+		this._voltClient.grpc,
+		this._voltClient.voltConfig.id,
+		this._voltClient.isRemote,
+	);
+	let invokeRequest;
+	let callMethod = method;
+
+	if (this._voltClient.isVoltRelay) {
+		let requestPayload;
+		if (request) {
+			requestPayload = this._grpcClient[method].requestSerialize(request);
+		} else if (request !== null) {
+			log$3("****************LOOKOUT****************** - empty request");
+		} else {
+			log$3("explicit empty request payload");
+		}
+
+		const tunnelMethod = this._grpcClient.Tunnel;
+
+		const tunnelResp = {
+			method_invoke: {
+				method_name: this._grpcClient[method].path,
+				method_type: methodType,
+				token: meta.token,
+				request: requestPayload,
+			},
+		};
+
+		const invokePayload = VoltCredential.aesEncrypt(
+			tunnelMethod.responseSerialize(tunnelResp),
+			meta.sharedKey.key,
+			meta.sharedKey.iv,
+		);
+
+		log$3("target volt is %s", this._voltClient.credential.voltFingerprint);
+
+		invokeRequest = {
+			identity_fingerprint: this._voltClient.credential.voltFingerprint,
+			payload: invokePayload,
+		};
+
+		callMethod = "Invoke";
+	} else if (this._voltClient.isRemote && meta.sharedKey.key) {
+		const requestPayload =
+			this._grpcClient[method].requestSerializeOriginal(request);
+		invokeRequest = VoltCredential.aesEncrypt(
+			requestPayload,
+			meta.sharedKey.key,
+			meta.sharedKey.iv,
+		);
+	} else {
+		invokeRequest = request;
+	}
+
+	return {
+		meta,
+		method: callMethod,
+		methodName: method,
+		request: invokeRequest,
+	};
 }
 
 function _preparePayloadRequest(request, invokeInfo) {
-  let payloadRequest;
-
-  if (this._voltClient.isVoltRelay) {
-    const requestPayload = this._grpcClient[invokeInfo.methodName].requestSerialize(request);
-    const tunnelMethod = this._grpcClient.Tunnel;
-
-    const tunnelResp = {
-      method_payload: {
-        payload: requestPayload,
-      },
-    };
-
-    const invokePayload = VoltCredential.aesEncrypt(
-      tunnelMethod.responseSerialize(tunnelResp),
-      invokeInfo.meta.sharedKey.key,
-      invokeInfo.meta.sharedKey.iv
-    );
-
-    payloadRequest = {
-      payload: invokePayload,
-    };
-  } else if (this._voltClient.isRemote && invokeInfo.meta.sharedKey.key) {
-    const requestPayload = this._grpcClient[invokeInfo.methodName].requestSerializeOriginal(request);
-    payloadRequest = VoltCredential.aesEncrypt(
-      requestPayload,
-      invokeInfo.meta.sharedKey.key,
-      invokeInfo.meta.sharedKey.iv
-    );
-  } else {
-    payloadRequest = request;
-  }
-
-  return payloadRequest;
+	let payloadRequest;
+
+	if (this._voltClient.isVoltRelay) {
+		const requestPayload =
+			this._grpcClient[invokeInfo.methodName].requestSerialize(request);
+		const tunnelMethod = this._grpcClient.Tunnel;
+
+		const tunnelResp = {
+			method_payload: {
+				payload: requestPayload,
+			},
+		};
+
+		const invokePayload = VoltCredential.aesEncrypt(
+			tunnelMethod.responseSerialize(tunnelResp),
+			invokeInfo.meta.sharedKey.key,
+			invokeInfo.meta.sharedKey.iv,
+		);
+
+		payloadRequest = {
+			payload: invokePayload,
+		};
+	} else if (this._voltClient.isRemote && invokeInfo.meta.sharedKey.key) {
+		const requestPayload =
+			this._grpcClient[invokeInfo.methodName].requestSerializeOriginal(request);
+		payloadRequest = VoltCredential.aesEncrypt(
+			requestPayload,
+			invokeInfo.meta.sharedKey.key,
+			invokeInfo.meta.sharedKey.iv,
+		);
+	} else {
+		payloadRequest = request;
+	}
+
+	return payloadRequest;
 }
 
 function _parseResponse(method, meta, response) {
-  let invokeResponse = {};
-
-  if (this._voltClient.isVoltRelay) {
-    if (response.payload) {
-      const decryptedPayload = VoltCredential.aesDecrypt(response.payload, meta.sharedKey.key, meta.sharedKey.iv);
-      const tunnelMethod = this._grpcClient.Tunnel;
-      const responsePayload = tunnelMethod.requestDeserialize(decryptedPayload);
-      if (responsePayload.payload === "method_payload") {
-        invokeResponse.payload = this._grpcClient[method].responseDeserialize(responsePayload.method_payload.payload);
-      } else if (responsePayload.payload === "method_end") {
-        invokeResponse = responsePayload.method_end;
-      } else {
-        log$3("unexpected tunnel payload type: %s", responsePayload.payload);
-      }
-    } else if (response.status?.message) {
-      // There's been an error in the tunnel.
-      log$3(
-        "Tunnel status received: %s, code %d, description: %s",
-        response.status.message,
-        response.status.code,
-        response.status.description || "n/a"
-      );
-      invokeResponse = {ended: true, error: `Error in tunnel: ${response.status.message}`};
-    } else {
-      invokeResponse.methodId = response.invoke_id;
-      log$3("started method %d for %s", invokeResponse.methodId, method);
-    }
-  } else if (this._voltClient.isRemote && meta.sharedKey.key) {
-    const decryptedPayload = VoltCredential.aesDecrypt(response, meta.sharedKey.key, meta.sharedKey.iv);
-    invokeResponse = {payload: this._grpcClient[method].responseDeserializeOriginal(decryptedPayload)};
-  } else {
-    invokeResponse = {payload: response};
-  }
-
-  return invokeResponse;
+	let invokeResponse = {};
+
+	if (this._voltClient.isVoltRelay) {
+		if (response.payload) {
+			const decryptedPayload = VoltCredential.aesDecrypt(
+				response.payload,
+				meta.sharedKey.key,
+				meta.sharedKey.iv,
+			);
+			const tunnelMethod = this._grpcClient.Tunnel;
+			const responsePayload = tunnelMethod.requestDeserialize(decryptedPayload);
+			if (responsePayload.payload === "method_payload") {
+				invokeResponse.payload = this._grpcClient[method].responseDeserialize(
+					responsePayload.method_payload.payload,
+				);
+			} else if (responsePayload.payload === "method_end") {
+				invokeResponse = responsePayload.method_end;
+			} else {
+				log$3("unexpected tunnel payload type: %s", responsePayload.payload);
+			}
+		} else if (response.status?.message) {
+			// There's been an error in the tunnel.
+			log$3(
+				"Tunnel status received: %s, code %d, description: %s",
+				response.status.message,
+				response.status.code,
+				response.status.description || "n/a",
+			);
+			invokeResponse = {
+				ended: true,
+				error: `Error in tunnel: ${response.status.message}`,
+			};
+		} else {
+			invokeResponse.methodId = response.invoke_id;
+			log$3("started method %d for %s", invokeResponse.methodId, method);
+		}
+	} else if (this._voltClient.isRemote && meta.sharedKey.key) {
+		const decryptedPayload = VoltCredential.aesDecrypt(
+			response,
+			meta.sharedKey.key,
+			meta.sharedKey.iv,
+		);
+		invokeResponse = {
+			payload:
+				this._grpcClient[method].responseDeserializeOriginal(decryptedPayload),
+		};
+	} else {
+		invokeResponse = { payload: response };
+	}
+
+	return invokeResponse;
 }
 
 class GRPCCall extends EventEmitter__default["default"] {
-  constructor(voltClient, methodName, methodType) {
-    super();
-    this._methodName = methodName;
-    this._methodType = methodType;
-    this._call = null;
-    this._voltClient = voltClient;
-    this._lastResponse = null;
-    this._promise = null;
-    this._reject = null;
-  }
-
-  reject(err) {
-    if (this._reject) {
-      this._reject(err);
-    }
-  }
-
-  wait() {
-    return this._promise;
-  }
-
-  start(grpcClient, request, responseCB) {
-    this._promise = new Promise((resolve, reject) => {
-      this._grpcClient = grpcClient;
-      this._reject = reject;
-
-      const callbackIntercept = (err, response) => {
-        log$3("received callback for method %s", this._methodName);
-        if (err) {
-          reject(err);
-        } else if (response) {
-          this._lastResponse = response;
-          if (responseCB) {
-            responseCB(err, response);
-          }
-        } else {
-          this.end();
-          resolve(this._lastResponse);
-        }
-      };
-
-      this._initialRequest = _prepareInvokeRequest.call(this, request, this._methodName, this._methodType);
-
-      if (!this._grpcClient[this._initialRequest.method]) {
-        return reject(new Error(`method not found: '${this._initialRequest.method}'`));
-      }
-
-      this._call = this._grpcClient[this._initialRequest.method](this._initialRequest.meta.metadata, callbackIntercept);
-
-      this._call.on("data", (streamResponse) => {
-        try {
-          const parsedResponse = _parseResponse.call(this, this._methodName, this._initialRequest.meta, streamResponse);
-          if (parsedResponse.payload) {
-            callbackIntercept(null, parsedResponse.payload);
-          } else if (parsedResponse.ended) {
-            if (parsedResponse.error) {
-              callbackIntercept(new Error(parsedResponse.error), null);
-            } else {
-              callbackIntercept(null, null);
-            }
-          } else {
-            log$3("method id is %s", parsedResponse.methodId);
-          }
-        } catch (err) {
-          log$3("failure processing connect response: %s", err.message);
-          this.emit("error", err);
-        }
-      });
-
-      this._call.on("error", (err) => {
-        log$3("ERROR - intercepted stream error %s", err.message);
-        callbackIntercept(err, null);
-      });
-
-      this._call.on("finish", () => {
-        // The read side has ended (i.e. we called end()).
-        log$3("finished call %s", this._methodName);
-        this.emit("finish");
-      });
-
-      this._call.on("end", () => {
-        // The remote peer ended the stream.
-        log$3("ended call %s, method id: %s", this._methodName, this._initialRequest.methodId || "n/a - not tunnelling");
-        this.emit("end");
-        callbackIntercept(null, null);
-      });
-
-      if (this._initialRequest.request) {
-        this._call.write(this._initialRequest.request);
-      }
-    });
-
-    return this;
-  }
-
-  end() {
-    if (this._call) {
-      return this._call.end();
-    } else {
-      throw new Error("call not initialised");
-    }
-  }
-
-  get writable() {
-    return this._call?.writable;
-  }
-
-  write(request) {
-    if (!this._call) {
-      log$3("ERROR - call not initialised");
-      throw new Error("call not initialised");
-    } else if (this._initialRequest) {
-      const payloadRequest = _preparePayloadRequest.call(this, request, this._initialRequest);
-      return this._call.write(payloadRequest);
-    } else {
-      this._initialRequest = _prepareInvokeRequest.call(this, request, this._methodName, this._methodType);
-
-      return this._call.write(this._initialRequest.request);
-    }
-  }
+	constructor(voltClient, methodName, methodType) {
+		super();
+		this._methodName = methodName;
+		this._methodType = methodType;
+		this._call = null;
+		this._voltClient = voltClient;
+	}
+
+	start(grpcClient, request) {
+		this._grpcClient = grpcClient;
+
+		this._initialRequest = _prepareInvokeRequest.call(
+			this,
+			request,
+			this._methodName,
+			this._methodType,
+		);
+
+		if (!this._grpcClient[this._initialRequest.method]) {
+			return reject(
+				new Error(`method not found: '${this._initialRequest.method}'`),
+			);
+		}
+
+		this._call = this._grpcClient[this._initialRequest.method](
+			this._initialRequest.meta.metadata,
+		);
+
+		this._call.on("data", (streamResponse) => {
+			try {
+				const parsedResponse = _parseResponse.call(
+					this,
+					this._methodName,
+					this._initialRequest.meta,
+					streamResponse,
+				);
+				if (parsedResponse.payload) {
+					this.emit("data", parsedResponse.payload);
+				} else if (parsedResponse.ended) {
+					if (parsedResponse.error) {
+						this.emit("error", new Error(parsedResponse.error));
+					} else {
+						// Not sure this is necessary - we should receive "end" from grpc soon...
+						this.emit("end");
+					}
+				} else {
+					log$3("method id is %s", parsedResponse.methodId);
+				}
+			} catch (err) {
+				log$3("failure processing connect response: %s", err.message);
+				this.emit("error", err);
+			}
+		});
+
+		this._call.on("error", (err) => {
+			log$3("ERROR - intercepted stream error %s", err.message);
+			this.emit("error", err);
+		});
+
+		this._call.on("finish", () => {
+			// The read side has ended (i.e. we called end()).
+			log$3("finished call %s", this._methodName);
+			this.emit("finish");
+		});
+
+		this._call.on("end", () => {
+			// The remote peer ended the stream.
+			log$3(
+				"ended call %s, method id: %s",
+				this._methodName,
+				this._initialRequest.methodId || "n/a - not tunnelling",
+			);
+			this.emit("end");
+		});
+
+		if (this._initialRequest.request) {
+			this._call.write(this._initialRequest.request);
+		}
+
+		return this;
+	}
+
+	end() {
+		if (this._call) {
+			return this._call.end();
+		} else {
+			throw new Error("call not initialised");
+		}
+	}
+
+	get writable() {
+		return this._call?.writable;
+	}
+
+	write(request) {
+		if (!this._call) {
+			log$3("ERROR - call not initialised");
+			throw new Error("call not initialised");
+		} else if (this._initialRequest) {
+			const payloadRequest = _preparePayloadRequest.call(
+				this,
+				request,
+				this._initialRequest,
+			);
+			return this._call.write(payloadRequest);
+		} else {
+			this._initialRequest = _prepareInvokeRequest.call(
+				this,
+				request,
+				this._methodName,
+				this._methodType,
+			);
+
+			return this._call.write(this._initialRequest.request);
+		}
+	}
 }
 
 /* eslint-disable no-use-before-define */
@@ -1281,19 +1304,21 @@ async function bindInternal() {
 	try {
 		// Check if we need to resolve a Relay volt.
 		if (
-			this._config?.relay?.discovery_url ||
-			typeof this._config?.relay === "string"
+			typeof this._voltConfig?.relay === "string" ||
+			this._voltConfig?.relay?.http_address
 		) {
-			const relayURL = this._config.relay?.discovery_url || this._config.relay;
+			const relayURL =
+				this._voltConfig.relay?.http_address || this._voltConfig.relay;
 			log$1("attempting to retrieve Relay information from %s", relayURL);
-			const voltConfig = await fetchVoltConfig.call(this, relayURL);
-			this._config.relay = voltConfig.volt;
-			this._config.relay.discovery_url = relayURL;
-			if (this._config.relay.ca_pem) {
+			this._voltConfig.relay = await fetchVoltConfig.call(
+				this,
+				`${relayURL}/discovery`,
+			);
+			if (this._voltConfig.relay.ca_pem) {
 				log$1(
 					"Auto-fetched Relay CA %s, remote address %s",
-					this._config.relay.ca_pem,
-					this._config.relay.address,
+					this._voltConfig.relay.ca_pem,
+					this._voltConfig.relay.address,
 				);
 			} else {
 				throw new Error("Unable to fetch Relay CA - cannot securely connect.");
@@ -1455,8 +1480,8 @@ function getVoltAPIClientInternal() {
 			serviceAddress,
 			this._credential,
 			this.isRemote && !this.isVoltRelay,
-			this._config?.relay?.cloud_relay ? this._voltConfig.id : "",
-			this._config?.relay?.cloud_relay ? this._voltConfig.id : "",
+			this._config?.relay?.cloud ? this._voltConfig.id : "",
+			this._config?.relay?.cloud ? this._voltConfig.id : "",
 		);
 	}
 
@@ -1464,55 +1489,95 @@ function getVoltAPIClientInternal() {
 }
 
 function unaryCall(method, request) {
-	const grpcClient = this.getVoltAPIClient();
+	return new Promise((resolve, reject) => {
+		const grpcClient = this.getVoltAPIClient();
+
+		const call = new GRPCCall(this, method, "METHOD_TYPE_UNARY");
+
+		let response = null;
+
+		call.on("data", (payload) => {
+			// Cache the response and wait for `end`.
+			response = payload;
+		});
 
-	const call = new GRPCCall(this, method, "METHOD_TYPE_UNARY");
-	call.start(grpcClient, request);
-	return call.wait();
+		call.on("error", reject);
+
+		call.on("end", () => {
+			if (!response) {
+				return reject(new Error("no response received"));
+			}
+
+			// Convert non-OK status to a JS error.
+			if (response.status?.message) {
+				reject(new Error(response.status.message));
+			} else {
+				resolve(response);
+			}
+		});
+
+		call.start(grpcClient, request);
+	});
 }
 
-async function fetchVoltConfig(disovery_url) {
-	const getJSON = bent__default["default"]("json");
-	const resolvedConfig = await getJSON(disovery_url);
-
-	const voltConfig = pick(
-		resolvedConfig,
-		"id",
-		"display_name",
-		"public_key",
-		"fingerprint",
-		"address",
-		"ca_pem",
-		"challenge_code",
-		"cloud_relay",
-	);
+async function fetchVoltConfig(discovery_url) {
+	try {
+		const getJSON = bent__default["default"]("json");
+		const fullVoltConfig = await getJSON(discovery_url);
 
-	const relayConfig = pick(resolvedConfig, "relay");
+		if (!fullVoltConfig || typeof fullVoltConfig !== "object") {
+			throw new Error(`invalid config resolved from: ${discovery_url}`);
+		}
+
+		const voltConfig = pick(
+			fullVoltConfig,
+			"id",
+			"display_name",
+			"public_key",
+			"fingerprint",
+			"address",
+			"ca_pem",
+			"challenge_code",
+			"cloud",
+			"relay",
+		);
 
-	return { volt: voltConfig, ...relayConfig };
+		return voltConfig;
+	} catch (err) {
+		throw new Error(
+			`Failure loading config from ${discovery_url}: ${err.message}`,
+		);
+	}
 }
 
 async function fetchVoltConfigFromDID(volt_did) {
-	const didResolution = getDIDResolutionURL(volt_did);
-	if (!didResolution) {
-		throw new Error(`Invalid Volt DID: ${volt_did}`);
-	}
+	try {
+		const didResolution = getDIDResolutionURL(volt_did);
+		if (!didResolution) {
+			throw new Error(`Invalid Volt DID: ${volt_did}`);
+		}
 
-	const getJSON = bent__default["default"]("json");
-	const didDocument = await getJSON(didResolution);
-	const voltConfigServices = findDIDDocumentService(
-		didDocument,
-		constants.didServiceType.voltConfig,
-	);
-	if (voltConfigServices.length !== 1) {
-		log$1(
-			"Unexpected number of Volt configuration endpoints found in DID document for %s, services found: %d",
-			volt_did,
-			voltConfigServices.length,
+		const getJSON = bent__default["default"]("json");
+		const didDocument = await getJSON(didResolution);
+		const voltConfigServices = findDIDDocumentService(
+			didDocument,
+			constants.didServiceType.voltConfig,
+		);
+		if (voltConfigServices.length !== 1) {
+			log$1(
+				"Unexpected number of Volt configuration endpoints found in DID document for %s, services found: %d",
+				volt_did,
+				voltConfigServices.length,
+			);
+		}
+
+		const serviceEndpoint = voltConfigServices[0].serviceEndpoint;
+		return await fetchVoltConfig.call(this, serviceEndpoint);
+	} catch (err) {
+		throw new Error(
+			`Failure fetching Volt config from DID document ${volt_did}: ${err.message}`,
 		);
 	}
-	const serviceEndpoint = voltConfigServices[0].serviceEndpoint;
-	return await fetchVoltConfig.call(this, serviceEndpoint);
 }
 
 const { readFile } = fs__default["default"].promises;
@@ -1601,32 +1666,38 @@ class VoltClient extends EventEmitter__default["default"] {
 			this._config = { ...configJSON, ...extras };
 
 			let voltDID = "";
-			let voltDiscovery = "";
+			let voltHttpAddress = "";
 			if (typeof this._config.volt === "string") {
 				if (this._config.volt.indexOf("did:") === 0) {
 					voltDID = this._config.volt;
 				} else {
-					voltDiscovery = this._config.volt;
+					voltHttpAddress = 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;
+				voltHttpAddress = this._config.volt.http_address;
 			}
 
 			if (voltDID) {
 				const didConfig = await fetchVoltConfigFromDID.call(this, voltDID);
-				this._config = { ...this._config, ...didConfig };
+				this._config = { ...this._config, volt: 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 };
+			} else if (voltHttpAddress) {
+				const discoConfig = await fetchVoltConfig.call(
+					this,
+					`${voltHttpAddress}/discovery`,
+				);
+				this._config = {
+					...this._config,
+					volt: { ...this._config.volt, ...discoConfig },
+				};
 			}
 
 			this._voltConfig = this._config.volt;
 			this._voltConfig.did = voltDID;
-			this._voltConfig.discovery_url = voltDiscovery;
+			this._voltConfig.http_address = voltHttpAddress;
 
 			if (!this._voltConfig.id || typeof this._voltConfig.id !== "string") {
 				throw new Error("'id' property is missing in Volt configuration");
@@ -1756,7 +1827,7 @@ class VoltClient extends EventEmitter__default["default"] {
 	}
 
 	get isVoltRelay() {
-		return this.isRemote && !this._config?.relay.cloud_relay;
+		return this.isRemote && !this._config?.relay.cloud;
 	}
 
 	connect() {
@@ -1777,7 +1848,7 @@ class VoltClient extends EventEmitter__default["default"] {
 	/**
 	 * Request resource access.
 	 * @param {*} targetResourceId
-	 * @param {*} accessType - see vault.proto for enum values.
+	 * @param {*} accessType - see volt.proto for values.
 	 */
 	async RequestAccessBlocking(
 		targetResourceId,
@@ -1952,24 +2023,19 @@ class VoltClient extends EventEmitter__default["default"] {
 	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);
-		});
+		const downloadCall = new GRPCCall(
+			this,
+			"DownloadFile",
+			"METHOD_TYPE_SERVER_STREAM",
+		);
+		return downloadCall.start(grpcClient, request);
 	}
 
-	UploadFile(request, callback) {
+	UploadFile(request) {
 		const grpcClient = this.getVoltAPIClient();
 
 		const uploadCall = new GRPCCall(this, "UploadFile", "METHOD_TYPE_BIDI");
-		return uploadCall.start(grpcClient, request, callback);
+		return uploadCall.start(grpcClient, request);
 	}
 
 	/**
@@ -1978,70 +2044,70 @@ class VoltClient extends EventEmitter__default["default"] {
 	 * @returns file buffer, base64 encoded
 	 */
 	DownloadFileSync(request) {
-		const grpcClient = this.getVoltAPIClient();
+		return new Promise((resolve, reject) => {
+			const grpcClient = this.getVoltAPIClient();
 
-		const blocks = [];
+			const blocks = [];
 
-		const call = new GRPCCall(
-			this,
-			"DownloadFile",
-			"METHOD_TYPE_SERVER_STREAM",
-		);
-		call.start(grpcClient, request, (err, response) => {
-			if (err) {
-				return call.reject(err);
-			}
+			const call = new GRPCCall(
+				this,
+				"DownloadFile",
+				"METHOD_TYPE_SERVER_STREAM",
+			);
 
-			switch (response.payload) {
-				case "block": {
-					blocks.push(response.block);
-					break;
-				}
-				case "status": {
-					if (response.status.message) {
-						return call.reject(new Error(response.status.message));
+			call.on("data", (response) => {
+				switch (response.payload) {
+					case "block": {
+						blocks.push(response.block);
+						break;
 					}
-					break;
+					case "status": {
+						if (response.status.message) {
+							return call.reject(new Error(response.status.message));
+						}
+						break;
+					}
+					default:
+						log("unrecognised response payload %s", response.payload);
+						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) => {
+			call.on("error", (err) => {
 				log("error during DownloadFile [%s]", err.message);
-				return Promise.reject(err);
+				reject(err);
 			});
+
+			call.on("end", () => {
+				log("Download finished");
+				resolve({ buffer: Buffer.concat(blocks).toString("base64") });
+			});
+
+			call.start(grpcClient, request);
+		});
 	}
 
 	/**
 	 * SqliteDatabaseAPI
 	 */
-	SqlExecute(request, callback) {
+	SqlExecute(request) {
 		const grpcClient = this.getVoltAPIClient();
 
 		const subscribeCall = new GRPCCall(this, "Execute", "METHOD_TYPE_BIDI");
-		return subscribeCall.start(grpcClient, request, callback);
+		return subscribeCall.start(grpcClient, request);
 	}
 
 	/**
 	 * WireAPI
 	 */
-	PublishWire(request, callback) {
+	PublishWire(request) {
 		const grpcClient = this.getVoltAPIClient();
 
 		const publishCall = new GRPCCall(this, "PublishWire", "METHOD_TYPE_BIDI");
-		return publishCall.start(grpcClient, request, callback);
+		return publishCall.start(grpcClient, request);
 	}
 
-	SubscribeWire(request, callback) {
+	SubscribeWire(request) {
 		const grpcClient = this.getVoltAPIClient();
 
 		const subscribeCall = new GRPCCall(
@@ -2049,7 +2115,7 @@ class VoltClient extends EventEmitter__default["default"] {
 			"SubscribeWire",
 			"METHOD_TYPE_BIDI",
 		);
-		return subscribeCall.start(grpcClient, request, callback);
+		return subscribeCall.start(grpcClient, request);
 	}
 }