@tdxvolt/volt-client-grpc 0.17.0 → 0.18.1

package/src/volt-client-internal.js

@@ -16,11 +16,9 @@ import { constants } from "./constants.js";
 import GRPCCall from "./grpc-call.js";
 import RpcInvocation from "./rpc-invocation.js";
 import { v4 as generateId } from "uuid";
-import {
-  publicKeyToPem,
-  removeCarriageReturn,
-  signBase64
-} from "@tdxvolt/volt-client-web";
+import { voltUtils as voltClientUtils } from "@tdxvolt/volt-client-web/js";
+
+const { publicKeyToPem, removeCarriageReturn, signBase64 } = voltClientUtils;
 
 const { filter, pick } = lodash;
 
@@ -174,7 +172,7 @@ export async function authenticateInternal(
 
     if (this._voltConfig.challenge_code) {
       authenticateRequest.challenge = signBase64(
-        keyPair.privateKey,
+        this._credential.cache.key,
         this._voltConfig.challenge_code
       );
     } else {
@@ -204,16 +202,18 @@ export async function authenticateInternal(
         // This is because the DID document is signed and the signature
         // is over the entire document.
         const didDocument = {
-          "@context": "https://www.w3.org/ns/did/v1",
+          "@context": [
+            "https://www.w3.org/ns/did/v1",
+            "https://tdxvolt.com/ns/did/v1"
+          ],
           authentication: [`${did}#key-1`],
           controller: did,
-          description: this._config.client_name,
           id: did,
           verificationMethod: [
             {
               id: `${did}#key-1`,
               publicKeyPem: publicKeyPem,
-              type: "Ed25519VerificationKey2018"
+              type: "Ed25519Signature2018"
             }
           ]
         };
@@ -224,7 +224,7 @@ export async function authenticateInternal(
         // Now sign the entire DID document, including the proof and set it in the
         // bind request. This is required by the Volt to verify that we have the private key for the DID.
         authenticateRequest.did_document_signature = signBase64(
-          keyPair.privateKey,
+          this._credential.cache.key,
           authenticateRequest.did_document
         );
 
@@ -262,7 +262,7 @@ export async function authenticateInternal(
 
     return decision === "POLICY_DECISION_PERMIT";
   } catch (err) {
-    log("failure binding to Volt [%s]", err.message);
+    log("failure authenticating with Volt [%s]", err.message);
     throw err;
   }
 }
@@ -278,15 +278,7 @@ export function connectInternal(helloPayload) {
       this._connected = false;
       this._session = null;
 
-      if (this._cachedClient) {
-        this._grpc.closeClient(this._cachedClient);
-        this._cachedClient = null;
-      }
-
-      if (this._cachedRemoteClient) {
-        this._grpc.closeClient(this._cachedRemoteClient);
-        this._cachedRemoteClient = null;
-      }
+      this.close();
     };
 
     this._voltConnection = new VoltConnection(this, this._grpc);
@@ -375,7 +367,7 @@ export function connectInternal(helloPayload) {
 
 export function getVoltAPIClientInternal() {
   if (!this._cachedClient) {
-    const serviceAddress = this.isRemote
+    const serviceAddress = this.isRelayed
       ? this._voltConfig.relay.address
       : this._voltConfig.address;
     log("creating cached VoltAPI service client on %s", serviceAddress);
@@ -390,7 +382,7 @@ export function getVoltAPIClientInternal() {
       serviceDescriptors,
       serviceAddress,
       this._credential,
-      this.isRemote && !this.isVoltRelay,
+      this.isRelayed,
       this._voltConfig?.relay?.cloud ? this._voltConfig.id : "",
       this._voltConfig?.relay?.cloud ? this._voltConfig.id : ""
     );
@@ -401,7 +393,7 @@ export function getVoltAPIClientInternal() {
 
 export function getAPIClientInternal(service) {
   if (!this._cachedService[service.id]) {
-    const serviceAddress = this.isRemote
+    const serviceAddress = this.isRelayed
       ? this._voltConfig.relay.address
       : service.service_description.host_address;
 
@@ -424,7 +416,7 @@ export function getAPIClientInternal(service) {
       serviceDescriptors,
       serviceAddress,
       this._credential,
-      this.isRemote && !this.isVoltRelay,
+      this.isRelayed,
       this._voltConfig?.relay?.cloud ? this._voltConfig.id : "",
       this._voltConfig?.relay?.cloud ? this._voltConfig.id : ""
     );
@@ -519,9 +511,9 @@ export async function fetchVoltConfig(discovery_url) {
   }
 }
 
-export async function fetchVoltConfigFromDID(volt_did) {
+async function fetchVoltConfigFromDIDInternal(volt_did, registryUrl) {
   try {
-    const didResolution = voltUtils.getDIDResolutionURL(volt_did);
+    const didResolution = voltUtils.getDIDResolutionURL(volt_did, registryUrl);
     if (!didResolution) {
       throw new Error(`Invalid Volt DID: ${volt_did}`);
     }
@@ -540,6 +532,8 @@ export async function fetchVoltConfigFromDID(volt_did) {
       );
     }
 
+    log("resolved DID from %s", didResolution);
+
     const serviceEndpoint = voltConfigServices[0].serviceEndpoint;
     return await fetchVoltConfig.call(this, serviceEndpoint);
   } catch (err) {
@@ -548,3 +542,22 @@ export async function fetchVoltConfigFromDID(volt_did) {
     );
   }
 }
+
+export async function fetchVoltConfigFromDID(
+  volt_did,
+  registryList = [constants.defaultDIDHostName]
+) {
+  for (let registryUrl of registryList) {
+    try {
+      return await fetchVoltConfigFromDIDInternal.call(
+        this,
+        volt_did,
+        registryUrl
+      );
+    } catch (err) {
+      log("Failed to fetch Volt config from %s: %s", registryUrl, err.message);
+    }
+  }
+
+  throw new Error("Failed to fetch Volt config from any registry");
+}

package/src/volt-client.js

@@ -31,7 +31,6 @@ export class VoltClient extends EventEmitter {
     }
     this._grpc = grpc;
     this._cachedClient = null;
-    this._cachedRemoteClient = null;
     this._session = null;
     this._config = null;
     this._voltConfig = null;
@@ -56,12 +55,36 @@ export class VoltClient extends EventEmitter {
     return this._voltConfig;
   }
 
+  get connection() {
+    return this._voltConnection;
+  }
+
+  close() {
+    if (this._cachedClient) {
+      this._grpc.closeClient(this._cachedClient);
+      this._cachedClient = null;
+    }
+
+    for (let serviceKey in Object.keys(this._cachedService)) {
+      if (this._cachedService[serviceKey]) {
+        this._grpc.closeClient(this._cachedService[serviceKey]);
+      }
+    }
+
+    this._cachedService = {};
+  }
+
   /**
    * 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
    */
-  async initialise(config, extras = {}) {
+  async initialise(
+    config,
+    extras = {},
+    ownDID = false,
+    didRegistryList = undefined
+  ) {
     try {
       if (!config) {
         throw new Error(
@@ -126,7 +149,15 @@ export class VoltClient extends EventEmitter {
       }
 
       if (voltDID) {
-        const didConfig = await fetchVoltConfigFromDID.call(this, 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) {
@@ -156,7 +187,7 @@ export class VoltClient extends EventEmitter {
 
       await this._credential.initialise();
 
-      if (!this.isRemote) {
+      if (!this.isRelayed) {
         // If we're not connecting via a Relay, we must have the address and CA.
         if (
           !this._voltConfig.address ||
@@ -179,7 +210,7 @@ export class VoltClient extends EventEmitter {
       } else {
         // No certificate present in the cache yet => we need to authenticate.
         try {
-          isBound = await authenticateInternal.call(this);
+          isBound = await authenticateInternal.call(this, false, ownDID);
         } catch (bindErr) {
           if (bindErr.message === "invalid arguments") {
             // This is usually the result of a missing challenge signature or credential.
@@ -196,7 +227,7 @@ export class VoltClient extends EventEmitter {
         throw new Error("Volt authentication failed");
       } else {
         // Perist the configuration.
-        this._config = this._credential.saveCache();
+        this._credential.saveCache();
       }
 
       return Promise.resolve(this._config);
@@ -247,7 +278,7 @@ export class VoltClient extends EventEmitter {
       });
     }
 
-    if (this.isRemote) {
+    if (this.isRelayed) {
       if (!this._voltConfig?.relay?.address) {
         throw new Error(
           "Remote connection enabled but no Relay address - have you called start()?"
@@ -274,14 +305,10 @@ export class VoltClient extends EventEmitter {
     }
   }
 
-  get isRemote() {
+  get isRelayed() {
     return !!(this._voltConfig?.relay && this._voltConfig.id);
   }
 
-  get isVoltRelay() {
-    return this.isRemote && !this._voltConfig?.relay.cloud;
-  }
-
   connect(helloPayload) {
     return connectInternal.call(this, helloPayload);
   }
@@ -613,6 +640,9 @@ export class VoltClient extends EventEmitter {
    */
   SqlExecuteJSON(request) {
     return new Promise((resolve, reject) => {
+      if (!request.start) {
+        request = { start: request };
+      }
       const call = this.SqlExecute(request);
 
       let header;

package/src/volt-connection.js

@@ -96,8 +96,18 @@ function _doConnect(connectHello) {
         break;
       }
       case "invoke_request": {
-        log("received invoke request");
-        this.emit("invoke_request", response.invoke_request);
+        log("received invoke request %s", response.invoke_request.invoke_id);
+        // Pause the call while we process the invoke request to avoid getting
+        // CANCELLED errors from grpc - we should perhaps leave this to the
+        // client to manage as it may be overkill in some cases.
+        this.call.pause();
+        try {
+          this.emit("invoke_request", response.invoke_request);
+        } catch (err) {
+          log("error processing invoke request [%s]", err.message);
+        } finally {
+          this.call.resume();
+        }
         break;
       }
       case "evt": {
@@ -169,6 +179,10 @@ export default class VoltConnection extends EventEmitter {
     this._helloPayload = undefined;
   }
 
+  get connectionId() {
+    return this._connectionId;
+  }
+
   connect(helloPayload, throwOnFail) {
     this._helloPayload = helloPayload;
     if (throwOnFail) {

package/src/volt-credential.js

@@ -2,14 +2,16 @@
 import debug from "debug";
 import fs from "fs";
 import { constants } from "./constants.js";
-import {
-  createKey,
-  fingerprintFromPublicKey,
+import { voltUtils as voltClientUtils } from "@tdxvolt/volt-client-web/js";
+
+const {
+  createSigningKey,
+  fingerprintFromPem,
   getIdentityToken,
   keyFromPem,
   privateKeyToPem,
   publicKeyToPem
-} from "@tdxvolt/volt-client-web";
+} = voltClientUtils;
 
 const log = debug("volt-client-grpc:volt-credential");
 
@@ -50,11 +52,11 @@ export class VoltCredential {
         this._cryptoCache.ca = this._voltConfig.ca_pem;
       }
 
-      // Extract Volt public key (used for encrypting Relay payloads).
+      // Extract Volt public key.
       this._voltPublicKey = this._voltConfig.public_key;
 
       const voltKey = keyFromPem(this._voltPublicKey).publicKey;
-      this._voltFingerprint = fingerprintFromPublicKey(voltKey);
+      this._voltFingerprint = fingerprintFromPem(voltKey);
     }
   }
 
@@ -90,6 +92,10 @@ export class VoltCredential {
     return this._voltFingerprint;
   }
 
+  get key() {
+    return this.getKey();
+  }
+
   getKey() {
     const key = keyFromPem(this._cryptoCache.key);
     return key;
@@ -105,7 +111,7 @@ export class VoltCredential {
       return Promise.resolve(this.getKey());
     } else {
       log("creating key");
-      this._cryptoCache.key = createKey();
+      this._cryptoCache.key = JSON.parse(createSigningKey()).private_pem;
       const key = keyFromPem(this._cryptoCache.key);
       log("successfully created key");
       return Promise.resolve(key);