@eluvio/elv-client-js 3.1.73 → 3.1.77

package/dist/src/client/Files.js

@@ -1094,6 +1094,8 @@ exports.DownloadFile = function _callee12(_ref13) {
       encryption,
       path,
       headers,
+      ownerCapKey,
+      ownerCap,
       bytesTotal,
       _args14 = arguments;
 
@@ -1139,33 +1141,53 @@ exports.DownloadFile = function _callee12(_ref13) {
           headers = _context14.sent;
           headers.Accept = "*/*"; // If not owner, indicate re-encryption
 
-          _context14.t0 = encrypted;
+          ownerCapKey = "eluv.caps.iusr".concat(this.utils.AddressToHash(this.signer.address));
+          _context14.next = 17;
+          return _regeneratorRuntime.awrap(this.ContentObjectMetadata({
+            libraryId: libraryId,
+            objectId: objectId,
+            metadataSubtree: ownerCapKey
+          }));
 
-          if (!_context14.t0) {
-            _context14.next = 22;
+        case 17:
+          ownerCap = _context14.sent;
+          _context14.t1 = encrypted;
+
+          if (!_context14.t1) {
+            _context14.next = 26;
             break;
           }
 
-          _context14.t1 = this.utils;
-          _context14.t2 = this.signer.address;
-          _context14.next = 20;
+          _context14.t2 = this.utils;
+          _context14.t3 = this.signer.address;
+          _context14.next = 24;
           return _regeneratorRuntime.awrap(this.ContentObjectOwner({
             objectId: objectId
           }));
 
-        case 20:
-          _context14.t3 = _context14.sent;
-          _context14.t0 = !_context14.t1.EqualAddress.call(_context14.t1, _context14.t2, _context14.t3);
+        case 24:
+          _context14.t4 = _context14.sent;
+          _context14.t1 = !_context14.t2.EqualAddress.call(_context14.t2, _context14.t3, _context14.t4);
+
+        case 26:
+          _context14.t0 = _context14.t1;
 
-        case 22:
           if (!_context14.t0) {
-            _context14.next = 24;
+            _context14.next = 29;
+            break;
+          }
+
+          _context14.t0 = !ownerCap;
+
+        case 29:
+          if (!_context14.t0) {
+            _context14.next = 31;
             break;
           }
 
           headers["X-Content-Fabric-Decryption-Mode"] = "reencrypt";
 
-        case 24:
+        case 31:
           // If using server side decryption, specify in header
           if (encrypted && !clientSideDecryption) {
             headers["X-Content-Fabric-Decryption-Mode"] = "decrypt"; // rep/files_download endpoint doesn't currently support Range header
@@ -1176,13 +1198,13 @@ exports.DownloadFile = function _callee12(_ref13) {
           bytesTotal = fileInfo["."].size;
 
           if (!(encrypted && clientSideDecryption)) {
-            _context14.next = 46;
+            _context14.next = 53;
             break;
           }
 
-          _context14.t4 = _regeneratorRuntime;
-          _context14.t5 = this;
-          _context14.next = 31;
+          _context14.t5 = _regeneratorRuntime;
+          _context14.t6 = this;
+          _context14.next = 38;
           return _regeneratorRuntime.awrap(this.EncryptionConk({
             libraryId: libraryId,
             objectId: objectId,
@@ -1190,39 +1212,39 @@ exports.DownloadFile = function _callee12(_ref13) {
             download: true
           }));
 
-        case 31:
-          _context14.t6 = _context14.sent;
-          _context14.t7 = path;
-          _context14.t8 = bytesTotal;
-          _context14.t9 = headers;
-          _context14.t10 = callback;
-          _context14.t11 = format;
-          _context14.t12 = clientSideDecryption;
-          _context14.t13 = chunked;
-          _context14.t14 = {
-            conk: _context14.t6,
-            downloadPath: _context14.t7,
-            bytesTotal: _context14.t8,
-            headers: _context14.t9,
-            callback: _context14.t10,
-            format: _context14.t11,
-            clientSideDecryption: _context14.t12,
-            chunked: _context14.t13
+        case 38:
+          _context14.t7 = _context14.sent;
+          _context14.t8 = path;
+          _context14.t9 = bytesTotal;
+          _context14.t10 = headers;
+          _context14.t11 = callback;
+          _context14.t12 = format;
+          _context14.t13 = clientSideDecryption;
+          _context14.t14 = chunked;
+          _context14.t15 = {
+            conk: _context14.t7,
+            downloadPath: _context14.t8,
+            bytesTotal: _context14.t9,
+            headers: _context14.t10,
+            callback: _context14.t11,
+            format: _context14.t12,
+            clientSideDecryption: _context14.t13,
+            chunked: _context14.t14
           };
-          _context14.t15 = _context14.t5.DownloadEncrypted.call(_context14.t5, _context14.t14);
-          _context14.next = 43;
-          return _context14.t4.awrap.call(_context14.t4, _context14.t15);
+          _context14.t16 = _context14.t6.DownloadEncrypted.call(_context14.t6, _context14.t15);
+          _context14.next = 50;
+          return _context14.t5.awrap.call(_context14.t5, _context14.t16);
 
-        case 43:
+        case 50:
           return _context14.abrupt("return", _context14.sent);
 
-        case 46:
+        case 53:
           if (!chunkSize) {
             chunkSize = 10000000;
           }
 
-          _context14.prev = 47;
-          _context14.next = 50;
+          _context14.prev = 54;
+          _context14.next = 57;
           return _regeneratorRuntime.awrap(this.Download({
             downloadPath: path,
             bytesTotal: bytesTotal,
@@ -1233,15 +1255,15 @@ exports.DownloadFile = function _callee12(_ref13) {
             chunkSize: chunkSize
           }));
 
-        case 50:
+        case 57:
           return _context14.abrupt("return", _context14.sent);
 
-        case 53:
-          _context14.prev = 53;
-          _context14.t16 = _context14["catch"](47);
+        case 60:
+          _context14.prev = 60;
+          _context14.t17 = _context14["catch"](54);
 
           if (!(encrypted && !clientSideDecryption)) {
-            _context14.next = 57;
+            _context14.next = 64;
             break;
           }
 
@@ -1249,15 +1271,15 @@ exports.DownloadFile = function _callee12(_ref13) {
             clientSideDecryption: true
           })));
 
-        case 57:
-          throw _context14.t16;
+        case 64:
+          throw _context14.t17;
 
-        case 58:
+        case 65:
         case "end":
           return _context14.stop();
       }
     }
-  }, null, this, [[47, 53]]);
+  }, null, this, [[54, 60]]);
 };
 /* Parts */
 

package/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@eluvio/elv-client-js",
-  "version": "3.1.73",
+  "version": "3.1.77",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eluvio/elv-client-js",
-  "version": "3.1.73",
+  "version": "3.1.77",
   "description": "Javascript client for the Eluvio Content Fabric",
   "main": "src/ElvClient.js",
   "author": "Kevin Talmadge",

package/src/AuthorizationClient.js

@@ -176,7 +176,10 @@ class AuthorizationClient {
     let publicKey;
     if(encryption && encryption !== "none" && objectId && await this.AccessType(objectId) === ACCESS_TYPES.OBJECT) {
       const owner = await this.Owner({id: objectId});
-      if(!Utils.EqualAddress(owner, this.client.signer.address)) {
+      const ownerCapKey = `eluv.caps.iusr${Utils.AddressToHash(this.client.signer.address)}`;
+      const ownerCap = await client.ContentObjectMetadata({libraryId, objectId, metadataSubtree: ownerCapKey});
+
+      if(!Utils.EqualAddress(owner, this.client.signer.address) && !ownerCap) {
         const cap = await this.ReEncryptionConk({libraryId, objectId});
         publicKey = cap.public_key;
       }

package/src/EthClient.js

@@ -285,6 +285,8 @@ class EthClient {
             const latestBlock = await this.MakeProviderCall({methodName: "getBlock", args: ["latest"]});
             overrides.gasLimit = latestBlock.gasLimit;
             overrides.gasPrice = overrides.gasPrice ? overrides.gasPrice * 1.50 : 8000000000;
+          } else if(error.code === "NONCE_EXPIRED" && error.reason === "nonce has already been used") {
+            this.Log(`Retrying method call ${methodName}`);
           } else if(!(error.message || error).includes("invalid response")) {
             this.Log(typeof error === "object" ? JSON.stringify(error, null, 2) : error, true);
             throw error;

package/src/FrameClient.js

@@ -329,6 +329,7 @@ class FrameClient {
       "CreateFileUploadJob",
       "CreateLinks",
       "CreateNTPInstance",
+      "CreateNonOwnerCap",
       "CreatePart",
       "CreateProductionMaster",
       "CreateSignedToken",

package/src/client/ABRPublishing.js

@@ -6,6 +6,7 @@
  * @module ElvClient/ABRPublishing
  */
 
+const R = require("ramda");
 const UrlJoin = require("url-join");
 const HttpClient = require("../HttpClient");
 
@@ -355,8 +356,6 @@ exports.CreateABRMezzanine = async function({
     ...metadata.public.asset_metadata
   };
 
-  metadata.elv_created_at = new Date().getTime();
-
   if(name || !existingMez) {
     metadata.name = name || `${masterName} Mezzanine`;
     metadata.public.name = name || `${masterName} Mezzanine`;
@@ -367,7 +366,23 @@ exports.CreateABRMezzanine = async function({
     metadata.public.description = description || "";
   }
 
-  await this.MergeMetadata({
+  // retrieve existing metadata to merge with updated metadata
+  const existingMetadata = await this.ContentObjectMetadata({
+    libraryId,
+    objectId: id,
+    writeToken: write_token,
+  });
+  // newer metadata values replace existing metadata, unless both new and old values are objects,
+  // in which case their keys are merged recursively
+  metadata = R.mergeDeepRight(existingMetadata, metadata);
+
+  if(!existingMez) {
+    // set creation date
+    metadata.elv_created_at = new Date().getTime();
+  }
+
+  // write metadata to mezzanine object
+  await this.ReplaceMetadata({
     libraryId,
     objectId: id,
     writeToken: write_token,

package/src/client/ContentAccess.js

@@ -473,9 +473,8 @@ exports.LibraryContentTypes = async function({libraryId}) {
  * @param {object=} filterOptions - Pagination, sorting and filtering options
  * @param {number=} filterOptions.start - Start index for pagination
  * @param {number=} filterOptions.limit - Max number of objects to return
- * @param {string=} filterOptions.cacheId - Cache ID corresponding a previous query
  * @param {(Array<string> | string)=} filterOptions.sort - Sort by the specified key(s)
- * @param {boolean=} filterOptions.sortDesc=false - Sort in descending order
+ * @param {boolean=} filterOptions.sortDesc - Sort in descending order
  * @param {(Array<string> | string)=} filterOptions.select - Include only the specified metadata keys (all must start with /public)
  * @param {(Array<object> | object)=} filterOptions.filter - Filter objects by metadata
  * @param {string=} filterOptions.filter.key - Key to filter on (must start with /public)
@@ -2408,7 +2407,10 @@ exports.EncryptionConk = async function({libraryId, objectId, versionHash, write
 
   const owner = await this.authClient.Owner({id: objectId});
 
-  if(!this.utils.EqualAddress(owner, this.signer.address)) {
+  const ownerCapKey = `eluv.caps.iusr${this.utils.AddressToHash(this.signer.address)}`;
+  const ownerCap = await this.ContentObjectMetadata({libraryId, objectId, metadataSubtree: ownerCapKey});
+
+  if(!this.utils.EqualAddress(owner, this.signer.address) && !ownerCap) {
     if(download) {
       return await this.authClient.ReEncryptionConk({libraryId, objectId, versionHash});
     } else {

package/src/client/ContentManagement.js

@@ -21,7 +21,8 @@ const {
   ValidateVersion,
   ValidateWriteToken,
   ValidateParameters,
-  ValidatePresence
+  ValidatePresence,
+  ValidateAddress
 } = require("../Validation");
 
 exports.SetVisibility = async function({id, visibility}) {
@@ -58,8 +59,9 @@ exports.SetVisibility = async function({id, visibility}) {
  * @methodGroup Content Objects
  * @param {string} objectId - The ID of the object
  * @param {string} permission - The key for the permission to set - See client.permissionLevels for available permissions
+ * @param {string} writeToken - Write token for the content object - If specified, info will be retrieved from the write draft instead of creating a new draft and finalizing
  */
-exports.SetPermission = async function({objectId, permission}) {
+exports.SetPermission = async function({objectId, permission, writeToken}) {
   ValidateObject(objectId);
   ValidatePresence("permission", permission);
 
@@ -118,14 +120,16 @@ exports.SetPermission = async function({objectId, permission}) {
       }
     });
   } else if(!kmsConk && settings.kmsConk) {
-    await this.EditAndFinalizeContentObject({
-      libraryId,
-      objectId,
-      commitMessage: "Add encryption conk",
-      callback: async ({writeToken}) => {
-        await this.CreateEncryptionConk({libraryId, objectId, writeToken, createKMSConk: true});
-      }
-    });
+    const finalize = !writeToken;
+    if(!writeToken) {
+      writeToken = (await this.EditContentObject({libraryId, objectId})).writeToken;
+    }
+
+    await this.CreateEncryptionConk({libraryId, objectId, writeToken, createKMSConk: true});
+
+    if(finalize) {
+      await this.FinalizeContentObject({libraryId, objectId, writeToken, commitMessage: `Set permissions to ${permission}`});
+    }
   }
 };
 
@@ -622,7 +626,100 @@ exports.CopyContentObject = async function({libraryId, originalVersionHash, opti
 
   options.copy_from = originalVersionHash;
 
-  return await this.CreateContentObject({libraryId, options});
+  const {objectId, writeToken} = await this.CreateContentObject({libraryId, options});
+  const originalObjectId = this.utils.DecodeVersionHash(originalVersionHash).objectId;
+  const metadata = await this.ContentObjectMetadata({versionHash: originalVersionHash});
+  const permission = await this.Permission({objectId: originalObjectId});
+
+  // User CAP
+  const userCapKey = `eluv.caps.iusr${this.utils.AddressToHash(this.signer.address)}`;
+
+  if(metadata[userCapKey]) {
+    const isOwner = this.utils.EqualAddress(this.signer.address, await this.ContentObjectOwner({objectId: originalObjectId}));
+
+    if(!isOwner) {
+      throw Error(`Current user is not owner of object ${metadata}`);
+    }
+
+    const userConkKey = await this.Crypto.DecryptCap(metadata[userCapKey], this.signer.signingKey.privateKey);
+    userConkKey.qid = objectId;
+
+    this.ReplaceMetadata({
+      libraryId,
+      objectId,
+      writeToken,
+      metadataSubtree: userCapKey,
+      metadata: await this.Crypto.EncryptConk(userConkKey, this.signer.signingKey.publicKey)
+    });
+  }
+
+  // KMS CAP
+  await Promise.all(
+    Object.keys(metadata)
+      .filter(key => key.startsWith("eluv.caps.ikms"))
+      .map(async kmsCapKey => await this.DeleteMetadata({
+        libraryId,
+        objectId,
+        writeToken,
+        metadataSubtree: kmsCapKey
+      }))
+  );
+
+  if(permission !== "owner") {
+    await this.SetPermission({objectId, permission, writeToken});
+  }
+
+  return await this.FinalizeContentObject({libraryId, objectId, writeToken});
+};
+
+/**
+ * Create a non-owner cap key using the specified public key and address
+ *
+ * @methodGroup Access Requests
+ * @namedParams
+ * @param {string} libraryId - ID of the library
+ * @param {string} objectId - ID of the object
+ * @param {string} publicKey - Public key for the target cap
+ * @param {string} publicAddress - Public address for the target cap key
+ * @param {string} writeToken - Write token for the content object - If specified, info will be retrieved from the write draft instead of creating a new draft and finalizing
+ *
+ * @returns {Promise<Object>}
+ */
+exports.CreateNonOwnerCap = async function({objectId, libraryId, publicKey, publicAddress, writeToken}) {
+  publicAddress = ValidateAddress(publicAddress);
+  const userCapKey = `eluv.caps.iusr${this.utils.AddressToHash(this.signer.address)}`;
+  const userCapValue = await this.ContentObjectMetadata({objectId, libraryId, metadataSubtree: userCapKey});
+
+  if(!userCapValue) {
+    throw Error("No user cap found for current user");
+  }
+
+  const userConk = await this.Crypto.DecryptCap(userCapValue, this.signer.signingKey.privateKey);
+
+  const targetUserCapKey = `eluv.caps.iusr${this.utils.AddressToHash(publicAddress)}`;
+  const targetUserCapValue = await this.Crypto.EncryptConk(userConk, publicKey);
+
+  const finalize = !writeToken;
+  if(!writeToken) {
+    writeToken = await this.EditContentObject({libraryId, objectId}).writeToken;
+  }
+
+  this.ReplaceMetadata({
+    libraryId,
+    objectId,
+    writeToken,
+    metadataSubtree: targetUserCapKey,
+    metadata: targetUserCapValue
+  });
+
+  if(finalize) {
+    await this.FinalizeContentObject({
+      libraryId,
+      objectId,
+      writeToken,
+      commitMessage: "Create non-owner cap"
+    });
+  }
 };
 
 /**

package/src/client/Files.js

@@ -641,7 +641,10 @@ exports.DownloadFile = async function({
   headers.Accept = "*/*";
 
   // If not owner, indicate re-encryption
-  if(encrypted && !this.utils.EqualAddress(this.signer.address, await this.ContentObjectOwner({objectId}))) {
+  const ownerCapKey = `eluv.caps.iusr${this.utils.AddressToHash(this.signer.address)}`;
+  const ownerCap = await this.ContentObjectMetadata({libraryId, objectId, metadataSubtree: ownerCapKey});
+
+  if(encrypted && !this.utils.EqualAddress(this.signer.address, await this.ContentObjectOwner({objectId})) && !ownerCap) {
     headers["X-Content-Fabric-Decryption-Mode"] = "reencrypt";
   }