@eluvio/elv-client-js 4.0.79 → 4.0.81

package/dist/src/walletClient/index.js

@@ -1739,6 +1739,21 @@ var ElvWalletClient = /*#__PURE__*/function () {
                 if (op === "nft-offer-redeem") {
                   offerId = status.op.split(":")[3];
                 }
+                if (op === "nft-claim-entitlement") {
+                  var _status$op$split3 = status.op.split(":"),
+                    _status$op$split4 = _slicedToArray(_status$op$split3, 4),
+                    _op = _status$op$split4[0],
+                    marketplace = _status$op$split4[1],
+                    sku = _status$op$split4[2],
+                    purchaseId = _status$op$split4[3];
+                  confirmationId = purchaseId;
+                  if (status.extra && status.extra["0"]) {
+                    address = status.extra["0"].token_addr;
+                    tokenId = status.extra["0"].token_id;
+                    address = address.startsWith("0x") ? Utils.FormatAddress(address) : address;
+                    status.marketplaceId = marketplace;
+                  }
+                }
                 return _objectSpread(_objectSpread({}, status), {}, {
                   timestamp: new Date(status.ts),
                   state: status.state && _typeof(status.state) === "object" ? Object.values(status.state) : status.state,

package/package.json

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

package/src/ElvClient.js

@@ -975,6 +975,71 @@ class ElvClient {
     ]))}`;
   }
 
+
+  /**
+   * Build a signed message (JSON) using the current signer.
+   * Signed messages have a similar format to signed access tokens and they include the message itself
+   * such that they can be both verified and decoded by the receiving entity.
+   *
+   * Messages can be encoded and signed using different methods, and the encoding and signature types
+   * are described in the header of the resulting signed message blob.
+   *
+   * Note this type of message can not be verified and decoded on chain.
+   *
+   * @methodGroup Authorization
+   * @namedParams
+   * @param {string} messasge - A JSON object representing the message to sign
+   */
+  async CreateSignedMessageJSON({
+      message
+  }) {
+
+    // Only one kind of signature supported currently
+    const type = "mje_" // JSON message, EIP192 signature
+
+    const msg = JSON.stringify(message);
+    const signature = await this.PersonalSign({message: msg, addEthereumPrefix: true});
+    return `${type}${Utils.B58(
+      Buffer.concat([
+        Buffer.from(signature.replace(/^0x/, ""), "hex"),
+        Buffer.from(msg)
+      ])
+    )}`;
+  }
+
+  /**
+   * Verify and decode a signed message (JSON).
+   *
+   * @methodGroup Authorization
+   * @namedParams
+   * @param {string} signedMessage - a signed message as created by CreateSignedMessageJSON
+   * @returns {Promise<Object>} - The decoded message, signer address, signature and signature type
+   */
+  async DecodeSignedMessageJSON({
+    signedMessage
+  })  {
+    const type = signedMessage.slice(0,4);
+    switch(type) {
+        case "mje_":
+            const msgBytes = Utils.FromB58(signedMessage.slice(4));
+            const signature = msgBytes.slice(0, 65);
+            const msg = msgBytes.slice(65);
+            const obj = JSON.parse(msg);
+
+            const prefixedMsgHash = Ethers.utils.keccak256(Buffer.from(`\x19Ethereum Signed Message:\n${msg.length}${msg}`, "utf-8"));
+            const signerAddr = Ethers.utils.recoverAddress(prefixedMsgHash, signature);
+
+            return {
+                type: type,
+                message: obj,
+                signerAddress: signerAddr,
+                signature: "0x" + signature.toString("hex")
+            };
+        default:
+            throw new Error(`Bad message type: ${type}`);
+    }
+  }
+
   /**
    * Get the account address of the current signer
    *

package/src/client/LiveConf.js

@@ -209,6 +209,17 @@ class LiveConf {
     return seg;
   }
 
+ /*
+  * Calculate output timebase from the encoder (codec) timebase. The videoTimeBase parameter
+  * represents the encoder timebase. The format muxer will change it so it is greater than 10000.
+  */
+  calcOutputTimebase(codecTimebase) {
+    let outputTimebase = codecTimebase;
+    while (outputTimebase < 10000)
+      outputTimebase = outputTimebase * 2;
+    return outputTimebase;
+  }
+
   calcSegDurationMpegts({sourceTimescale}) {
     let videoStream = this.getStreamDataForCodecType("video");
     let frameRate = videoStream.frame_rate;
@@ -270,7 +281,9 @@ class LiveConf {
 
     switch(frameRate) {
       case "24":
-        seg.video = sourceTimescale * 30;
+        seg.videoTimeBase = 1536; // Output timebase: 12288
+        seg.videoFrameDurationTs = 512;
+        seg.video = this.calcOutputTimebase(seg.videoTimeBase) * 30;
         seg.keyint = 48;
         seg.duration = "30";
         break;
@@ -280,7 +293,9 @@ class LiveConf {
         seg.duration = "30";
         break;
       case "30":
-        seg.video = sourceTimescale * 30;
+        seg.videoTimeBase = 960; // Output timebase: 15360
+        seg.videoFrameDurationTs = 512;
+        seg.video = this.calcOutputTimebase(seg.videoTimeBase) * 30;
         seg.keyint = 60;
         seg.duration = "30";
         break;
@@ -290,7 +305,9 @@ class LiveConf {
         seg.duration = "30.03";
         break;
       case "48":
-        seg.video = sourceTimescale * 30;
+        seg.videoTimeBase = 1536; // Output timebase: 12288
+        seg.videoFrameDurationTs = 256;
+        seg.video = this.calcOutputTimebase(seg.videoTimeBase) * 30;
         seg.keyint = 96;
         seg.duration = "30";
         break;
@@ -300,7 +317,9 @@ class LiveConf {
         seg.duration = "30";
         break;
       case "60":
-        seg.video = sourceTimescale * 30;
+        seg.videoTimeBase = 960; // Output timebase: 15360
+        seg.videoFrameDurationTs = 256;
+        seg.video = this.calcOutputTimebase(seg.videoTimeBase) * 30;
         seg.keyint = 120;
         seg.duration = "30";
         break;
@@ -397,7 +416,9 @@ class LiveConf {
     // Optional override output timebase and frame duration (ts)
     if(segDurations.videoTimeBase) {
       conf.live_recording.recording_config.recording_params.xc_params.video_time_base = segDurations.videoTimeBase;
-      conf.live_recording.recording_config.recording_params.source_timescale = segDurations.videoTimeBase;
+
+      // Note 'source_timescale' needs to be set to the output timebase and is used by playout
+      conf.live_recording.recording_config.recording_params.source_timescale = this.calcOutputTimebase(segDurations.videoTimeBase);
     }
     if(segDurations.videoFrameDurationTs) {
       conf.live_recording.recording_config.recording_params.xc_params.video_frame_duration_ts = segDurations.videoFrameDurationTs;

package/src/client/LiveStream.js

@@ -1322,7 +1322,7 @@ exports.StreamConfig = async function({name, customSettings={}}) {
   const hostName = userConfig.url.replace("udp://", "").replace("rtmp://", "").replace("srt://", "").split(":")[0];
   const streamUrl = new URL(userConfig.url);
 
-  console.log("Retrieving nodes...");
+  console.log("Retrieving nodes - matching", hostName);
   let nodes = await this.SpaceNodes({matchEndpoint: hostName});
   if(nodes.length < 1) {
     status.error = "No node matching stream URL " + streamUrl.href;

package/src/walletClient/ClientMethods.js

@@ -1371,6 +1371,54 @@ exports.GiftClaimStatus = async function({marketplaceParams, confirmationId, gif
   }
 };
 
+/**
+ * Return status of the specified entitlement claim
+ *
+ * @methodGroup Status
+ * @namedParams
+ * @param {Object} marketplaceParams - Parameters of the marketplace
+ * @param {string} purchaseId - The purchase ID of the entitlement, for confirmation of status
+ *
+ * @returns {Promise<Object>} - The mint status of the entitlement claim
+ */
+exports.EntitlementClaimStatus = async function({marketplaceParams, purchaseId}) {
+  try {
+    const marketplaceInfo = await this.MarketplaceInfo({marketplaceParams});
+    const statuses = await this.MintingStatus({tenantId: marketplaceInfo.tenantId});
+
+    const responses = statuses.filter(status => status.op === "nft-claim-entitlement"
+      && (purchaseId && purchaseId == status.confirmationId)) || { status: "none" };
+
+    if(responses.length === 0) {
+      return { status: "none" };
+    } else {
+      if(responses.find(response => response.status === "complete")) {
+        return {
+          status: "complete",
+          op: "nft-claim-entitlement",
+          items: [{
+            token_addr: responses[0].address,
+            token_id: responses[0].tokenId
+          }]
+        };
+      } else if(responses.find(response => response.status === "error")) {
+        return {
+          status: "error",
+          op: "nft-claim-entitlement",
+        };
+      } else {
+        return {
+          status: "pending",
+          op: "nft-claim-entitlement",
+        };
+      }
+    }
+  } catch(error) {
+    this.Log(error, true);
+    return { status: "unknown" };
+  }
+};
+
 /**
  * Return status of the specified pack opening
  *

package/src/walletClient/index.js

@@ -1326,6 +1326,18 @@ class ElvWalletClient {
             offerId = status.op.split(":")[3];
           }
 
+          if(op === "nft-claim-entitlement") {
+            let [op, marketplace, sku, purchaseId ] = status.op.split(":");
+            confirmationId = purchaseId
+            if(status.extra && status.extra["0"]) {
+              address = status.extra["0"].token_addr;
+              tokenId = status.extra["0"].token_id;
+
+              address = address.startsWith("0x") ? Utils.FormatAddress(address) : address;
+              status.marketplaceId = marketplace;
+            }
+          }
+
           return {
             ...status,
             timestamp: new Date(status.ts),

package/testScripts/CreateAndDecodeSignedMessage.js

@@ -0,0 +1,51 @@
+const { ElvClient } = require("../src/ElvClient");
+
+const yargs = require("yargs");
+const argv = yargs
+.option("msg", {
+  description: "message to be signed and decoded",
+  type: "string"
+})
+.option("config-url", {
+  type: "string",
+  description: "URL pointing to the Fabric configuration. i.e. https://main.net955210.contentfabric.io/config"
+})
+.demandOption(
+  ["msg"],
+  "\nUsage: PRIVATE_KEY=<private-key> node CreateAndDecodeSignedMessage.js --msg <message>\n"
+)
+.strict().argv;
+const ClientConfiguration = (!argv["config-url"]) ? (require("../TestConfiguration.json")) : {"config-url": argv["config-url"]};
+
+const CreateAndDecodeSignedMessage = async ({msg}) => {
+  try {
+    const client = await ElvClient.FromConfigurationUrl({
+      configUrl: ClientConfiguration["config-url"],
+    });
+    const wallet = client.GenerateWallet();
+    const signer = wallet.AddAccount({
+      privateKey: process.env.PRIVATE_KEY
+    });
+
+    client.SetSigner({signer});
+
+    const signedMessage = await client.CreateSignedMessageJSON({
+      message:msg,
+    });
+
+    const decodedMessage = await client.DecodeSignedMessageJSON({
+      signedMessage,
+    });
+
+
+    console.log(signedMessage);
+    console.log(decodedMessage);
+  } catch(error) {
+    console.error(error);
+    console.error(JSON.stringify(error, null, 2));
+  }
+
+  process.exit(0);
+};
+
+CreateAndDecodeSignedMessage({msg: argv.msg});

package/utilities/GenerateFabricToken.js

@@ -11,7 +11,10 @@ const GenerateFabricToken = async () => {
 
     client.SetSigner({signer});
 
-    console.log(await client.CreateFabricToken({duration: process.env.DURATION}));
+    console.log(await client.CreateFabricToken({
+      duration: parseInt(process.env.DURATION),
+      //context: {email:"xyz@eluv.io"}
+    }));
   } catch(error) {
     console.error(error);
     console.error(JSON.stringify(error, null, 2));