@lightsparkdev/lightspark-sdk 0.1.6

package/examples/streaming-wallet-extension/src/auth/DemoAccountProvider.ts

@@ -0,0 +1,99 @@
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc";
+import { v4 as uuid } from "uuid";
+import { INSTANCE_ID_KEY } from "../common/storage";
+import StreamingDemoAccountCredentials from "./StreamingDemoCredentials";
+
+const GRAPH_QL_ENDPOINT = "https://api.lightspark.com/graphql/frontend";
+
+dayjs.extend(utc);
+
+const getInstanceID = (): Promise<string> => {
+  return new Promise<string>((resolve) => {
+    chrome.storage.local.get(INSTANCE_ID_KEY, (result) => {
+      if (result.instanceID) {
+        resolve(result.instanceID);
+      } else {
+        const instanceID = uuid();
+        chrome.storage.local.set({ [INSTANCE_ID_KEY]: instanceID }, () => {
+          resolve(instanceID);
+        });
+      }
+    });
+  });
+};
+
+export const reserveStreamingDemoAccountCredentials =
+  async (): Promise<StreamingDemoAccountCredentials | null> => {
+    const response = await fetch(GRAPH_QL_ENDPOINT, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Lightspark-Beta": "z2h0BBYxTA83cjW7fi8QwWtBPCzkQKiemcuhKY08LOo",
+      },
+      body: JSON.stringify({
+        query: `mutation DemoAccountReserve {
+          DEMO_reserve_streaming_sats_account(input: { extension_id: "${await getInstanceID()}" }) {
+            signing_private_key
+            sender_node_id
+            receiver_node_id
+            client_secret
+            api_token {
+              id
+              client_id
+              name
+            }
+            expires_at
+            allocation_time
+          }
+        }`,
+        operationName: "DemoAccountReserve",
+      }),
+    });
+    if (!response.ok) {
+      console.error("Failed to reserve demo account", response.statusText);
+      return null;
+    }
+    const responseJson = await response.json();
+    const data = responseJson.data.DEMO_reserve_streaming_sats_account;
+    if (!data) {
+      console.error(
+        "Failed to reserve demo account",
+        JSON.stringify(responseJson.errors)
+      );
+      return null;
+    }
+    return {
+      clientId: data.api_token.client_id,
+      clientSecret: data.client_secret,
+      viewerWalletId: data.sender_node_id,
+      creatorWalletId: data.receiver_node_id,
+      viewerSigningKey: data.signing_private_key,
+      apiTokenId: data.api_token.id,
+      expiresAt: dayjs.utc(data.expires_at).utc().valueOf(),
+      allocationTime: data.allocation_time,
+    };
+  };
+
+export const unreserveStreamingDemoAccountCredentials = async (
+  credentials: StreamingDemoAccountCredentials
+): Promise<void> => {
+  await fetch(GRAPH_QL_ENDPOINT, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Lightspark-Beta": "z2h0BBYxTA83cjW7fi8QwWtBPCzkQKiemcuhKY08LOo",
+    },
+    body: JSON.stringify({
+      query: `mutation DemoAccountUnreserve {
+        DEMO_unreserve_streaming_sats_account(input: {
+          extension_id: "${await getInstanceID()}"
+          api_token_id: "${credentials.apiTokenId}"
+        }) {
+          success
+        }
+      }`,
+      operationName: "DemoAccountUnreserve",
+    }),
+  });
+};

package/examples/streaming-wallet-extension/src/auth/StreamingDemoCredentials.ts

@@ -0,0 +1,10 @@
+export default interface StreamingDemoAccountCredentials {
+  clientId: string;
+  clientSecret: string;
+  viewerWalletId: string;
+  creatorWalletId: string;
+  viewerSigningKey: string;
+  apiTokenId: string;
+  expiresAt: number;
+  allocationTime: string;
+}

package/examples/streaming-wallet-extension/src/background/PaymentStrategy.ts

@@ -0,0 +1,36 @@
+import PlaybackRange from "./PlaybackRange";
+
+export interface PaymentStrategy {
+  onPlayedRange(
+    previousRanges: PlaybackRange[],
+    newRanges: PlaybackRange[]
+  ): number;
+}
+
+export class LinearPaymentStrategy implements PaymentStrategy {
+  private readonly paymentPerChunkMsats: number;
+  private readonly chunkSizeSec: number;
+
+  constructor(paymentPerChunkMsats: number, chunkSizeSec: number) {
+    this.paymentPerChunkMsats = paymentPerChunkMsats;
+    this.chunkSizeSec = chunkSizeSec;
+  }
+
+  private numberOfChunksInRanges(ranges: PlaybackRange[]): number {
+    const totalDuration = ranges.reduce(
+      (acc, range) => acc + range.duration(),
+      0
+    );
+    return Math.ceil(totalDuration / this.chunkSizeSec);
+  }
+
+  onPlayedRange(
+    previousRanges: PlaybackRange[],
+    newRanges: PlaybackRange[]
+  ): number {
+    const newChunks = this.numberOfChunksInRanges(newRanges);
+    const previousChunks = this.numberOfChunksInRanges(previousRanges);
+    const chunkDiff = newChunks - previousChunks;
+    return this.paymentPerChunkMsats * chunkDiff;
+  }
+}

package/examples/streaming-wallet-extension/src/background/PlaybackRange.ts

@@ -0,0 +1,31 @@
+class PlaybackRange {
+  start: number;
+  end: number;
+
+  constructor(start: number, end: number) {
+    this.start = start;
+    this.end = end;
+  }
+
+  mergeWith(other: PlaybackRange) {
+    let start = this.start;
+    let end = this.end;
+    if (other.start < this.start) {
+      start = other.start;
+    }
+    if (other.end > this.end) {
+      end = other.end;
+    }
+    return new PlaybackRange(start, end);
+  }
+
+  isOverlapping(other: PlaybackRange) {
+    return this.start <= other.end && this.end >= other.start;
+  }
+
+  duration() {
+    return this.end - this.start;
+  }
+}
+
+export default PlaybackRange;

package/examples/streaming-wallet-extension/src/background/StreamingInvoiceHolder.ts

@@ -0,0 +1,33 @@
+import { InvoiceType, LightsparkClient } from "@lightsparkdev/lightspark-sdk";
+import autoBind from "auto-bind";
+
+class StreamingInvoiceHolder {
+  constructor() {
+    autoBind(this);
+  }
+
+  public async createInvoice(
+    lightsparkClient: LightsparkClient,
+    creatorWalletId: string
+  ): Promise<String | undefined> {
+    const encodedInvoice = await lightsparkClient.createInvoice(
+      creatorWalletId,
+      0,
+      "Streaming demo",
+      InvoiceType.AMP
+    );
+    await chrome.storage.local.set({ streamingInvoice: encodedInvoice });
+    return encodedInvoice;
+  }
+
+  public async getInvoiceData(): Promise<string | undefined> {
+    return (await chrome.storage.local.get("streamingInvoice"))
+      .streamingInvoice;
+  }
+
+  public async clearInvoice(): Promise<void> {
+    return await chrome.storage.local.remove("streamingInvoice");
+  }
+}
+
+export default StreamingInvoiceHolder;

package/examples/streaming-wallet-extension/src/background/TransactionObserver.ts

@@ -0,0 +1,66 @@
+import { LightsparkClient, Transaction } from "@lightsparkdev/lightspark-sdk";
+import autoBind from "auto-bind";
+import { Subscription } from "zen-observable-ts";
+import { findActiveStreamingDemoTabs } from "../common/streamingTabs";
+
+class TransactionObserver {
+  private isListening = false;
+  private subscription?: Subscription;
+  private readonly cachedTransactions = new Map<string, Transaction>();
+
+  constructor(private readonly lightsparkClient: LightsparkClient) {
+    autoBind(this);
+  }
+
+  public startListening(nodeId: string) {
+    console.log("Starting listening for transactions...");
+    if (this.isListening) {
+      return;
+    }
+
+    this.isListening = true;
+    this.subscription = this.lightsparkClient
+      .listenToTransactions([nodeId])
+      .subscribe({
+        next: (transaction) => {
+          if (transaction) {
+            this.broadcastTransactions([transaction]);
+          }
+        },
+      });
+  }
+
+  public clearCache() {
+    this.cachedTransactions.clear();
+  }
+
+  public stopListening() {
+    console.log("Stopping listening for transactions...");
+    if (!this.isListening || !this.subscription) {
+      return;
+    }
+
+    this.isListening = false;
+    this.subscription.unsubscribe();
+    this.subscription = undefined;
+  }
+
+  private async broadcastTransactions(transactions: Transaction[]) {
+    transactions.forEach((transaction) => {
+      this.cachedTransactions.set(transaction.id, transaction);
+    });
+    findActiveStreamingDemoTabs().then((tabs) => {
+      if (tabs.length === 0) return;
+      chrome.tabs.sendMessage(tabs[0].id!, {
+        id: "transactions_updated",
+        transactions,
+      });
+    });
+    chrome.runtime.sendMessage({
+      id: "transactions_updated",
+      transactions: Array.from(this.cachedTransactions.values()),
+    });
+  }
+}
+
+export default TransactionObserver;

package/examples/streaming-wallet-extension/src/background/VideoPlaybackRanges.ts

@@ -0,0 +1,38 @@
+import PlaybackRange from "./PlaybackRange";
+
+class VideoPlaybackRanges {
+  private playedRanges: Array<PlaybackRange> = [];
+
+  addPlayedRange(start: number, end: number) {
+    if (start > end) return;
+    const newRange = new PlaybackRange(start, end);
+    if (!this.mergeOverlappingRangeIfApplicable(newRange)) {
+      this.playedRanges.push(newRange);
+    }
+  }
+
+  mergeOverlappingRangeIfApplicable(playbackRange: PlaybackRange): boolean {
+    for (let i = 0; i < this.playedRanges.length; i++) {
+      let range = this.playedRanges[i];
+      if (range.isOverlapping(playbackRange)) {
+        this.playedRanges[i] = range.mergeWith(playbackRange);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  getPlayedRanges() {
+    return this.playedRanges;
+  }
+
+  getPlayedDuration() {
+    let duration = 0;
+    this.playedRanges.forEach((range) => {
+      duration += range.end - range.start;
+    });
+    return duration;
+  }
+}
+
+export default VideoPlaybackRanges;

package/examples/streaming-wallet-extension/src/background/VideoProgressCache.ts

@@ -0,0 +1,87 @@
+import PlaybackRangesTracker from "./VideoPlaybackRanges";
+
+class VideoProgressCache {
+  private videoProgressCache: { [videoID: string]: PlaybackRangesTracker };
+  private listeners: Array<(videoID: string) => void> = [];
+  private resolveWhenLoaded: () => void = () => {};
+  private whenLoadedPromise = new Promise<void>((resolve) => {
+    this.resolveWhenLoaded = resolve;
+  });
+
+  constructor() {
+    this.videoProgressCache = {};
+    this.readProgressFromStorage();
+  }
+
+  public async whenLoaded() {
+    return this.whenLoadedPromise;
+  }
+
+  public clear() {
+    this.videoProgressCache = {};
+    this.writeProgressToStorage();
+  }
+
+  addProgress(videoID: string, start: number, end: number) {
+    if (!this.videoProgressCache[videoID]) {
+      this.videoProgressCache[videoID] = new PlaybackRangesTracker();
+    }
+    this.videoProgressCache[videoID].addPlayedRange(start, end);
+    console.log(`Added progress for ${videoID}: ${start} - ${end}`);
+    console.log(
+      `Current ranges: ${JSON.stringify(
+        this.videoProgressCache[videoID].getPlayedRanges()
+      )}`
+    );
+    this.listeners.forEach((listener) => listener(videoID));
+    this.writeProgressToStorage();
+  }
+
+  listenForProgressChanges(listener: (videoID: string) => void) {
+    this.listeners.push(listener);
+  }
+
+  getPlayedDuration(videoID: string) {
+    if (!this.videoProgressCache[videoID]) {
+      return 0;
+    }
+    return this.videoProgressCache[videoID].getPlayedDuration();
+  }
+
+  getPlayedRanges(videoID: string) {
+    if (!this.videoProgressCache[videoID]) {
+      return [];
+    }
+    return this.videoProgressCache[videoID].getPlayedRanges();
+  }
+
+  readProgressFromStorage() {
+    chrome.storage.local.get(null, (result) => {
+      Object.keys(result).forEach((key) => {
+        if (key.startsWith("video_")) {
+          const videoID = key.replace("video_", "");
+          const videoRanges = result[key]["playedRanges"];
+          this.videoProgressCache[videoID] = new PlaybackRangesTracker();
+          videoRanges.forEach((range: any) => {
+            this.videoProgressCache[videoID].addPlayedRange(
+              range.start,
+              range.end
+            );
+          });
+        }
+      });
+      this.resolveWhenLoaded();
+    });
+  }
+
+  writeProgressToStorage() {
+    const newEntrys: any = {};
+    Object.keys(this.videoProgressCache).forEach((videoID) => {
+      const videoRanges = this.videoProgressCache[videoID];
+      newEntrys[`video_${videoID}`] = videoRanges;
+    });
+    chrome.storage.local.set(newEntrys);
+  }
+}
+
+export default VideoProgressCache;

package/examples/streaming-wallet-extension/src/background/background.ts

@@ -0,0 +1,145 @@
+import {
+  AccountTokenAuthProvider,
+} from "@lightsparkdev/lightspark-sdk";
+import AccountStorage from "../auth/AccountStorage";
+import { unreserveStreamingDemoAccountCredentials } from "../auth/DemoAccountProvider";
+import StreamingDemoAccountCredentials from "../auth/StreamingDemoCredentials";
+import { clearStorageKeepingInstanceId } from "../common/storage";
+import { findActiveStreamingDemoTabs } from "../common/streamingTabs";
+import { getWalletClient } from "../lightsparkClientProvider";
+import { onMessageReceived } from "./messageHandling";
+import StreamingInvoiceHolder from "./StreamingInvoiceHolder";
+import TransactionObserver from "./TransactionObserver";
+import VideoProgressCache from "./VideoProgressCache";
+import { StubAuthProvider } from "@lightsparkdev/core";
+
+const progressCache = new VideoProgressCache();
+const accountStorage = new AccountStorage();
+const invoiceHolder = new StreamingInvoiceHolder();
+const lightsparkClient = getWalletClient(accountStorage);
+const transactionObserver = lightsparkClient.then(
+  (client) => new TransactionObserver(client)
+);
+let lastKnownStreamingTabId: number | undefined;
+
+const setStreamingTabIdIfSender = (
+  message: { id: string },
+  sender: chrome.runtime.MessageSender
+) => {
+  if (
+    message.id === "video_details" &&
+    sender.url?.includes("demos/streaming") &&
+    sender.tab &&
+    sender.tab?.id
+  ) {
+    lastKnownStreamingTabId = sender.tab.id;
+  }
+};
+
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  Promise.all([lightsparkClient, transactionObserver]).then(
+    ([lightsparkClient, transactionObserver]) => {
+      setStreamingTabIdIfSender(message, sender);
+      onMessageReceived(
+        message,
+        lightsparkClient,
+        progressCache,
+        invoiceHolder,
+        accountStorage,
+        transactionObserver,
+        sendResponse
+      );
+    }
+  );
+  return true;
+});
+
+chrome.runtime.onMessageExternal.addListener(
+  (message, sender, sendResponse) => {
+    Promise.all([lightsparkClient, transactionObserver]).then(
+      ([lightsparkClient, transactionObserver]) => {
+        setStreamingTabIdIfSender(message, sender);
+        onMessageReceived(
+          message,
+          lightsparkClient,
+          progressCache,
+          invoiceHolder,
+          accountStorage,
+          transactionObserver,
+          sendResponse
+        );
+      }
+    );
+    return true;
+  }
+);
+
+const reloadOrOpenStreamingDemo = (openIfMissing: boolean = true) => {
+  findActiveStreamingDemoTabs().then(async (tabs) => {
+    console.log(`Found ${tabs.length} tabs to reload.`);
+    if (tabs.length > 0) {
+      chrome.tabs.update(tabs[0].id!, { active: true, highlighted: true });
+      chrome.tabs.reload(tabs[0].id!);
+      lastKnownStreamingTabId = tabs[0].id;
+    } else if (openIfMissing) {
+      // TODO: Replace with the final URL.
+      const newTab = await chrome.tabs.create({
+        url: "https://app.lightspark.com/demos/streaming",
+        active: true,
+      });
+      lastKnownStreamingTabId = newTab.id;
+    }
+  });
+};
+
+chrome.runtime.onInstalled.addListener((details) => {
+  if (details.reason === "install") {
+    reloadOrOpenStreamingDemo();
+  }
+});
+
+chrome.storage.local.onChanged.addListener((changes) => {
+  if (changes["credentials"]) {
+    console.log("Credentials changed, reloading tabs.");
+    lightsparkClient.then(async (lightsparkClient) => {
+      const credentials = changes["credentials"]
+        .newValue as StreamingDemoAccountCredentials;
+      if (credentials) {
+        lightsparkClient.setAuthProvider(
+          new AccountTokenAuthProvider(
+            credentials.clientId,
+            credentials.clientSecret
+          )
+        );
+        await lightsparkClient.loadNodeKey(
+          credentials.viewerWalletId,
+          credentials.viewerSigningKey
+        );
+        await invoiceHolder
+          .createInvoice(lightsparkClient, credentials.creatorWalletId)
+          .then((invoice) => {
+            console.log(`Created invoice: ${invoice}`);
+          });
+      } else {
+        await lightsparkClient.setAuthProvider(new StubAuthProvider());
+        await invoiceHolder.clearInvoice();
+      }
+      reloadOrOpenStreamingDemo(!!credentials);
+    });
+    return true;
+  }
+  return false;
+});
+
+chrome.tabs.onRemoved.addListener(async (tabId, _removeInfo) => {
+  if (tabId === lastKnownStreamingTabId) {
+    lastKnownStreamingTabId = undefined;
+    const account = await accountStorage.getAccountCredentials();
+    if (account) {
+      await unreserveStreamingDemoAccountCredentials(account);
+    }
+    await clearStorageKeepingInstanceId();
+    progressCache.clear();
+    (await transactionObserver).clearCache();
+  }
+});