@playdotfun/game-sdk 1.0.0

package/src/scripts/deploy.ts

@@ -0,0 +1,135 @@
+import { rejects } from 'assert';
+import AWS from 'aws-sdk';
+import { PutObjectRequest } from 'aws-sdk/clients/s3';
+import { exec } from 'child_process';
+import { readFile } from 'fs/promises';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const DEFAULT_FILE_NAME = 'sdk.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT_DIR = path.resolve(__dirname, '../../');
+const DIST_DIR = path.resolve(ROOT_DIR, 'dist');
+const S3_BUCKET = 'ogp-cdn';
+const S3_PREFIX = 'vanilla-js-sdk';
+const CDN_URL = 'https://sdk.play.fun';
+const CLOUDFRONT_DISTRIBUTION_ID = 'E2RUY7SDQK9F8Y';
+
+AWS.config.update({
+  region: 'us-east-1',
+});
+
+const s3 = new AWS.S3();
+
+const uploadToS3 = async (filePath: string, s3Key: string, ContentType?: string) => {
+  const fileData = await readFile(filePath);
+  const params: PutObjectRequest = {
+    Bucket: S3_BUCKET,
+    Key: `${S3_PREFIX}/${s3Key}`,
+    Body: fileData,
+  };
+
+  if (ContentType) {
+    params.ContentType = ContentType;
+  }
+
+  s3.upload(params, async (err, data) => {
+    if (err) {
+      console.error('Error uploading to S3:', err);
+      throw err;
+    }
+    await spawn('aws', [
+      'cloudfront',
+      'create-invalidation',
+      '--distribution-id',
+      CLOUDFRONT_DISTRIBUTION_ID,
+      '--paths',
+      '"/*"',
+    ]);
+    return data.Location;
+  });
+};
+
+const deploy = async (
+  deployLatest = false,
+  target: 'prod' | 'dev' | 'dev-mainnet' | 'staging' = 'prod',
+) => {
+  const filePath = path.resolve(DIST_DIR, DEFAULT_FILE_NAME);
+  const pkgVersion = JSON.parse(
+    await readFile(path.resolve(ROOT_DIR, 'package.json'), 'utf8'),
+  ).version;
+
+  let s3Key: string;
+  if (target === 'prod') {
+    // Prod goes to root
+    s3Key = deployLatest ? 'sdk.js' : `sdk.v${pkgVersion}.js`;
+  } else {
+    // Other targets go to subfolders
+    s3Key = deployLatest ? `${target}/sdk.js` : `${target}/sdk.v${pkgVersion}.js`;
+  }
+
+  console.log('Deploying to S3:', s3Key);
+  await uploadToS3(filePath, s3Key, 'application/javascript');
+
+  console.log('Deployed to S3: ' + `${CDN_URL}/${s3Key}`);
+  if (deployLatest) {
+    console.log('Deploying latest to S3');
+    const latestKey = target === 'prod' ? 'sdk.latest.js' : `${target}/sdk.latest.js`;
+
+    console.log('Deploying to S3:', latestKey);
+    await uploadToS3(filePath, latestKey, 'application/javascript');
+  }
+};
+
+const spawn = (cmd: string, args: string[], env: Record<string, string> = {}, verbose = false) =>
+  new Promise((resolve, reject) => {
+    const combinedEnv = Object.assign({}, process.env, env);
+    const cmdStr = `${cmd} ${args.join(' ')}`;
+    const runner = exec(cmdStr, { env: combinedEnv }, (err, stdout, stderr) => {
+      if (err) {
+        console.error(`Error running command: ${cmd} ${args.join(' ')}`);
+        return reject(err);
+      }
+      return resolve(stdout || stderr);
+    });
+
+    if (verbose) {
+      runner.stdout?.on('data', function (data) {
+        console.log('stdou:', data.toString());
+      });
+
+      runner.stderr?.on('data', function (data) {
+        console.log('stderr:', data.toString());
+      });
+    }
+  });
+
+const main = async (args: string[]) => {
+  let version = null;
+  let target: 'prod' | 'dev' | 'dev-mainnet' | 'staging' = 'prod';
+  let deployLatest = false;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case '--latest':
+      case '--deploy-latest':
+        deployLatest = true;
+        break;
+      case '--version':
+        version = args[i + 1];
+        break;
+      case '--target':
+        target = args[i + 1] as 'prod' | 'dev' | 'dev-mainnet' | 'staging';
+        break;
+    }
+  }
+
+  console.log('Starting deploy script with args:', { version, target, deployLatest });
+
+  deploy(deployLatest, target);
+};
+
+(async () => {
+  await main(process.argv);
+})();

package/src/sdk/crypto.ts

@@ -0,0 +1,51 @@
+/**
+ * Crypto utilities for points hardening
+ * Uses Web Crypto API for browser compatibility
+ */
+
+/**
+ * Compute HMAC-SHA256 signature
+ */
+export async function hmacSha256(key: string, data: string): Promise<string> {
+  const encoder = new TextEncoder();
+  const keyData = encoder.encode(key);
+  const dataBytes = encoder.encode(data);
+
+  const cryptoKey = await crypto.subtle.importKey(
+    'raw',
+    keyData,
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['sign'],
+  );
+
+  const signature = await crypto.subtle.sign('HMAC', cryptoKey, dataBytes);
+  return arrayBufferToHex(signature);
+}
+
+/**
+ * Compute SHA-256 hash
+ */
+export async function sha256(data: string): Promise<string> {
+  const encoder = new TextEncoder();
+  const dataBytes = encoder.encode(data);
+  const hashBuffer = await crypto.subtle.digest('SHA-256', dataBytes);
+  return arrayBufferToHex(hashBuffer);
+}
+
+/**
+ * Generate a random UUID (for nonces, client instance IDs, etc.)
+ */
+export function generateUUID(): string {
+  return crypto.randomUUID();
+}
+
+/**
+ * Convert ArrayBuffer to hex string
+ */
+function arrayBufferToHex(buffer: ArrayBuffer): string {
+  const bytes = new Uint8Array(buffer);
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
+}