@tdxvolt/volt-client-grpc 0.18.9 → 0.19.0

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.18.9",
+  "version": "0.19.0",
   "description": "tdx Volt library for nodejs clients",
   "type": "module",
   "exports": {
@@ -37,8 +37,7 @@
   "author": "toby.ealden@gmail.com",
   "license": "ISC",
   "dependencies": {
-    "@tdxvolt/volt-client-web": "^0.18.1",
-    "bent": "^7.3.12",
+    "@tdxvolt/volt-client-web": "^0.19.0",
     "builtin-modules": "^3.3.0",
     "debug": "^4.1.1",
     "ip": "^1.1.5",

package/src/constants.js

@@ -1,4 +1,4 @@
-export const constants = {
+const _constants = {
   authTokenName: "volt-token",
   defaultDIDHostName: "coreid.com",
   didServiceType: {
@@ -19,5 +19,14 @@ export const constants = {
     terminalAPI: "tdx.volt_api.volt.v1.TerminalAPI",
     voltAPI: "tdx.volt_api.volt.v1.VoltAPI",
     wireAPI: "tdx.volt_api.volt.v1.WireAPI"
-  }
+  },
+  voltDIDPrefix: "did:volt:"
 };
+
+_constants.defaultRegistryList = [
+  _constants.defaultDIDHostName,
+  "https://tdxvolt.com",
+  "https://tdxid.com"
+];
+
+export const constants = _constants;

package/src/index.js

@@ -1,7 +1,8 @@
-export {constants} from "./constants.js";
+export { SyncProvider } from "@tdxvolt/volt-client-web";
+export { v4 as generateId } from "uuid";
+export { constants } from "./constants.js";
 export * as grpcUtils from "./grpc-utils.js";
+export * as protoUtils from "./proto-utils.js";
 export * as utils from "./utils.js";
-export {VoltClient} from "./volt-client.js";
+export { VoltClient } from "./volt-client.js";
 export * from "./volt-credential.js";
-export * as protoUtils from "./proto-utils.js";
-export {v4 as generateId} from "uuid";

package/src/volt-client-internal.js

@@ -1,6 +1,5 @@
 /* eslint-disable no-underscore-dangle */
 import { voltUtils as voltClientUtils } from "@tdxvolt/volt-client-web/js";
-import bent from "bent";
 import debug from "debug";
 import ip from "ip";
 import lodash from "lodash";
@@ -106,30 +105,6 @@ export async function authenticateInternal(
   ownDID = false
 ) {
   try {
-    // Check if we need to resolve a Relay volt.
-    if (
-      typeof this._voltConfig?.relay === "string" ||
-      this._voltConfig?.relay?.http_address
-    ) {
-      const relayURL =
-        this._voltConfig.relay?.http_address || this._voltConfig.relay;
-      log("attempting to retrieve Relay information from %s", relayURL);
-      this._voltConfig.relay = await fetchVoltConfig.call(
-        this,
-        `${relayURL}/discover`
-      );
-
-      if (this._voltConfig.relay.ca_pem) {
-        log(
-          "Auto-fetched Relay CA %s, remote address %s",
-          this._voltConfig.relay.ca_pem,
-          this._voltConfig.relay.address
-        );
-      } else {
-        throw new Error("Unable to fetch Relay CA - cannot securely connect.");
-      }
-    }
-
     if (!this._credential.cache.ca) {
       this._credential.cache.ca = this._voltConfig.ca_pem;
     }
@@ -159,10 +134,10 @@ export async function authenticateInternal(
       host: this._credential.cache.bindIp
     };
 
-    if (this._voltConfig.challenge_code) {
+    if (this._credential.cache.challenge_code) {
       authenticateRequest.challenge = signBase64(
         this._credential.cache.key,
-        this._voltConfig.challenge_code
+        this._credential.cache.challenge_code
       );
     } else {
       log(
@@ -459,11 +434,18 @@ export function streamingCallInternal(methodType, method, request, service) {
 
 export async function fetchVoltConfig(discovery_url) {
   try {
-    const getJSON = bent("json");
-    const fullVoltConfig = await getJSON(discovery_url);
+    const response = await fetch(discovery_url);
+
+    if (!response.ok) {
+      log("fetchVoltConfig - error [%s]", response.status);
+      return null;
+    }
+
+    const fullVoltConfig = await response.json();
 
     if (!fullVoltConfig || typeof fullVoltConfig !== "object") {
-      throw new Error(`invalid config resolved from: ${discovery_url}`);
+      log("fetchVoltConfig - invalid config resolved from: %s", discovery_url);
+      return null;
     }
 
     const voltConfig = pick(
@@ -475,16 +457,15 @@ export async function fetchVoltConfig(discovery_url) {
       "address",
       "http_address",
       "ca_pem",
-      "challenge_code",
-      "cloud",
       "relay"
     );
 
+    log("fetchVoltConfig from %s", discovery_url);
+
     return voltConfig;
   } catch (err) {
-    throw new Error(
-      `Failure loading config from ${discovery_url}: ${err.message}`
-    );
+    log("fetchVoltConfig - %s error [%s]", discovery_url, err.message);
+    return null;
   }
 }
 
@@ -495,8 +476,13 @@ async function fetchVoltConfigFromDIDInternal(volt_did, registryUrl) {
       throw new Error(`Invalid Volt DID: ${volt_did}`);
     }
 
-    const getJSON = bent("json");
-    const didDocument = await getJSON(didResolution);
+    const response = await fetch(didResolution);
+
+    if (!response.ok) {
+      throw new Error(`HTTP error, status: ${response.status}`);
+    }
+
+    const didDocument = await response.json();
     const voltConfigServices = findDIDDocumentService(
       didDocument,
       constants.didServiceType.voltConfig
@@ -512,7 +498,12 @@ async function fetchVoltConfigFromDIDInternal(volt_did, registryUrl) {
     log("resolved DID from %s", didResolution);
 
     const serviceEndpoint = voltConfigServices[0].serviceEndpoint;
-    return await fetchVoltConfig.call(this, serviceEndpoint);
+    const voltConfig = await fetchVoltConfig.call(this, serviceEndpoint);
+    if (!voltConfig) {
+      throw new Error(`failed to resolve Volt config from ${serviceEndpoint}`);
+    }
+
+    return voltConfig;
   } catch (err) {
     throw new Error(
       `Failure fetching Volt config from DID document ${volt_did}: ${err.message}`
@@ -520,21 +511,128 @@ async function fetchVoltConfigFromDIDInternal(volt_did, registryUrl) {
   }
 }
 
-export async function fetchVoltConfigFromDID(
-  volt_did,
-  registryList = [constants.defaultDIDHostName]
-) {
+export async function fetchVoltConfigFromDID(volt_did, registryListIn) {
+  let registryList;
+  if (!registryListIn) {
+    //  If no registry list is provided, use the default registry list.
+    registryList = constants.defaultRegistryList;
+  } else {
+    // If a registry list is provided, merge it with the default registry list.
+    registryList = Array.from(
+      new Set(registryListIn.concat(constants.defaultRegistryList))
+    );
+  }
+
+  let voltConfig;
   for (let registryUrl of registryList) {
     try {
-      return await fetchVoltConfigFromDIDInternal.call(
+      voltConfig = await fetchVoltConfigFromDIDInternal.call(
         this,
         volt_did,
         registryUrl
       );
+
+      // If we've found a config, break out of the loop.
+      break;
+    } catch (err) {
+      log("unable to fetch Volt config from %s: %s", registryUrl, err.message);
+    }
+  }
+
+  if (!voltConfig) {
+    log("failed to fetch Volt config for %s from any registry", volt_did);
+  }
+
+  return voltConfig;
+}
+
+export async function resolveVoltConfig(cfg, didRegistryList) {
+  // Start by resolving the relay if one is specified.
+  let relay = cfg?.relay?.http_address || cfg?.relay;
+  if (relay) {
+    relay = await resolveVoltConfig.call(this, relay, didRegistryList);
+  }
+
+  let voltDID = "";
+  let voltHttpAddress = "";
+
+  if (typeof cfg === "string") {
+    // If the configuration is a string, determine if it is a DID or HTTP address.
+    if (cfg.indexOf("did:") === 0) {
+      voltDID = cfg;
+    } else {
+      voltHttpAddress = cfg;
+    }
+    cfg = {};
+  } else if (typeof cfg === "object") {
+    voltDID = cfg.id;
+    voltHttpAddress = cfg.http_address;
+  } else {
+    throw new Error("configuration is missing the 'volt' object");
+  }
+
+  let resolvedConfig;
+
+  if (relay) {
+    if (!voltDID) {
+      throw new Error("relay specified but no Volt DID provided");
+    }
+
+    // Build the sub-domain URL for the Volt discovery service by inserting the volt DID into the relay URL.
+    const relayURL = relay.http_address;
+    const relayParts = relayURL.split("://");
+    const subdomain = voltDID.substring(constants.voltDIDPrefix.length);
+    voltHttpAddress = `${relayParts[0]}://${subdomain}.${relayParts[1]}`;
+  } else if (voltDID) {
+    resolvedConfig = await fetchVoltConfigFromDID.call(
+      this,
+      voltDID,
+      didRegistryList
+    );
+  }
+
+  if (!resolvedConfig && voltHttpAddress) {
+    try {
+      resolvedConfig = await fetchVoltConfig.call(
+        this,
+        `${voltHttpAddress}/discover`
+      );
+
+      // Update the http address in the resolved config to the one we used to
+      // fetch it, since we may have used the relay rather than local address.
+      resolvedConfig.http_address = voltHttpAddress;
     } catch (err) {
-      log("Failed to fetch Volt config from %s: %s", registryUrl, err.message);
+      log(
+        "failed to resolve Volt configuration %s [%s]",
+        voltHttpAddress,
+        err.message
+      );
+    }
+  }
+
+  if (!resolvedConfig) {
+    if (cfg.address && cfg.ca_pem) {
+      log(
+        "unable to resolve %s / %s, using existing configuration",
+        voltDID,
+        voltHttpAddress
+      );
+    } else {
+      throw new Error(
+        `failed to resolve Volt ${voltDID} / ${voltHttpAddress} and no existing configuration`
+      );
     }
+  } else {
+    log("resolved config from: %s", voltDID || voltHttpAddress);
+    log(JSON.stringify(resolvedConfig, null, 2));
+
+    cfg = {
+      ...cfg,
+      ...resolvedConfig
+    };
   }
 
-  throw new Error(`Failed to fetch Volt config from any of these registries: ${registryList.join(", ")}`);
+  cfg.relay = relay;
+
+  return cfg;
 }

package/src/volt-client.js

@@ -6,9 +6,8 @@ import GRPCCall from "./grpc-call.js";
 import {
   authenticateInternal,
   connectInternal,
-  fetchVoltConfig,
-  fetchVoltConfigFromDID,
   getVoltAPIClientInternal,
+  resolveVoltConfig,
   streamingCallInternal,
   unaryCallInternal
 } from "./volt-client-internal.js";
@@ -74,19 +73,22 @@ export class VoltClient extends EventEmitter {
 
   /**
    * Initialises a binding and connection to the volt.
-   * @param {string} [config] - the location of the Volt configuration file, or a configuration object
-   * @param {object} [extras] - additional configuration properties
+   * @param {string | object} [config] - the location of the Volt configuration
+   * file, or a configuration object
+   * @param {object} [options] - initialisation options
+   * @param {string[]} [options.didRegistryList] - list of DID registry URLs to use for
+   * resolving DIDs
+   * @param {object} [options.extraConfig] - additional configuration to be merged with the
+   * configuration from the config file.
+   * @param {boolean} [options.ownDID] - whether the Volt should manage the DID - set to
+   * true  if you want to manage the DID yourself
    */
-  async initialise(
-    config,
-    extras = {},
-    ownDID = false,
-    didRegistryList = undefined
-  ) {
+  async initialise(config, options = {}) {
+    const { ownDID, didRegistryList, extraConfig } = options;
     try {
       if (!config) {
         throw new Error(
-          "configPath argument is required to be a non-empty string"
+          "config argument is required to be a non-empty string or JSON object"
         );
       }
 
@@ -119,7 +121,8 @@ export class VoltClient extends EventEmitter {
         throw new Error("config argument is required to be an object");
       }
 
-      this._config = { ...extras, ...configJSON };
+      // Merge any extra configuration supplied, preferring that loaded from file.
+      this._config = { ...extraConfig, ...configJSON };
 
       if (
         !this._config.client_name ||
@@ -128,52 +131,13 @@ export class VoltClient extends EventEmitter {
         throw new Error("client_name property required in config");
       }
 
-      let voltDID = "";
-      let voltHttpAddress = "";
-      if (typeof this._config.volt === "string") {
-        if (this._config.volt.indexOf("did:") === 0) {
-          voltDID = this._config.volt;
-        } else {
-          voltHttpAddress = this._config.volt;
-        }
-        delete 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;
-        voltHttpAddress = this._config.volt.http_address;
-      }
-
-      if (voltDID) {
-        const didConfig = await fetchVoltConfigFromDID.call(
-          this,
-          voltDID,
-          didRegistryList
-        );
-
-        // Remove the relay list from the DID config, as it would overwrite the relay in the supplied config.
-        delete didConfig.relay;
-
-        this._config = { ...this._config, volt: didConfig };
-        log("resolved config from DID: %s", JSON.stringify(didConfig, null, 2));
-      } else if (voltHttpAddress && !this._config?.volt?.id) {
-        const discoConfig = await fetchVoltConfig.call(
-          this,
-          `${voltHttpAddress}/discover`
-        );
-        this._config = {
-          ...this._config,
-          volt: { ...this._config.volt, ...discoConfig }
-        };
-      }
+      this._config.volt = await resolveVoltConfig.call(
+        this,
+        this._config.volt,
+        didRegistryList
+      );
 
       this._voltConfig = this._config.volt;
-      if (voltDID) {
-        this._voltConfig.did = voltDID;
-      }
-      if (voltHttpAddress) {
-        this._voltConfig.http_address = voltHttpAddress;
-      }
 
       if (!this._voltConfig.id || typeof this._voltConfig.id !== "string") {
         throw new Error("'id' property is missing in Volt configuration");
@@ -228,13 +192,14 @@ export class VoltClient extends EventEmitter {
 
       return Promise.resolve(this._config);
     } catch (err) {
-      log("Failure starting Volt client [%s]", err.message);
+      log("failure starting Volt client [%s]", err.message);
       throw err;
     }
   }
 
-  initialiseAndConnect(configPath, helloPayload = undefined, extras = {}) {
-    return this.initialise(configPath, extras)
+  initialiseAndConnect(configPath, options) {
+    const helloPayload = options?.helloPayload;
+    return this.initialise(configPath, options)
       .then(() => {
         return connectInternal.call(this, helloPayload);
       })

package/src/volt-credential.js

@@ -1,8 +1,9 @@
 /* eslint-disable no-underscore-dangle */
+import { voltUtils as voltClientUtils } from "@tdxvolt/volt-client-web/js";
+import crypto from "crypto";
 import debug from "debug";
 import fs from "fs";
 import { constants } from "./constants.js";
-import { voltUtils as voltClientUtils } from "@tdxvolt/volt-client-web/js";
 
 const {
   createSigningKey,
@@ -54,6 +55,11 @@ export class VoltCredential {
 
       // Extract Volt public key.
       this._voltPublicKey = this._voltConfig.public_key;
+      if (!this._voltPublicKey) {
+        // Extract the public key from the Volt CA cert.
+        const voltCA = new crypto.X509Certificate(this._voltConfig.ca_pem);
+        this._voltPublicKey = voltCA.publicKey.export({ type: 'spki', format: 'pem' });
+      }
 
       const voltKey = keyFromPem(this._voltPublicKey).publicKey;
       this._voltFingerprint = fingerprintFromPem(voltKey);

package/src/volt-proto-literals.js

@@ -2747,6 +2747,7 @@ message InvokeResponse {
   // The invocation id to match the originating request.
   uint64 invoke_id = 1;
 
+  // Key exchange details for the response payload encryption. Only necessary for the first response.
   InvokeRequestKeyExchange key_exchange = 2;
 
   // The initialisation vector for the response payload encryption. This will be a random 16 byte value, that is different for each response.