@amityco/ts-sdk-react-native 7.12.1-f6ba70a0.0 → 7.13.0

package/dist/index.cjs.js

@@ -260,8 +260,8 @@ exports.AmityEventOrderOption = void 0;
 
 function getVersion() {
     try {
-        // the string ''v7.12.0-cjs'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v7.12.0-cjs';
+        // the string ''v7.13.0-cjs'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v7.13.0-cjs';
     }
     catch (error) {
         return '__dev__';
@@ -6904,11 +6904,11 @@ class SessionWatcher {
             this._listener.delete(callback);
         };
     }
-    setSessionState(state) {
+    setSessionState(state, reason) {
         if (this._sessionState === state)
             return;
         this._sessionState = state;
-        this._listener.forEach(cb => cb(state));
+        this._listener.forEach(cb => cb(state, reason));
     }
     destroy() {
         this._listener.clear();
@@ -7348,9 +7348,9 @@ const isValidStateChange = (prevState, nextState) => {
  *
  * @category private
  */
-const setSessionState = (state) => {
+const setSessionState = (state, reason) => {
     const client = getActiveClient();
-    client.log('client/api/setSessionState', state);
+    client.log('client/api/setSessionState', state, reason);
     const { sessionState: prevState } = client;
     if (prevState === state)
         return false;
@@ -7359,7 +7359,7 @@ const setSessionState = (state) => {
         throw new ASCError(`Session state cannot change from ${prevState} to ${state}`, 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
     }
     client.sessionState = state;
-    SessionWatcher$1.getInstance().setSessionState(state);
+    SessionWatcher$1.getInstance().setSessionState(state, reason);
     return true;
 };
 
@@ -8842,7 +8842,7 @@ const logout = async () => {
  */
 const terminateClient = (terminationReason) => {
     const client = getActiveClient();
-    setSessionState("terminated" /* Amity.SessionStates.TERMINATED */);
+    setSessionState("terminated" /* Amity.SessionStates.TERMINATED */, terminationReason);
     if (client.http.defaults.metadata) {
         if (terminationReason === "globalBan" /* Amity.TokenTerminationReason.GLOBAL_BAN */)
             client.http.defaults.metadata.isGlobalBanned = true;
@@ -10799,12 +10799,19 @@ const blockUser = async (userId) => {
     const { data } = await client.http.post(`/api/v4/me/user-blocks/${userId}`);
     const cachedAt = client.cache && Date.now();
     const { follows, followCounts } = data;
-    const followStatus = { follows };
+    const blockedFollowStatus = { follows };
     if (client.cache) {
-        ingestInCache(followStatus, { cachedAt });
+        ingestInCache(blockedFollowStatus, { cachedAt });
         upsertInCache(['followInfo', 'get', userId], followCounts[0], { cachedAt });
     }
-    const payload = prepareFollowStatusPayload(followStatus);
+    // need to swap {from} and {to} to get the correct id for unfollow event to filter from follower live collection
+    const blockedUnfollowStatus = {
+        follows: follows.map(follow => {
+            const unfollowStatus = Object.assign(Object.assign({}, follow), { to: follow.from, from: follow.to, status: 'none' });
+            return follow.status === 'blocked' ? unfollowStatus : follow;
+        }),
+    };
+    const payload = prepareFollowStatusPayload(blockedUnfollowStatus);
     fireEvent('local.follow.unfollowed', payload);
     return data;
 };
@@ -12709,6 +12716,414 @@ const getInvitation = async (params) => {
 };
 /* end_public_function */
 
+/**
+ * WatchSessionStorage manages watch session data in memory
+ * Similar to UsageCollector for stream watch minutes
+ */
+class WatchSessionStorage {
+    constructor() {
+        this.sessions = new Map();
+    }
+    /**
+     * Add a new watch session
+     */
+    addSession(session) {
+        this.sessions.set(session.sessionId, session);
+    }
+    /**
+     * Get a watch session by sessionId
+     */
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    /**
+     * Update a watch session
+     */
+    updateSession(sessionId, updates) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            this.sessions.set(sessionId, Object.assign(Object.assign({}, session), updates));
+        }
+    }
+    /**
+     * Get all sessions with a specific sync state
+     */
+    getSessionsByState(state) {
+        return Array.from(this.sessions.values()).filter(session => session.syncState === state);
+    }
+    /**
+     * Delete a session
+     */
+    deleteSession(sessionId) {
+        this.sessions.delete(sessionId);
+    }
+    /**
+     * Get all pending sessions
+     */
+    getPendingSessions() {
+        return this.getSessionsByState('PENDING');
+    }
+    /**
+     * Get all syncing sessions
+     */
+    getSyncingSessions() {
+        return this.getSessionsByState('SYNCING');
+    }
+}
+// Singleton instance
+let storageInstance = null;
+const getWatchSessionStorage = () => {
+    if (!storageInstance) {
+        storageInstance = new WatchSessionStorage();
+    }
+    return storageInstance;
+};
+
+const privateKey = "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDHo80SecH7FuF2\nhFYnb+l26/VN8UMLXAQFLnxciNTEwkGVFMpdezlH8rU2HtUJL4RETogbAOLVY0XM\njs6sPn8G1nALmh9qeDpUtVqFOVtBHxEZ910TLOtQiunjqJKO5nWdqZ71EC3OFluR\niGQkO84BiIFbv37ub7xl3S8XarbtKoLcyVpkDHi+1wx1pgCAn6gtBUgckPL5NR8j\nLseabl3HAXQfhTCKo4tmOFM2Dxwl1IUMmIJrJg/aIU/U0tj/1Eoo7mG0JcNWX19l\nW3EecCbi0ncCJOrkUdwlBrcjaMayaX/ubEwyUeTGiLdyc4L3GRLHjyK8xgVNXRMH\nbZWJ2a5NAgMBAAECggEASxuE+35zTFO/XydKgmvIGcWL9FbgMlXb7Vcf0nBoG945\nbiz0NVc2paraIhJXc608xbYF3qLmtAE1MVBI0ORyRdBHNxY024l/6H6SH60Ed+uI\nM4ysp5ourY6Vj+DLwpdRiI9YDjqYAQDIUmhNxJP7XPhOMoZI6st+xZQBM34ic/bv\nAMSJm9OZphSp3+qXVkFZztr2mxD2EZSJJLYxi8BCdgM2qhazalbcJ6zDKHCZWVWm\n8RRxDGldyMb/237JxETzP40tAlzOZDmBAbUgEnurDJ93RVDIE3rbZUshwgeQd18a\nem096mWgvB1AIKYgsTAR3pw+V19YWAjq/glP6fz8wQKBgQD/oQq+ukKF0PRgBeM5\ngeTjSwsdGppQLmf5ndujvoiz/TpdjDEPu6R8kigQr1rG2t4K/yfdZoI8RdmJD1al\n3Q7N9hofooSy4rj6E3txzWZCHJjHad2cnCp/O26HiReGAl7wTcfTmNdiFHhZQzm5\nJBkvWAiwuvQMNfEbnXxw6/vIDwKBgQDH7fX8gsc77JLvAWgp1MaQN/sbqVb6JeT1\nFQfR8E/WFCSmzQBtNzd5KgYuCeelwr/8DyYytvN2BzCYZXp73gI1jF3YlW5jVn74\nOY6TwQ095digwo6Z0yuxopdIOApKgAkL9PRKgNrqAf3NAyMua6lOGifzjDojC3KU\nfylQmxMn4wKBgHp2B9O/H0dEBw5JQ8W0+JX6yWQz7mEjGiR2/1W+XXb8hQ1zr709\nw1r6Gb+EghRpnZ3fBpYGGbYOMFx8wKHM+N6qW3F0ReX8v2juFGE8aRSa5oYBrWzt\nU16Idjbv8hj84cZ1PJmdyvDtpYn9rpWHOZl4rxEbPvbqkIsOMyNVqdT5AoGAOSge\nmwIIU2le2FVeohbibXiToWTYKMuMmURZ5/r72AgKMmWJKbAPe+Q3wBG01/7FRBpQ\noU8Ma0HC8s6QJbliiEyIx9JwrJWd1vkdecBHONrtA4ibm/5zD2WcOllLF+FitLhi\n3qnX6+6F0IaFGFBPJrTzlv0P4dTz/OAdv52V7GECgYEA2TttOKBAqWllgOaZOkql\nLVMJVmgR7s6tLi1+cEP8ZcapV9aRbRzTAKXm4f8AEhtlG9F9kCOvHYCYGi6JaiWJ\nZkHjeex3T+eE6Di6y5Bm/Ift5jtVhJ4jCVwHOKTMej79NPUFTJfv8hCo29haBDv6\nRXFrv+T21KCcw8k3sJeJWWQ=\n-----END PRIVATE KEY-----";
+/*
+ * The crypto algorithm used for importing key and signing string
+ */
+const ALGORITHM = {
+    name: 'RSASSA-PKCS1-v1_5',
+    hash: { name: 'SHA-256' },
+};
+/*
+ * IMPORTANT!
+ * If you are recieving key from other platforms use an online tool to convert
+ * the PKCS1 to PKCS8. For instance the key from Android SDK is of the format
+ * PKCS1.
+ *
+ * If recieving from the platform, verify if it's already in the expected
+ * format. Otherwise the crypto.subtle.importKey will throw a DOMException
+ */
+const PRIVATE_KEY_SIGNATURE = 'pkcs8';
+/*
+ * Ensure that the private key in the .env follows this format
+ */
+const PEM_HEADER = '-----BEGIN PRIVATE KEY-----';
+const PEM_FOOTER = '-----END PRIVATE KEY-----';
+/*
+ * The crypto.subtle.sign function returns an ArrayBuffer whereas the server
+ * expects a base64 string. This util helps facilitate that process
+ */
+function base64FromArrayBuffer(buffer) {
+    const uint8Array = new Uint8Array(buffer);
+    let binary = '';
+    uint8Array.forEach(byte => {
+        binary += String.fromCharCode(byte);
+    });
+    return jsBase64.btoa(binary);
+}
+/*
+ * Encode ASN.1 length field
+ */
+function encodeLength(length) {
+    if (length < 128) {
+        return new Uint8Array([length]);
+    }
+    if (length < 256) {
+        return new Uint8Array([0x81, length]);
+    }
+    // eslint-disable-next-line no-bitwise
+    return new Uint8Array([0x82, (length >> 8) & 0xff, length & 0xff]);
+}
+/*
+ * Convert PKCS1 private key to PKCS8 format
+ * PKCS1 is RSA-specific format, PKCS8 is generic format that crypto.subtle requires
+ * Android uses PKCS8EncodedKeySpec which expects PKCS8 format
+ */
+function pkcs1ToPkcs8(pkcs1) {
+    // Algorithm identifier for RSA
+    const algorithmIdentifier = new Uint8Array([
+        0x30,
+        0x0d,
+        0x06,
+        0x09,
+        0x2a,
+        0x86,
+        0x48,
+        0x86,
+        0xf7,
+        0x0d,
+        0x01,
+        0x01,
+        0x01,
+        0x05,
+        0x00, // NULL
+    ]);
+    // Version (INTEGER 0)
+    const version = new Uint8Array([0x02, 0x01, 0x00]);
+    // OCTET STRING tag + length + pkcs1 data
+    const octetStringTag = 0x04;
+    const octetStringLength = encodeLength(pkcs1.length);
+    // Calculate total content length (version + algorithm + octet string)
+    const contentLength = version.length + algorithmIdentifier.length + 1 + octetStringLength.length + pkcs1.length;
+    // SEQUENCE tag + length
+    const sequenceTag = 0x30;
+    const sequenceLength = encodeLength(contentLength);
+    // Build the PKCS8 structure
+    const pkcs8 = new Uint8Array(1 + sequenceLength.length + contentLength);
+    let offset = 0;
+    pkcs8[offset] = sequenceTag;
+    offset += 1;
+    pkcs8.set(sequenceLength, offset);
+    offset += sequenceLength.length;
+    pkcs8.set(version, offset);
+    offset += version.length;
+    pkcs8.set(algorithmIdentifier, offset);
+    offset += algorithmIdentifier.length;
+    pkcs8[offset] = octetStringTag;
+    offset += 1;
+    pkcs8.set(octetStringLength, offset);
+    offset += octetStringLength.length;
+    pkcs8.set(pkcs1, offset);
+    return pkcs8;
+}
+async function importPrivateKey(keyString) {
+    // Remove PEM headers if present and any whitespace
+    let base64Key = keyString;
+    if (keyString.includes(PEM_HEADER)) {
+        base64Key = keyString
+            .substring(PEM_HEADER.length, keyString.length - PEM_FOOTER.length)
+            .replace(/\s/g, '');
+    }
+    else {
+        base64Key = keyString.replace(/\s/g, '');
+    }
+    // Base64 decode to get binary data
+    const binaryDerString = jsBase64.atob(base64Key);
+    // Convert to Uint8Array for manipulation
+    const pkcs1 = new Uint8Array(binaryDerString.length);
+    for (let i = 0; i < binaryDerString.length; i += 1) {
+        pkcs1[i] = binaryDerString.charCodeAt(i);
+    }
+    // Convert PKCS1 to PKCS8 (crypto.subtle requires PKCS8)
+    const pkcs8 = pkcs1ToPkcs8(pkcs1);
+    // Import the key
+    const key = await crypto.subtle.importKey(PRIVATE_KEY_SIGNATURE, pkcs8.buffer, ALGORITHM, false, ['sign']);
+    return key;
+}
+async function createSignature({ timestamp, rooms, }) {
+    const dataStr = rooms
+        .map(item => Object.keys(item)
+        .sort()
+        .map(key => `${key}=${item[key]}`)
+        .join('&'))
+        .join(';');
+    /*
+     * nonceStr needs to be unique for each request
+     */
+    const nonceStr = uuid__default["default"].v4();
+    const signStr = `nonceStr=${nonceStr}&timestamp=${timestamp}&data=${dataStr}==`;
+    const encoder = new TextEncoder();
+    const data = encoder.encode(signStr);
+    const key = await importPrivateKey(privateKey);
+    const sign = await crypto.subtle.sign(ALGORITHM, key, data);
+    return { signature: base64FromArrayBuffer(sign), nonceStr };
+}
+
+/**
+ * Sync pending watch sessions to backend
+ * This function implements the full sync flow with network resilience
+ */
+async function syncWatchSessions() {
+    const storage = getWatchSessionStorage();
+    // Get all pending sessions
+    const pendingSessions = storage.getPendingSessions();
+    if (pendingSessions.length === 0) {
+        return true;
+    }
+    try {
+        const timestamp = new Date().toISOString();
+        // Convert sessions to API format - always include all fields like syncUsage does
+        const rooms = pendingSessions.map(session => ({
+            sessionId: session.sessionId,
+            roomId: session.roomId,
+            watchSeconds: session.watchSeconds,
+            startTime: session.startTime.toISOString(),
+            endTime: session.endTime ? session.endTime.toISOString() : '',
+        }));
+        // Create signature (reuse from stream feature) - pass directly like syncUsage
+        const signatureData = await createSignature({
+            timestamp,
+            rooms,
+        });
+        if (!signatureData || !signatureData.signature) {
+            throw new Error('Signature is undefined');
+        }
+        // Update sync state to SYNCING
+        pendingSessions.forEach(session => {
+            storage.updateSession(session.sessionId, { syncState: 'SYNCING' });
+        });
+        const payload = {
+            signature: signatureData.signature,
+            nonceStr: signatureData.nonceStr,
+            timestamp,
+            rooms,
+        };
+        const client = getActiveClient();
+        // Send to backend
+        await client.http.post('/api/v3/user-event/room', payload);
+        // Success - update to SYNCED
+        pendingSessions.forEach(session => {
+            storage.updateSession(session.sessionId, {
+                syncState: 'SYNCED',
+                syncedAt: new Date(),
+            });
+        });
+        return true;
+    }
+    catch (err) {
+        console.error('[SDK syncWatchSessions] ERROR caught:', (err === null || err === void 0 ? void 0 : err.message) || err);
+        // Failure - update back to PENDING and increment retry count
+        pendingSessions.forEach(session => {
+            const currentSession = storage.getSession(session.sessionId);
+            if (currentSession) {
+                const newRetryCount = currentSession.retryCount + 1;
+                if (newRetryCount >= 3) {
+                    // Delete session if retry count exceeds 3
+                    storage.deleteSession(session.sessionId);
+                }
+                else {
+                    // Update to PENDING with incremented retry count
+                    storage.updateSession(session.sessionId, {
+                        syncState: 'PENDING',
+                        retryCount: newRetryCount,
+                    });
+                }
+            }
+        });
+        return false;
+    }
+}
+
+/**
+ * Room statuses that are considered watchable
+ */
+const WATCHABLE_ROOM_STATUSES = ['live', 'recorded'];
+/**
+ * Generate a random jitter delay between 5 and 30 seconds
+ */
+const getJitterDelay = () => {
+    const minDelay = 5000; // 5 seconds
+    const maxDelay = 30000; // 30 seconds
+    return Math.floor(Math.random() * (maxDelay - minDelay + 1)) + minDelay;
+};
+/**
+ * Wait for network connection with timeout
+ * @param maxWaitTime Maximum time to wait in milliseconds (default: 60000 = 60 seconds)
+ * @returns Promise that resolves when network is available or timeout is reached
+ */
+const waitForNetwork = (maxWaitTime = 60000) => {
+    return new Promise(resolve => {
+        // Simple check - if navigator.onLine is available, use it
+        // Otherwise, assume network is available
+        if (typeof navigator === 'undefined' || typeof navigator.onLine === 'undefined') {
+            resolve();
+            return;
+        }
+        const startTime = Date.now();
+        const checkInterval = 1000; // 1 second
+        const checkConnection = () => {
+            if (navigator.onLine || Date.now() - startTime >= maxWaitTime) {
+                resolve();
+            }
+            else {
+                setTimeout(checkConnection, checkInterval);
+            }
+        };
+        checkConnection();
+    });
+};
+/**
+ * AmityRoomAnalytics provides analytics capabilities for room watch sessions
+ */
+class AmityRoomAnalytics {
+    constructor(room) {
+        this.storage = getWatchSessionStorage();
+        this.client = getActiveClient();
+        this.room = room;
+    }
+    /**
+     * Create a new watch session for the current room
+     * @param startedAt The timestamp when watching started
+     * @returns Promise<string> sessionId unique identifier for this watch session
+     * @throws ASCApiError if room is not in watchable state (not LIVE or RECORDED)
+     */
+    async createWatchSession(startedAt) {
+        // Validate room status
+        if (!WATCHABLE_ROOM_STATUSES.includes(this.room.status)) {
+            throw new ASCApiError('room is not in watchable state', 500000 /* Amity.ServerError.BUSINESS_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+        }
+        // Generate session ID with prefix
+        const prefix = this.room.status === 'live' ? 'room_' : 'room_playback_';
+        const sessionId = prefix + uuid__default["default"].v4();
+        // Create watch session entity
+        const session = {
+            sessionId,
+            roomId: this.room.roomId,
+            watchSeconds: 0,
+            startTime: startedAt,
+            endTime: null,
+            syncState: 'PENDING',
+            syncedAt: null,
+            retryCount: 0,
+        };
+        // Persist to storage
+        this.storage.addSession(session);
+        return sessionId;
+    }
+    /**
+     * Update an existing watch session with duration
+     * @param sessionId The unique identifier of the watch session
+     * @param duration The total watch duration in seconds
+     * @param endedAt The timestamp when this update occurred
+     * @returns Promise<void> Completion status
+     */
+    async updateWatchSession(sessionId, duration, endedAt) {
+        const session = this.storage.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Watch session ${sessionId} not found`);
+        }
+        // Update session
+        this.storage.updateSession(sessionId, {
+            watchSeconds: duration,
+            endTime: endedAt,
+        });
+    }
+    /**
+     * Sync all pending watch sessions to backend
+     * This function uses jitter delay and handles network resilience
+     */
+    syncPendingWatchSessions() {
+        // Execute with jitter delay (5-30 seconds)
+        const jitterDelay = getJitterDelay();
+        this.client.log('room/RoomAnalytics: syncPendingWatchSessions called, jitter delay:', `${jitterDelay}ms`);
+        setTimeout(async () => {
+            this.client.log('room/RoomAnalytics: Jitter delay completed, starting sync process');
+            try {
+                // Reset any SYNCING sessions back to PENDING
+                const syncingSessions = this.storage.getSyncingSessions();
+                this.client.log('room/RoomAnalytics: SYNCING sessions to reset:', syncingSessions.length);
+                syncingSessions.forEach(session => {
+                    this.storage.updateSession(session.sessionId, { syncState: 'PENDING' });
+                });
+                // Wait for network connection (max 60 seconds)
+                await waitForNetwork(60000);
+                this.client.log('room/RoomAnalytics: Network available');
+                // Sync pending sessions
+                this.client.log('room/RoomAnalytics: Calling syncWatchSessions()');
+                await syncWatchSessions();
+                this.client.log('room/RoomAnalytics: syncWatchSessions completed');
+            }
+            catch (error) {
+                // Error is already handled in syncWatchSessions
+                console.error('Failed to sync watch sessions:', error);
+            }
+        }, jitterDelay);
+    }
+}
+
 const roomLinkedObject = (room) => {
     return Object.assign(Object.assign({}, room), { get post() {
             var _a;
@@ -12755,6 +13170,9 @@ const roomLinkedObject = (room) => {
                 type: "livestreamCohostInvite" /* InvitationTypeEnum.LivestreamCohostInvite */,
             });
             return data;
+        }, analytics() {
+            // Use 'this' to avoid creating a new room object
+            return new AmityRoomAnalytics(this);
         } });
 };
 
@@ -29133,6 +29551,10 @@ var index$b = /*#__PURE__*/Object.freeze({
     getRecordedUrl: getRecordedUrl,
     removeParticipant: removeParticipant,
     leaveRoom: leaveRoom,
+    AmityRoomAnalytics: AmityRoomAnalytics,
+    WatchSessionStorage: WatchSessionStorage,
+    getWatchSessionStorage: getWatchSessionStorage,
+    syncWatchSessions: syncWatchSessions,
     onRoomStartBroadcasting: onRoomStartBroadcasting,
     onRoomWaitingReconnect: onRoomWaitingReconnect,
     onRoomEndBroadcasting: onRoomEndBroadcasting,
@@ -30641,85 +31063,6 @@ var index$7 = /*#__PURE__*/Object.freeze({
     getPoll: getPoll
 });
 
-const privateKey = "-----BEGIN PRIVATE KEY-----\nMIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDAARz+hmBgi8pJ\nQb8LeY41gtHhk+ACMwRfhsn7GqpqRQNG2qU0755mzZuVDUqjQMGSo8THJB7O+OJs\nflbZRkFXlFoFOVNw1UpNOgwEQZ6wB9oRwzepTJAfF1sVhm/o/ixvXh1zDFNDy6yZ\npXyiiJHUVxqyjllZhxnwdvjoVtDs6hW6awG09bB9nh/TTejlUKXoAgzqVwu/1QMu\nUVViET495elEe19aUarEy+oL2iKeXCEvqda/pWNBdbieFyJvvZ08HN8dPuT88wq2\njZLEAth1vrwQ2IAa4ktaLcBQdLJgIkrbDvAiVZ8lQAjS/bq5vXQikTGvoPlC5bbn\nvuOM/3eLAgMBAAECggEAVZ+peHAghq2QVj71nX5lxsNCKaCyYwixSJBpfouTt7Rz\nE6PpzMOXFi1W1o+I22jDakuSM2SOQKqI/u0QefB0r0O/KVk5NrZHXk0mkrdYtxOp\nUgaGyf8UvmjB+8VqHrNKyZdk9qtmbnNj01kTTcAtmE4H39zPR7eR/8Rul94vaZbs\nwCnKJS3mLT3JxyGug6lxanveKkjG+CKC1nJQYWaxCJxaFSzbwXQPvDhB+TvrIbee\npd5v4EAyEJohpr+T9oDGGJkb/KARBZCtwLyB976PKJwwBA8MRVL1i5QwawuMiMq5\nUtnOnbGKtCeFzaLbNU0Qi8bqyims84EQxC6DOu1fkQKBgQDdvsoBsEhsOXV7hlIJ\naEd0eSJZVkdqimxH8uGoMM2FeNaOrcB6yBXqTSP0R3OIyf8eaY6yjRvP30ZNXcll\n/gD3O1Mu6YmWQdt1W2WA6pKOsUuPXasf0pdOF7IiFZKlSabz5YHXFqwVuqm8loaj\nsXel3YWqPVdHiankE7tz+3ssnQKBgQDdqi4TNdD1MdEpihx19jr0QjUiXW3939FK\nqp30HESPEGDGQzXdmJgif9HhZb+cJSuWaHEbjgBrYahvgCF+y6LbEpOD+D/dmT+s\nDEAQaR84sah6dokwPjV8fjBSrcVFjCS+doxv0d3p/9OUEeyUhFrY03nxtIEYkLIE\n/Zvn37b4RwKBgQCLENVFe9XfsaVhQ5r9dV2iyTlmh7qgMZG5CbTFs12hQGhm8McO\n+Z7s41YSJCFr/yq1WwP4LJDtrBw99vyQr1zRsG35tNLp3gGRNzGQSQyC2uQFVHw2\np+7mNewsfhUK/gbrXNsyFnDz6635rPlhfbII3sWuP2wWXFqkxE9CbMwR7QKBgQC6\nawDMzxmo2/iYArrkyevSuEuPVxvFwpF1RgAI6C0QVCnPE38dmdN4UB7mfHekje4W\nVEercMURidPp0cxZolCYBQtilUjAyL0vqC3In1/Ogjq6oy3FEMxSop1pKxMY5j+Q\nnoqFD+6deLUrddeNH7J3X4LSr4dSbX4JjG+tlgt+yQKBgQCuwTL4hA6KqeInQ0Ta\n9VQX5Qr8hFlqJz1gpymi/k63tW/Ob8yedbg3WWNWyShwRMFYyY9S81ITFWM95uL6\nvF3x9rmRjwElJw9PMwVu6dmf/CO0Z1wzXSp2VVD12gbrUD/0/d7MUoJ9LgC8X8f/\nn0txLHYGHbx+nf95+JUg6lV3hg==\n-----END PRIVATE KEY-----";
-/*
- * The crypto algorithm used for importing key and signing string
- */
-const ALGORITHM = {
-    name: 'RSASSA-PKCS1-v1_5',
-    hash: { name: 'SHA-256' },
-};
-/*
- * IMPORTANT!
- * If you are recieving key from other platforms use an online tool to convert
- * the PKCS1 to PKCS8. For instance the key from Android SDK is of the format
- * PKCS1.
- *
- * If recieving from the platform, verify if it's already in the expected
- * format. Otherwise the crypto.subtle.importKey will throw a DOMException
- */
-const PRIVATE_KEY_SIGNATURE = 'pkcs8';
-/*
- * Ensure that the private key in the .env follows this format
- */
-const PEM_HEADER = '-----BEGIN PRIVATE KEY-----';
-const PEM_FOOTER = '-----END PRIVATE KEY-----';
-/*
- * The crypto.subtle.sign function returns an ArrayBuffer whereas the server
- * expects a base64 string. This util helps facilitate that process
- */
-function base64FromArrayBuffer(buffer) {
-    const uint8Array = new Uint8Array(buffer);
-    let binary = '';
-    uint8Array.forEach(byte => {
-        binary += String.fromCharCode(byte);
-    });
-    return jsBase64.btoa(binary);
-}
-/*
- * Convert a string into an ArrayBuffer
- * from https://developers.google.com/web/updates/2012/06/How-to-convert-ArrayBuffer-to-and-from-String
- *
- * Solely used by the importPrivateKey method
- */
-function str2ab(str) {
-    const buf = new ArrayBuffer(str.length);
-    const bufView = new Uint8Array(buf);
-    for (let i = 0, strLen = str.length; i < strLen; i += 1) {
-        bufView[i] = str.charCodeAt(i);
-    }
-    return buf;
-}
-function importPrivateKey(pem) {
-    // fetch the part of the PEM string between header and footer
-    const pemContents = pem.substring(PEM_HEADER.length, pem.length - PEM_FOOTER.length);
-    /*
-     * base64 decode the string to get the binary data
-     */
-    const binaryDerString = jsBase64.atob(pemContents);
-    // convert from a binary string to an ArrayBuffer
-    const binaryDer = str2ab(binaryDerString);
-    return crypto.subtle.importKey(PRIVATE_KEY_SIGNATURE, binaryDer, ALGORITHM, false, ['sign']);
-}
-async function createSignature({ timestamp, streams, }) {
-    const dataStr = streams
-        .map(item => Object.keys(item)
-        .sort()
-        .map(key => `${key}=${item[key]}`)
-        .join('&'))
-        .join(';');
-    /*
-     * nonceStr needs to be unique for each request
-     */
-    const nonceStr = uuid__default["default"].v4();
-    const signStr = `nonceStr=${nonceStr}&timestamp=${timestamp}&data=${dataStr}==`;
-    const encoder = new TextEncoder();
-    const data = encoder.encode(signStr);
-    const key = await importPrivateKey(privateKey);
-    const sign = await crypto.subtle.sign(ALGORITHM, key, data);
-    return { signature: base64FromArrayBuffer(sign), nonceStr };
-}
-
 async function syncUsage({ bufferCurrentUsage, getActiveStreams, updateUsage, dispose, }) {
     const streams = bufferCurrentUsage();
     if (!streams.length)