@eluvio/elv-client-js 4.2.27 → 4.2.30

package/src/ElvClient.js

@@ -936,6 +936,57 @@ class ElvClient {
     json                    79b  {"adr":"VVf4DQU357tDnZGYQeDrntRJ5rs=","spc":"ispc3ANoVSzNA3P6t7abLR69ho5YPPZU"}
    */
 
+  /*
+    PLAIN TOKEN  PREFIX + BODY | aplsjcJf1HYcDDUuCdXcSZtU86nYK162YmYJeuqwMczEBJVkD5D5EvsBvVwYDRsf4hzDvBWMoe9piBpqx...
+    PREFIX       6b  aplsjc | apl=plain s=ES256K jc=json-compressed
+    BODY             base58(SIGNATURE + PAYLOAD)
+    SIGNATURE   65b  ES256K signature
+    PAYLOAD          raw-deflate JSON
+    json             {"adr":"VVf4DQU357tDnZGYQeDrntRJ5rs=","spc":"ispc3ANoVSzNA3P6t7abLR69ho5YPPZU"}
+   */
+
+  /**
+   * Create a signed "plain" authorization token (`aplsjc...`).
+   *
+   * Plain tokens are largely the same as client-signed access tokens - they do not contain a b/c transaction
+   * and authorization is determined from the rights of the current signer's address.
+   * Currently needed for tenant content query /tenant/:tid/q/query
+   * This token will be deprecated in the future in favor of client-signed access tokens.
+   *
+   * @methodGroup Authorization
+   * @namedParams
+   * @param {string=} libraryId - Optional library ID to scope the token. If omitted, the token is space-wide.
+   * @returns {Promise<string>} - The signed Plain auth token
+   */
+  async CreatePlainToken({libraryId}={}) {
+    const address = this.CurrentAccountAddress();
+    if(!address) {
+      throw Error("Unable to create plain token: No signer is configured");
+    }
+
+    const token = {
+      adr: Buffer.from(address.replace(/^0x/, ""), "hex").toString("base64"),
+      spc: await this.ContentSpaceId()
+    };
+
+    if(libraryId) {
+      token.lib = libraryId;
+    }
+
+    const compressedToken = Pako.deflateRaw(Buffer.from(JSON.stringify(token), "utf-8"));
+    const signature = await this.authClient.Sign(Ethers.utils.keccak256(compressedToken));
+    const signatureBytes = Buffer.from(signature.replace(/^0x/, ""), "hex");
+
+    if(signatureBytes.length !== 65) {
+      throw Error("Unable to create plain token: Expected a 65-byte ES256K signature");
+    }
+
+    return `aplsjc${this.utils.B58(Buffer.concat([
+      signatureBytes,
+      Buffer.from(compressedToken)
+    ]))}`;
+  }
+
   async PersonalSign({
     message,
     addEthereumPrefix,

package/src/EthClient.js

@@ -309,6 +309,7 @@ class EthClient {
     methodName,
     methodArgs,
     value,
+    overrides={},
     timeout,
     formatArguments=true,
     cacheContract=true,
@@ -319,7 +320,6 @@ class EthClient {
     if(!abi) { abi = await this.client.ContractAbi({contractAddress}); }
 
     const contract = this.Contract({contractAddress, abi, cacheContract, overrideCachedContract});
-
     // Make method call
     const createMethodCall = await this.CallContractMethod({
       contract,
@@ -327,6 +327,7 @@ class EthClient {
       methodName,
       methodArgs,
       value,
+      overrides,
       formatArguments,
       cacheContract
     });

package/src/FrameClient.js

@@ -375,6 +375,7 @@ class FrameClient {
       "CreateNTPInstance",
       "CreateNonOwnerCap",
       "CreatePart",
+      "CreatePlainToken",
       "CreateProductionMaster",
       "CreateShare",
       "CreateSignedMessageJSON",

package/src/client/ContentAccess.js

@@ -9,6 +9,7 @@ const objectPath = require("object-path");
 
 const HttpClient = require("../HttpClient");
 const ContentObjectAudit = require("../ContentObjectAudit");
+const bs58 = require("bs58");
 
 const {
   ValidateLibrary,
@@ -17,6 +18,7 @@ const {
   ValidatePartHash,
   ValidateWriteToken,
   ValidateParameters,
+  ValidatePresence,
 } = require("../Validation");
 
 const MergeWith = require("lodash/mergeWith");
@@ -2713,7 +2715,6 @@ exports.LinkData = async function({libraryId, objectId, versionHash, writeToken,
   );
 };
 
-
 /* Encryption */
 
 exports.CreateEncryptionConk = async function({libraryId, objectId, versionHash, writeToken, createKMSConk=true}) {
@@ -2793,6 +2794,74 @@ exports.CreateEncryptionConk = async function({libraryId, objectId, versionHash,
   return this.encryptionConks[objectId];
 };
 
+/**
+ * Encrypt the owner encryption key using the new user details provided
+ *
+ * @methodGroup Encryption
+ * @namedParams
+ * @param {string=} libraryId - ID of a library
+ * @param {string=} objectId - ID of an object
+ * @param {string=} versionHash - Hash of an object version
+ * @param {string=} writeToken - The write token for the object
+ * @param {Object=} newEncodedUserPublicKey - raw public key or base-58 encoded publicKey of the new user prefixed 'kupk'
+ */
+exports.MigrateEncryptionConkForUserProvided = async function({libraryId, objectId, versionHash, writeToken, newEncodedUserPublicKey}) {
+  if(this.signer.remoteSigner) {
+    return;
+  }
+
+  ValidateParameters({libraryId, objectId, versionHash});
+  ValidateWriteToken(writeToken);
+
+  if(!objectId) {
+    objectId = this.utils.DecodeVersionHash(versionHash).objectId;
+  }
+
+  ValidatePresence("newEncodedUserPublicKey", newEncodedUserPublicKey);
+
+  let publicKey;
+  if(!newEncodedUserPublicKey.startsWith("kupk")){
+    publicKey = newEncodedUserPublicKey;
+  } else {
+    const publicKeyBytes = bs58.decode(newEncodedUserPublicKey.slice(4));
+    if(publicKeyBytes.length !== 65) {
+      publicKey = "0x" + Buffer.concat([Buffer.from([0x04]), publicKeyBytes]).toString("hex");
+    } else {
+      publicKey = "0x" + publicKeyBytes.toString("hex");
+    }
+  }
+
+  // Decrypt using existing user key
+  const existingCapKey = `eluv.caps.iusr${this.utils.AddressToHash(this.signer.address)}`;
+  const existingUserCap =
+    await this.ContentObjectMetadata({
+      libraryId,
+      objectId,
+      writeToken,
+      metadataSubtree: existingCapKey
+    });
+
+  if(!existingUserCap) {
+    throw (`No encryption conk present for ${objectId} for user ${this.signer.address}`);
+  }
+
+  this.encryptionConks[objectId] = await this.Crypto.DecryptCap(existingUserCap, this.signer._signingKey().privateKey);
+
+  // Encrypt with the new key
+  const encryptedConk = await this.Crypto.EncryptConk(this.encryptionConks[objectId], publicKey);
+  const newUserCap = `eluv.caps.iusr${this.utils.AddressToHash(this.utils.PublicKeyToAddress(publicKey))}`;
+
+  await this.ReplaceMetadata({
+    libraryId,
+    objectId,
+    writeToken,
+    metadataSubtree: newUserCap,
+    metadata: encryptedConk
+  });
+
+  return this.encryptionConks[objectId];
+};
+
 /**
  * Retrieve the encryption conk for the specified object. If one has not yet been created
  * and a writeToken has been specified, this method will create a new conk and