@eluvio/elv-client-js 3.1.90 → 3.1.93

package/dist/src/client/NFT.js

@@ -25,9 +25,8 @@ var _require = require("../Validation"),
  * @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
@@ -40,59 +39,22 @@ var _require = require("../Validation"),
 
 
 exports.MintNFT = function _callee(_ref) {
-  var tenantId, email, address, collectionId, items, _ref$extraData, extraData, accountInitializationBody, accountInitializationSignature, _ref2, addr, requestBody, transactionId, mintSignature;
+  var tenantId, address, marketplaceId, items, _ref$extraData, extraData, requestBody, transactionId, mintSignature;
 
   return _regeneratorRuntime.async(function _callee$(_context) {
     while (1) {
       switch (_context.prev = _context.next) {
         case 0:
-          tenantId = _ref.tenantId, email = _ref.email, address = _ref.address, collectionId = _ref.collectionId, items = _ref.items, _ref$extraData = _ref.extraData, extraData = _ref$extraData === void 0 ? {} : _ref$extraData;
+          tenantId = _ref.tenantId, address = _ref.address, marketplaceId = _ref.marketplaceId, items = _ref.items, _ref$extraData = _ref.extraData, extraData = _ref$extraData === void 0 ? {} : _ref$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
-
-          accountInitializationBody = {
-            ts: Date.now()
-          };
-
-          if (email) {
-            accountInitializationBody.email = email;
-          } else {
-            accountInitializationBody.addr = address;
-          }
-
-          _context.next = 10;
-          return _regeneratorRuntime.awrap(this.Sign(JSON.stringify(accountInitializationBody)));
-
-        case 10:
-          accountInitializationSignature = _context.sent;
-          _context.t0 = _regeneratorRuntime;
-          _context.t1 = this.utils;
-          _context.next = 15;
-          return _regeneratorRuntime.awrap(this.authClient.MakeAuthServiceRequest({
-            method: "POST",
-            path: "/as/tnt/prov/eth/".concat(tenantId),
-            body: accountInitializationBody,
-            headers: {
-              "Authorization": "Bearer ".concat(accountInitializationSignature)
-            }
-          }));
-
-        case 15:
-          _context.t2 = _context.sent;
-          _context.t3 = _context.t1.ResponseToJson.call(_context.t1, _context.t2);
-          _context.next = 19;
-          return _context.t0.awrap.call(_context.t0, _context.t3);
-
-        case 19:
-          _ref2 = _context.sent;
-          addr = _ref2.addr;
-          address = this.utils.FormatAddress(addr);
+          ValidateObject(marketplaceId);
+          ValidateAddress(address);
           requestBody = {
-            "tickets": null,
-            "products": items.map(function (item) {
+            tickets: null,
+            products: items.map(function (item) {
               return {
                 sku: item.sku,
                 quant: item.quantity || 1,
@@ -101,44 +63,37 @@ exports.MintNFT = function _callee(_ref) {
                 }) : _objectSpread({}, item.extraData || {})
               };
             }),
-            "ident": email || address,
-            "cust_name": email || address,
-            "extra": _objectSpread({}, extraData)
+            ident: address,
+            cust_name: address,
+            extra: _objectSpread({}, extraData, {
+              elv_addr: address
+            })
           };
-          ValidateAddress(address);
-
-          if (email) {
-            requestBody.email = email;
-          } else {
-            requestBody.addr = address;
-          }
-
-          requestBody.extra.elv_addr = address;
           transactionId = this.utils.B58(UUID.parse(UUID.v4()));
           requestBody.ts = Date.now();
           requestBody.trans_id = transactionId;
-          _context.next = 31;
+          _context.next = 13;
           return _regeneratorRuntime.awrap(this.Sign(JSON.stringify(requestBody)));
 
-        case 31:
+        case 13:
           mintSignature = _context.sent;
-          _context.next = 34;
+          _context.next = 16;
           return _regeneratorRuntime.awrap(this.authClient.MakeAuthServiceRequest({
             method: "POST",
-            path: "/as/otp/webhook/base/".concat(tenantId, "/").concat(collectionId),
+            path: UrlJoin("/as/tnt/trans/base", tenantId, marketplaceId),
             body: requestBody,
             headers: {
               "Authorization": "Bearer ".concat(mintSignature)
             }
           }));
 
-        case 34:
+        case 16:
           return _context.abrupt("return", {
             address: address,
             transactionId: transactionId
           });
 
-        case 35:
+        case 17:
         case "end":
           return _context.stop();
       }
@@ -163,14 +118,14 @@ exports.MintNFT = function _callee(_ref) {
  */
 
 
-exports.CollectionTransactions = function _callee2(_ref3) {
-  var tenantId, collectionId, _ref3$filterOptions, filterOptions, ts, queryParams, allowedOptions, path, signature;
+exports.CollectionTransactions = function _callee2(_ref2) {
+  var tenantId, collectionId, _ref2$filterOptions, filterOptions, ts, queryParams, allowedOptions, path, signature;
 
   return _regeneratorRuntime.async(function _callee2$(_context2) {
     while (1) {
       switch (_context2.prev = _context2.next) {
         case 0:
-          tenantId = _ref3.tenantId, collectionId = _ref3.collectionId, _ref3$filterOptions = _ref3.filterOptions, filterOptions = _ref3$filterOptions === void 0 ? {} : _ref3$filterOptions;
+          tenantId = _ref2.tenantId, collectionId = _ref2.collectionId, _ref2$filterOptions = _ref2.filterOptions, filterOptions = _ref2$filterOptions === void 0 ? {} : _ref2$filterOptions;
           ts = Date.now();
           queryParams = {
             ts: ts

package/package-lock.json

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

package/package.json

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

package/src/HttpClient.js

@@ -77,10 +77,10 @@ class HttpClient {
       headers: this.RequestHeaders(bodyType, headers)
     };
 
-    if(method === "POST" || method === "PUT") {
+    if(method === "POST" || method === "PUT" || method === "DELETE") {
       if(body && bodyType === "JSON") {
         fetchParameters.body = JSON.stringify(body);
-      } else {
+      } else if(body) {
         fetchParameters.body = body;
       }
     }

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/ContentAccess.js

@@ -234,11 +234,14 @@ exports.ContentType = async function({name, typeId, versionHash, publicOnly=fals
   if(name) {
     this.Log("Looking up type by name in content space metadata...");
     // Look up named type in content space metadata
-    typeId = await this.ContentObjectMetadata({
-      libraryId: this.contentSpaceLibraryId,
-      objectId: this.contentSpaceObjectId,
-      metadataSubtree: UrlJoin("public", "contentTypes", name)
-    });
+    try {
+      typeId = await this.ContentObjectMetadata({
+        libraryId: this.contentSpaceLibraryId,
+        objectId: this.contentSpaceObjectId,
+        metadataSubtree: UrlJoin("public", "contentTypes", name)
+      });
+    // eslint-disable-next-line no-empty
+    } catch(error) {}
   }
 
   if(!typeId) {
@@ -310,11 +313,15 @@ exports.ContentTypes = async function() {
   this.Log(typeAddresses);
 
   // Content space types
-  const contentSpaceTypes = await this.ContentObjectMetadata({
-    libraryId: this.contentSpaceLibraryId,
-    objectId: this.contentSpaceObjectId,
-    metadataSubtree: "public/contentTypes"
-  }) || {};
+  let contentSpaceTypes = {};
+  try {
+    contentSpaceTypes = await this.ContentObjectMetadata({
+      libraryId: this.contentSpaceLibraryId,
+      objectId: this.contentSpaceObjectId,
+      metadataSubtree: "public/contentTypes"
+    }) || {};
+  // eslint-disable-next-line no-empty
+  } catch(error) {}
 
   const contentSpaceTypeAddresses = Object.values(contentSpaceTypes)
     .map(typeId => this.utils.HashToAddress(typeId));

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}`