@playdotfun/game-sdk 1.0.0

package/src/sdk/messaging.ts

@@ -0,0 +1,50 @@
+import { SDKEvents } from '@/types';
+
+export default (eventHandler: EventTarget) => {
+  function emit(evt: SDKEvents | '*', data?: Record<string, any>) {
+    const cEvent = new CustomEvent(evt, { detail: data });
+    console.debug(`[OpenGameSDK] Dispatching event: ${evt} to SDK handler`);
+    eventHandler.dispatchEvent(cEvent);
+
+    if (window) {
+      console.debug(`[OpenGameSDK] Dispatching event: ${evt} to window`);
+      window.dispatchEvent(cEvent);
+    }
+
+    const globalEvent = new CustomEvent('*', {
+      detail: {
+        name: evt,
+        data,
+      },
+    });
+
+    console.debug(`[OpenGameSDK] Dispatching global event: ${globalEvent.detail} to SDK handler`);
+    eventHandler.dispatchEvent(globalEvent);
+    if (window) {
+      console.debug('[OpenGameSDK] Dispatching global event:', globalEvent.detail, 'to window');
+      window.dispatchEvent(globalEvent);
+    }
+  }
+  function on(event: SDKEvents, callback: (event: CustomEvent) => void) {
+    console.debug('[OpenGameSDK] Adding event listener for event:', event);
+    eventHandler.addEventListener(event, (e: Event) => callback(e as CustomEvent));
+  }
+  function off(event: SDKEvents | '*', callback: (event: CustomEvent) => void) {
+    console.debug('[OpenGameSDK] Removing event listener for event:', event);
+    eventHandler.removeEventListener(event, callback as EventListener);
+  }
+  function onAll(callback: (event: SDKEvents, data?: Record<string, any>) => void) {
+    console.debug('[OpenGameSDK] Adding event listener for all events');
+    eventHandler.addEventListener('*', (e: Event) => {
+      const { name, data } = (e as CustomEvent).detail;
+      callback(name as SDKEvents, data);
+    });
+  }
+
+  return {
+    emit,
+    on,
+    off,
+    onAll,
+  };
+};

package/src/sdk/obfuscation.ts

@@ -0,0 +1,74 @@
+const k7x = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+function m9q(s: string) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) h = (h * 33) ^ s.charCodeAt(i);
+  return h >>> 0;
+}
+function w3r(n: number) {
+  let x = n || 2463534242;
+  return () => {
+    x ^= x << 13;
+    x ^= x >>> 17;
+    x ^= x << 5;
+    return (x >>> 0) / 0x100000000;
+  };
+}
+function p8t(k: string) {
+  const a = k7x.split('');
+  const r = w3r(m9q(k));
+  for (let i = a.length - 1; i > 0; i--) {
+    const j = Math.floor(r() * (i + 1));
+    [a[i], a[j]] = [a[j], a[i]];
+  }
+  return a.join('');
+}
+function l5n(s: string, f: string, t: string) {
+  const m = new Map<string, string>();
+  for (let i = 0; i < f.length; i++) m.set(f[i], t[i]);
+  let o = '';
+  for (const c of s) o += m.get(c) ?? c;
+  return o;
+}
+function d2v(s: string, z = 6, p = '-') {
+  const x = [];
+  for (let i = 0; i < s.length; i += z) x.push(s.slice(i, i + z));
+  return x.join(p);
+}
+function g6h(s: string, p = '-') {
+  return s.split(p).join('');
+}
+function q1u(b: Buffer, k: Buffer) {
+  const o = Buffer.allocUnsafe(b.length);
+  for (let i = 0; i < b.length; i++) o[i] = b[i] ^ k[i % k.length];
+  return o;
+}
+export function encodePointsObf(points: number, key = 'default_obf_key') {
+  if (!Number.isFinite(points)) throw new Error('points must be finite number');
+  const y = `${points}:${Date.now()}`;
+  const yb = Buffer.from(y, 'utf8');
+  const kb = Buffer.from(key, 'utf8');
+  const x = q1u(yb, kb);
+  const b = x.toString('base64');
+  const s = p8t(key);
+  const m = l5n(b, k7x, s);
+  const t = d2v(m.split('').reverse().join(''), 6, '-');
+  return t;
+}
+export function decodePointsObf(token: string, key = 'default_obf_key') {
+  try {
+    const c = g6h(token, '-');
+    const u = c.split('').reverse().join('');
+    const s = p8t(key);
+    const b = l5n(u, s, k7x);
+    const x = Buffer.from(b, 'base64');
+    const kb = Buffer.from(key, 'utf8');
+    const yb = q1u(x, kb);
+    const y = yb.toString('utf8');
+    const [v] = y.split(':');
+    const n = Number(v);
+    if (!Number.isFinite(n)) throw new Error('invalid payload');
+    return n;
+  } catch (e) {
+    throw new Error('Failed to decode obfuscated token');
+  }
+}

package/src/types.ts

@@ -0,0 +1,67 @@
+export type {
+  SDKOpts,
+  SDKState,
+  Token,
+  Game,
+  Theme,
+  Session,
+  Context,
+  ListUserRewardsResponse,
+  ClaimRewardsResponse,
+  PromiseResolveFn,
+  User,
+} from '@play-fun/types/sdk';
+
+export {
+  WidgetScreen,
+  SDKMessages,
+  CarouselMessages,
+  WidgetMessages,
+  SDKEvents,
+  SDKActions,
+  WidgetActions,
+  CarouselActions,
+} from '@play-fun/types/sdk';
+
+export interface PaginatedFetchOpts {
+  limit?: number;
+  cursor?: string;
+  sort?: string;
+  sortBy?: string;
+  query?: string;
+}
+
+export type RecursivePartial<T> = {
+  [P in keyof T]?: RecursivePartial<T[P]>;
+};
+
+// Flush protocol types
+export interface FlushState {
+  seq: number;
+  currentHash: string;
+  stepKey: string;
+  totalPoints: number;
+  initialized: boolean;
+}
+
+export interface FlushResponse {
+  seq: number;
+  newHash: string;
+  nextStepKey: string;
+  total: number;
+  added: number;
+  duplicate?: boolean;
+}
+
+export interface CommitResponse {
+  saved: number;
+  status: 'accepted' | 'pending_review';
+  riskScore?: number;
+}
+
+export interface SessionStateResponse {
+  lastSeq: number;
+  lastHash: string;
+  stepKey: string;
+  totalPoints: number;
+}

package/src/widget/bridge.ts

@@ -0,0 +1,157 @@
+import config, { isDevOrigin } from '@/config';
+import {
+  PromiseResolveFn,
+  SDKActions,
+  SDKMessages,
+  Theme,
+  WidgetActions,
+  WidgetMessages,
+} from '@/types';
+import { UpwardsDashboardActions, UpwardDashboardMessages } from '@play-fun/types/sdk';
+import { DashboardBridge } from '@/dashboard/bridge';
+
+const sandbox = `
+  allow-same-origin 
+  allow-scripts 
+  allow-forms 
+  allow-popups 
+  allow-modals 
+  allow-downloads
+  allow-top-navigation 
+  allow-top-navigation-by-user-activation
+`;
+
+const initialStyle = {
+  display: 'none',
+  width: '100%',
+  height: '100%',
+  position: 'fixed',
+  zIndex: '9999',
+  background: 'transparent',
+  padding: '0',
+  margin: '0',
+  top: '0',
+  left: '0',
+  border: 'none',
+};
+
+export class WidgetBridge {
+  private style: Partial<CSSStyleDeclaration> = { ...initialStyle };
+
+  private widgetIFrame: HTMLIFrameElement;
+
+  private widgetElementResolver?: PromiseResolveFn;
+  private widgetElementPromise = new Promise((resolve) => (this.widgetElementResolver = resolve));
+
+  private widgetReadyResolver?: PromiseResolveFn;
+  private widgetReadyPromise = new Promise((resolve) => (this.widgetReadyResolver = resolve));
+
+  private widgetReady = false;
+
+  constructor(
+    private handleWidgetMessage: (msg: WidgetMessages) => void,
+    private url = config.widgetURL,
+  ) {
+    window.addEventListener('message', (e) => {
+      const originHostname = new URL(e.origin).hostname;
+      const isValidOrigin =
+        e.origin === config.widgetURL ||
+        (config.dashboardURL && e.origin === config.dashboardURL) ||
+        isDevOrigin(originHostname);
+      if (isValidOrigin) {
+        this._handleWidgetActions(e.data);
+      }
+    });
+
+    this.widgetIFrame = document.createElement('iframe') as HTMLIFrameElement;
+    this.widgetIFrame.sandbox.value = sandbox;
+    this._updateStyle(initialStyle);
+  }
+
+  async init(target: HTMLElement = document.body, url?: string) {
+    this.widgetIFrame.src = url ?? this.url;
+    this.widgetIFrame.onload = () => {
+      this.widgetElementResolver?.({});
+    };
+    this._waitForWidgetReady();
+    target.appendChild(this.widgetIFrame);
+    await Promise.all([this.widgetElementPromise, this.widgetReadyPromise]);
+  }
+
+  sendMessage(msg: SDKMessages) {
+    if (this.widgetIFrame.contentWindow) {
+      console.log(`Sending message to widget: ${msg.action}`);
+      const targetOrigin = new URL(this.url).origin;
+      this.widgetIFrame.contentWindow.postMessage(msg, targetOrigin);
+    } else {
+      console.warn(`No contentWindow found for widget iframe. Message not sent: ${msg.action}`);
+    }
+  }
+
+  show(extraStyle?: Partial<CSSStyleDeclaration>) {
+    this._updateStyle({
+      display: 'block',
+      ...extraStyle,
+    });
+  }
+
+  hide() {
+    this._updateStyle({ ...initialStyle });
+  }
+
+  setTheme(theme: Theme) {
+    this.sendMessage({
+      action: SDKActions.UI_SetTheme,
+      data: theme,
+    });
+  }
+
+  private _updateStyle = (style: Partial<CSSStyleDeclaration>) => {
+    this.style = {
+      ...this.style,
+      ...style,
+    };
+    Object.keys(style).forEach((styleKey) => {
+      // @ts-ignore
+      this.widgetIFrame.style[styleKey] = style[styleKey];
+    });
+  };
+
+  private _handleWidgetActions(msg: WidgetMessages | UpwardDashboardMessages) {
+    console.log('Handling Widget Action:', msg.action);
+
+    // Check if this is an UpwardsDashboardAction that should be forwarded to the dashboard
+    const isUpwardsDashboardAction = Object.values(UpwardsDashboardActions).includes(
+      msg.action as UpwardsDashboardActions,
+    );
+    if (isUpwardsDashboardAction) {
+      console.log('Forwarding UpwardsDashboardAction to dashboard:', msg.action);
+      DashboardBridge.sendMessage(msg as UpwardDashboardMessages);
+      return;
+    }
+
+    const isValidAction = Object.values(WidgetActions).includes(msg.action as WidgetActions);
+    if (isValidAction) {
+      if (msg.action === WidgetActions.WidgetReady) {
+        console.log('Widget is ready!');
+        this.widgetReady = true;
+        this.widgetReadyResolver?.({});
+      } else {
+        this.handleWidgetMessage(msg as WidgetMessages);
+      }
+    }
+  }
+
+  private _waitForWidgetReady() {
+    if (this.widgetReady) {
+      return;
+    }
+    this.sendMessage({
+      action: SDKActions.CheckForWidgetReady,
+      data: undefined,
+    });
+    setTimeout(() => {
+      this._waitForWidgetReady();
+    }, 250);
+  }
+}

package/src/widget/messages.ts

@@ -0,0 +1,45 @@
+import OpenGameSDK from '@/sdk';
+import { SDKActions, WidgetActions, WidgetMessages } from '@/types';
+import { DashboardActions, DashboardMessages } from '@play-fun/types/sdk';
+
+export const handleWidgetMessage = async (self: OpenGameSDK, msg: WidgetMessages | DashboardMessages) => {
+  console.log(`Received widget message: ${msg.action}`, msg.data);
+
+  switch (msg.action) {
+    case WidgetActions.SetPrivyToken:
+      console.log('[WidgetBridge] Received Privy token');
+      self.handlePrivyTokenResponse(msg.data.privyAccessToken, msg.data.requestId);
+      return;
+    case WidgetActions.EnableView:
+      const heightValue =
+        typeof msg.data?.height === 'number'
+          ? `${msg.data.height}px`
+          : (msg.data?.height ?? '100%');
+      return self.widget?.show({
+        height: heightValue,
+        maxHeight: heightValue,
+      });
+    case WidgetActions.DisableView:
+      self.widget?.hide();
+      if (self.pointsDisplay?.show) {
+        setTimeout(() => {
+          self.showPoints();
+        });
+      }
+      break;
+    case WidgetActions.SetIdentityToken:
+      return self.setIdentityToken(msg.data);
+
+    case WidgetActions.SetPlayerId:
+      console.log('[WidgetBridge] Setting player ID:', msg.data);
+      if (!self.gameId) {
+        throw new Error('No game ID found. Cannot set player ID.');
+      }
+      const { playerId, privyAccessToken } = msg.data;
+      // Don't set playerId here - loadGame will set it from server response
+      // Setting it before loadGame causes the early-return check to trigger
+      return self.loadGame(self.gameId, playerId, privyAccessToken);
+    case WidgetActions.ShowClaim:
+      return self.showClaim();
+  }
+};

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "es2022",
+    "moduleResolution": "node",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "declaration": true,
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    },
+    "lib": ["DOM", "ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": false,
+    "forceConsistentCasingInFileNames": true,
+  },
+  "include": ["./src/**/*",],
+  "exclude": ["node_modules", "dist", "*.config.ts"]
+}

package/tsup.config.ts

@@ -0,0 +1,77 @@
+import { defineConfig } from 'tsup';
+import { config } from 'dotenv';
+config();
+
+export default defineConfig([
+  {
+    entry: ['src/index.ts'],
+    format: ['esm', 'cjs'],
+    dts: true,
+    splitting: false,
+    sourcemap: true,
+    clean: true,
+    minify: false,
+    treeshake: true,
+    target: 'es2022',
+    outDir: 'dist',
+    platform: 'node',
+    esbuildOptions(options) {
+      options.define = {
+        'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || 'production'),
+        'process.env.OGP_API_URL': JSON.stringify(
+          process.env.OGP_API_URL || 'https://api.play.fun',
+        ),
+        'process.env.OGP_DASHBOARD_WIDGET_URL': JSON.stringify(
+          process.env.OGP_DASHBOARD_WIDGET_URL || '',
+        ),
+        'process.env.OGP_CAROUSEL_URL': JSON.stringify(
+          process.env.OGP_CAROUSEL_URL || 'https://carousel.play.fun',
+        ),
+        'process.env.OGP_WIDGET_URL': JSON.stringify(
+          process.env.OGP_WIDGET_URL || 'https://widget.play.fun',
+        ),
+      };
+    },
+  },
+  {
+    entry: { sdk: 'src/index.ts' },
+    format: ['iife'],
+    globalName: 'OpenGameSDK',
+    outDir: 'dist',
+    outExtension: () => ({ js: '.js' }),
+    platform: 'browser',
+    target: 'es2020',
+    clean: true,
+    dts: true,
+    sourcemap: true,
+    bundle: true,
+    minify: false,
+    inject: ['src/buffer-shim.ts'],
+    noExternal: ['@play-fun/types'],
+    esbuildOptions(options) {
+      options.alias = {
+        '@': './src',
+      };
+      options.define = {
+        'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || 'production'),
+        'process.env.OGP_API_URL': JSON.stringify(
+          process.env.OGP_API_URL || 'https://api.play.fun',
+        ),
+        'process.env.OGP_DASHBOARD_URL': JSON.stringify(process.env.OGP_DASHBOARD_URL || ''),
+        'process.env.OGP_CAROUSEL_URL': JSON.stringify(
+          process.env.OGP_CAROUSEL_URL || 'https://carousel.play.fun',
+        ),
+        'process.env.OGP_WIDGET_URL': JSON.stringify(
+          process.env.OGP_WIDGET_URL || 'https://widget.play.fun',
+        ),
+      };
+      options.footer = {
+        js: 'OpenGameSDK = OpenGameSDK.default;',
+      };
+      // options.pure =
+      //   process.env.NODE_ENV === 'production'
+      //     ? ['console.log', 'console.debug', 'console.info']
+      //     : [];
+    },
+  },
+]);