@eluvio/elv-client-js 3.1.92 → 3.1.95

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eluvio/elv-client-js",
-  "version": "3.1.92",
+  "version": "3.1.95",
   "description": "Javascript client for the Eluvio Content Fabric",
   "main": "src/ElvClient.js",
   "author": "Kevin Talmadge",
@@ -57,6 +57,7 @@
   "dependencies": {
     "@babel/runtime": "^7.8.4",
     "@eluvio/crypto": ">=1.0.8",
+    "@eluvio/elv-abr-profile": "^0.2.0",
     "@sindresorhus/slugify": "^1.1.0",
     "babel-loader": "^8.0.6",
     "bignumber.js": "^8.0.2",

package/src/ElvClient.js

@@ -694,6 +694,67 @@ class ElvClient {
     return this.utils.FormatAddress(this.signer.address);
   }
 
+  /*
+    TOKEN                  211b  PREFIX + BODY | aplsjcJf1HYcDDUuCdXcSZtU86nYK162YmYJeuqwMczEBJVkD5D5EvsBvVwYDRsf4hzDvBWMoe9piBpqx...
+    PREFIX                   6b  aplsjc | apl=plain s=ES256K jc=json-compressed
+    BODY                   205b  base58(SIGNATURE + PAYLOAD)
+    SIGNATURE + PAYLOAD    151b  151b * 138 / 100 + 1 = 209b (>= 205b)
+    SIGNATURE               66b  ES256K_Di9Lu83mz4wMoehCEeQhKpJJ7ApmDZLumAa2Cge48F6EHYnbn8msATGGpjucScwimei1TWGd7aeyQY45AdXd5tT1Z
+    PAYLOAD                 85b  json-compressed
+    json                    79b  {"adr":"VVf4DQU357tDnZGYQeDrntRJ5rs=","spc":"ispc3ANoVSzNA3P6t7abLR69ho5YPPZU"}
+   */
+
+  /**
+   * Create a signed authorization token that can be used to authorize against the fabric
+   *
+   * @methodGroup Authorization
+   * @namedParams
+   * @param {number} duration=86400000 - Time until the token expires, in milliseconds (1 hour = 60 * 60 * 1000 = 3600000). Default is 24 hours.
+   * @param {Object=} spec - Additional attributes for this token
+   * @param {string=} address - Address of the signing account - if not specified, the current signer address will be used.
+   * @param {function=} Sign - If specified, this function will be used to produce the signature instead of the client's current signer
+   * @param {boolean=} addEthereumPrefix=true - If specified, the 'Ethereum Signed Message' prefixed hash format will be performed. Disable this if the provided Sign method already does this (e.g. Metamask)
+   */
+  async CreateFabricToken({
+    duration=24 * 60 * 60 * 1000,
+    spec={},
+    address,
+    Sign,
+    addEthereumPrefix=true,
+  }={}) {
+    address = address || this.CurrentAccountAddress();
+
+    let token = {
+      ...spec,
+      sub:`iusr${Utils.AddressToHash(address)}`,
+      adr: Buffer.from(address.replace(/^0x/, ""), "hex").toString("base64"),
+      spc: await this.ContentSpaceId(),
+      iat: Date.now(),
+      exp: Date.now() + duration,
+    };
+
+    if(!Sign) {
+      Sign = async message => this.authClient.Sign(message);
+    }
+
+    let message = `Eluvio Content Fabric Access Token 1.0\n${JSON.stringify(token)}`;
+
+    if(addEthereumPrefix) {
+      message = Ethers.utils.keccak256(Buffer.from(`\x19Ethereum Signed Message:\n${message.length}${message}`, "utf-8"));
+    }
+
+    const signature = await Sign(message);
+
+    const compressedToken = Pako.deflateRaw(Buffer.from(JSON.stringify(token), "utf-8"));
+    return `acspjc${this.utils.B58(
+      Buffer.concat([
+        Buffer.from(signature.replace(/^0x/, ""), "hex"),
+        Buffer.from(compressedToken)
+      ])
+    )}`;
+  }
+
+
   /**
    * Issue a self-signed authorization token
    *
@@ -705,7 +766,7 @@ class ElvClient {
    * @param {string=} policyId - The object ID of the policy for this token
    * @param {string=} subject - The subject of the token
    * @param {string} grantType=read - Permissions to grant for this token. Options: "access", "read", "create", "update", "read-crypt"
-   * @param {number} duration - Time until the token expires, in milliseconds (1 hour = 60 * 60 * 1000)
+   * @param {number} duration - Time until the token expires, in milliseconds (1 hour = 60 * 60 * 1000 = 3600000)
    * @param {boolean} allowDecryption=false - If specified, the re-encryption key will be included in the token,
    * enabling the user of this token to download encrypted content from the specified object
    * @param {Object=} context - Additional JSON context

package/src/RemoteSigner.js

@@ -85,24 +85,28 @@ class RemoteSigner extends Ethers.Signer {
    */
   async signDigest(digest) {
     if(!this.signatureCache[digest]) {
-      this.signatureCache[digest] = new Promise(async resolve => {
-        let signature = await Utils.ResponseToJson(
-          this.HttpClient.Request({
-            method: "POST",
-            path: UrlJoin("as", "wlt", "sign", "eth", this.id),
-            headers: {
-              Authorization: `Bearer ${this.authToken}`
-            },
-            body: {
-              hash: digest
-            }
-          })
-        );
-
-        signature.v = parseInt(signature.v, 16);
-        signature.recoveryParam = signature.v - 27;
-
-        resolve(signature);
+      this.signatureCache[digest] = new Promise(async (resolve, reject) => {
+        try {
+          let signature = await Utils.ResponseToJson(
+            this.HttpClient.Request({
+              method: "POST",
+              path: UrlJoin("as", "wlt", "sign", "eth", this.id),
+              headers: {
+                Authorization: `Bearer ${this.authToken}`
+              },
+              body: {
+                hash: digest
+              }
+            })
+          );
+
+          signature.v = parseInt(signature.v, 16);
+          signature.recoveryParam = signature.v - 27;
+
+          resolve(signature);
+        } catch(error) {
+          reject(error);
+        }
       });
     }
 

package/src/Utils.js

@@ -150,6 +150,125 @@ const Utils = {
     };
   },
 
+  /**
+   * Decode the specified write token into its component parts
+   *
+   * @param writeToken
+   *
+   * @returns {Object} - Components of the write token.
+   */
+  DecodeWriteToken: (writeToken) => {
+    /*
+    Format:
+    - content write token, LRO:
+      - prefix: "tq__", "tqw__", "tlro"
+      - format:
+        prefix + base58(uvarint(len(QID) | QID |
+                        uvarint(len(NID) | NID |
+                        uvarint(len(RAND_BYTES) | RAND_BYTES)
+    - content part write token:
+      - prefix: "tqp_"
+      - format:
+        prefix + base58(scheme | flags | uvarint(len(RAND_BYTES) | RAND_BYTES)
+    - content write token v1, content part write token v1:
+      - prefix: "tqw_", "tqpw"
+      - format:
+        prefix + base58(RAND_BYTES)
+     */
+
+    if(writeToken.length<4){
+      throw new Error(`Invalid write token: ["${writeToken}"] (unknown prefix)`);
+    }
+
+    let tokenType;
+
+    if(writeToken.startsWith("tqw__")) {
+      tokenType = "tq__";
+      writeToken = writeToken.slice(5);
+    } else {
+      tokenType = writeToken.slice(0, 4);
+      writeToken = writeToken.slice(4);
+    }
+    if(writeToken.length===0){
+      throw new Error(`Invalid write token: ["${writeToken}"] (too short)`);
+    }
+
+    switch(tokenType) {
+      case "tqw_":
+      case "tq__":
+      case "tqpw":
+      case "tqp_":
+      case "tlro":
+        break;
+      default:
+        throw new Error(`Invalid write token: ["${writeToken}"] (unknown prefix)`);
+    }
+
+    // decode base58 payload
+    let bytes = Utils.FromB58(writeToken);
+
+    function decodeBytes(isID, prefix) {
+      let bsize = VarInt.decode(bytes,0); // decode: count of bytes to read
+      let offset = VarInt.decode.bytes;   // offset in buffer to start read after decode
+      let theBytes;
+      let ret;
+
+      if(isID) {
+        theBytes = bytes.slice(offset+1, bsize+offset); // skip 1st byte (code id) at offset 0
+        if(theBytes.length===0){
+          ret = "";
+        } else {
+          ret = prefix + Utils.B58(theBytes);
+        }
+      } else {
+        theBytes = bytes.slice(offset, bsize+offset);
+        ret = "0x" + theBytes.toString("hex");
+      }
+      bytes = bytes.slice(bsize+offset);
+      return ret;
+    }
+
+    let tokenId;
+    let qid;
+    let nid;
+    let scheme;
+    let flags;
+
+    switch(tokenType) {
+      case "tqw_": // content write token v1
+      case "tqpw": // content part write token v1
+        tokenId = "0x" + bytes.toString("hex");
+        break;
+      case "tlro": // LRO,
+      case "tq__": // content write token
+        qid = decodeBytes(true, "iq__");
+        nid = decodeBytes(true, "inod");
+        tokenId = decodeBytes(false, "");
+        break;
+      case "tqp_": // content part write token
+        if(bytes.length<3) {
+          throw new Error(`Invalid write token: ["${writeToken}"] (token truncated)`);
+        }
+        scheme=bytes[0];
+        flags=bytes[1];
+        bytes = bytes.slice(2);
+        tokenId = decodeBytes(false, "");
+        break;
+      default:
+        // already raised
+        throw new Error(`Invalid write token: ["${writeToken}"] (unknown prefix)`);
+    }
+
+    return {
+      tokenType: tokenType,   // type of token
+      tokenId: tokenId,       // random bytes generated by the fabric node
+      objectId: qid,          // content id for content write token (tq__) or LRO (tlro)
+      nodeId: nid,            // node id where the content write token is valid (tq__)
+      scheme,                 // encryption scheme for part write token - (tqp_)
+      flags                   // flags for part write token (tqp_)
+    };
+  },
+
   /**
    * Convert contract address to multiformat hash
    *

package/src/client/ABRPublishing.js

@@ -478,7 +478,7 @@ exports.StartABRMezzanineJobs = async function({
     metadata: lroInfo
   });
 
-  await this.FinalizeContentObject({
+  const finalizeResponse = await this.FinalizeContentObject({
     libraryId,
     objectId,
     writeToken: statusDraft.write_token,
@@ -500,6 +500,7 @@ exports.StartABRMezzanineJobs = async function({
   });
 
   return {
+    hash: finalizeResponse.hash,
     lro_draft: lroInfo,
     writeToken: processingDraft.write_token,
     data,

package/src/client/NFT.js

@@ -18,9 +18,8 @@ const {
  * @methodGroup Minting
  * @namedParams
  * @param {string} tenantId - The ID of the tenant
- * @param {string=} email - The email of the NFT recipient
  * @param {string=} address - The address of the NFT recipient
- * @param {string} collectionId - The ID of the NFT collection containing the NFT
+ * @param {string} marketplaceId - The ID of the marketplace containing the NFT
  * @param {Array<Object>} items - List of items
  * @param {string} items.sku - SKU of the NFT
  * @param {number=} items.quantity=1 - Number to mint
@@ -30,66 +29,32 @@ const {
  *
  * @return Promise<Object> - An object containing the address for whom the NFT was minted and the transactionId of the minting request.
  */
-exports.MintNFT = async function({tenantId, email, address, collectionId, items, extraData={}}) {
+exports.MintNFT = async function({tenantId, address, marketplaceId, items, extraData={}}) {
   ValidatePresence("tenantId", tenantId);
-  ValidatePresence("email or address", email || address);
-  ValidatePresence("collectionId", collectionId);
+  ValidatePresence("address", address);
+  ValidatePresence("marketplaceId", marketplaceId);
   ValidatePresence("items", items);
 
-  ValidateObject(collectionId);
-
-  // If address not specified, make call to initialize address for email
-  let accountInitializationBody = { ts: Date.now() };
-  if(email) {
-    accountInitializationBody.email = email;
-  } else {
-    accountInitializationBody.addr = address;
-  }
-
-  const accountInitializationSignature = await this.Sign(
-    JSON.stringify(accountInitializationBody)
-  );
-
-  const {addr} = await this.utils.ResponseToJson(
-    await this.authClient.MakeAuthServiceRequest({
-      method: "POST",
-      path: `/as/tnt/prov/eth/${tenantId}`,
-      body: accountInitializationBody,
-      headers: {
-        "Authorization": `Bearer ${accountInitializationSignature}`
-      }
-    })
-  );
-
-  address = this.utils.FormatAddress(addr);
+  ValidateObject(marketplaceId);
+  ValidateAddress(address);
 
   let requestBody = {
-    "tickets": null,
-    "products": items.map(item => ({
+    tickets: null,
+    products: items.map(item => ({
       sku: item.sku,
       quant: item.quantity || 1,
       extra: item.tokenId ?
         { ...(item.extraData || {}), token_id: item.tokenId } :
         { ...(item.extraData || {}) }
     })),
-    "ident": email || address,
-    "cust_name": email || address,
-    "extra": {
-      ...extraData
+    ident: address,
+    cust_name: address,
+    extra: {
+      ...extraData,
+      elv_addr: address
     }
   };
 
-
-  ValidateAddress(address);
-
-  if(email) {
-    requestBody.email = email;
-  } else {
-    requestBody.addr = address;
-  }
-
-  requestBody.extra.elv_addr = address;
-
   const transactionId = this.utils.B58(UUID.parse(UUID.v4()));
   requestBody.ts = Date.now();
   requestBody.trans_id = transactionId;
@@ -100,7 +65,7 @@ exports.MintNFT = async function({tenantId, email, address, collectionId, items,
 
   await this.authClient.MakeAuthServiceRequest({
     method: "POST",
-    path: `/as/otp/webhook/base/${tenantId}/${collectionId}`,
+    path: UrlJoin("/as/tnt/trans/base", tenantId, marketplaceId),
     body: requestBody,
     headers: {
       "Authorization": `Bearer ${mintSignature}`

package/testScripts/Test.js

@@ -13,25 +13,6 @@ const Test = async () => {
     });
 
     client.SetSigner({signer});
-
-
-    const ethUrl = "https://host-216-66-40-19.contentfabric.io/eth";
-    const asUrl = "https://host-66-220-3-86.contentfabric.io";
-
-    client.SetNodes({
-      ethereumURIs: [
-        ethUrl
-      ],
-      authServiceURIs: [
-        asUrl
-      ]
-    });
-
-    console.log(
-      await client.ContentObjectTenantId({
-        objectId: "iq__3PXRZX5NCzPQsfTEquCctB2K3KJh"
-      })
-    )
   } catch(error) {
     console.error(error);
     console.error(JSON.stringify(error, null, 2));

package/testScripts/VariantABRProfile.js

@@ -0,0 +1,45 @@
+/* eslint-disable no-console */
+
+
+const ScriptVariant = require("./parentClasses/ScriptVariant");
+const ABR = require("@eluvio/elv-abr-profile");
+
+class VariantABRProfile extends ScriptVariant {
+
+  async body() {
+    const client = await this.client();
+
+    const libraryId = this.args.libraryId;
+    const objectId = this.args.objectId;
+
+    // get media info from production master
+    const masterMetadata = await client.ContentObjectMetadata({
+      libraryId,
+      objectId,
+      metadataSubtree: "/production_master"
+    });
+
+    // adapt ABR Profile to production master's video properties
+    const generatedProfile = ABR.ABRProfileForVariant(
+      masterMetadata.sources,
+      masterMetadata.variants.default
+    );
+
+    if(!generatedProfile.ok) {
+      console.error("Error generating ABR Profile:\n" + generatedProfile.errors.join("\n"));
+    } else {
+      console.log(JSON.stringify(generatedProfile.result, null, 2));
+    }
+  }
+
+  header() {
+    return `Generate ABR Profile for production master ${this.args.objectId}, default variant`;
+  }
+
+  options() {
+    return super.options();
+  }
+}
+
+const script = new VariantABRProfile;
+script.run();