@phantom/utils 1.0.0-beta.19

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Self-contained UUID v4 implementation for Phantom Wallet SDK
+ * No external dependencies to avoid ES module compatibility issues
+ */
+/**
+ * Generate a random UUID v4 string
+ * RFC 4122 compliant UUID version 4
+ * @returns A UUID v4 string in the format xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
+ */
+declare function randomUUID(): string;
+/**
+ * Generate a random string of specified length using alphanumeric characters
+ * @param length - The length of the string to generate
+ * @returns A random alphanumeric string
+ */
+declare function randomString(length: number): string;
+
+/**
+ * Secure time service that fetches server time from Phantom's time API
+ * instead of relying on local machine time which can be manipulated
+ */
+declare const getSecureTimestamp: () => Promise<number>;
+declare const getSecureTimestampSync: () => number;
+
+/**
+ * Network utility functions for working with blockchain network identifiers
+ */
+declare function isEthereumChain(networkId: string): boolean;
+declare function getChainPrefix(networkId: string): string;
+
+export { getChainPrefix, getSecureTimestamp, getSecureTimestampSync, isEthereumChain, randomString, randomUUID };

package/dist/index.js

@@ -0,0 +1,135 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  getChainPrefix: () => getChainPrefix,
+  getSecureTimestamp: () => getSecureTimestamp,
+  getSecureTimestampSync: () => getSecureTimestampSync,
+  isEthereumChain: () => isEthereumChain,
+  randomString: () => randomString,
+  randomUUID: () => randomUUID
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/uuid.ts
+function randomUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function randomString(length) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+
+// src/time.ts
+var TimeService = class {
+  constructor() {
+    this.cache = null;
+    this.CACHE_DURATION = 3e4;
+    // 30 seconds cache
+    this.TIME_API_URL = "https://time.phantom.app/utc";
+  }
+  static getInstance() {
+    if (!TimeService.instance) {
+      TimeService.instance = new TimeService();
+    }
+    return TimeService.instance;
+  }
+  /**
+   * Get current timestamp from Phantom's secure time API
+   * Includes basic caching to reduce API calls
+   */
+  async now() {
+    const now = Date.now();
+    if (this.cache && now - this.cache.fetchedAt < this.CACHE_DURATION) {
+      const elapsed = now - this.cache.fetchedAt;
+      return this.cache.timestamp + elapsed;
+    }
+    try {
+      const response = await fetch(this.TIME_API_URL);
+      if (!response.ok) {
+        throw new Error(`Time API responded with status: ${response.status}`);
+      }
+      const timestampText = await response.text();
+      const timestamp = parseInt(timestampText, 10);
+      if (isNaN(timestamp)) {
+        throw new Error(`Invalid timestamp received: ${timestampText}`);
+      }
+      this.cache = {
+        timestamp,
+        fetchedAt: now
+      };
+      return timestamp;
+    } catch (error) {
+      return Date.now();
+    }
+  }
+  /**
+   * Synchronous version that uses cached time if available,
+   * otherwise falls back to Date.now()
+   */
+  nowSync() {
+    if (this.cache) {
+      const elapsed = Date.now() - this.cache.fetchedAt;
+      if (elapsed < this.CACHE_DURATION) {
+        return this.cache.timestamp + elapsed;
+      }
+    }
+    return Date.now();
+  }
+  /**
+   * Clear the cache (useful for testing)
+   */
+  clearCache() {
+    this.cache = null;
+  }
+};
+var timeService = TimeService.getInstance();
+var getSecureTimestamp = () => timeService.now();
+var getSecureTimestampSync = () => timeService.nowSync();
+
+// src/network.ts
+function isEthereumChain(networkId) {
+  const network = networkId.split(":")[0].toLowerCase();
+  return network === "eip155";
+}
+function getChainPrefix(networkId) {
+  return networkId.split(":")[0].toLowerCase();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getChainPrefix,
+  getSecureTimestamp,
+  getSecureTimestampSync,
+  isEthereumChain,
+  randomString,
+  randomUUID
+});

package/dist/index.mjs

@@ -0,0 +1,103 @@
+// src/uuid.ts
+function randomUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function randomString(length) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+
+// src/time.ts
+var TimeService = class {
+  constructor() {
+    this.cache = null;
+    this.CACHE_DURATION = 3e4;
+    // 30 seconds cache
+    this.TIME_API_URL = "https://time.phantom.app/utc";
+  }
+  static getInstance() {
+    if (!TimeService.instance) {
+      TimeService.instance = new TimeService();
+    }
+    return TimeService.instance;
+  }
+  /**
+   * Get current timestamp from Phantom's secure time API
+   * Includes basic caching to reduce API calls
+   */
+  async now() {
+    const now = Date.now();
+    if (this.cache && now - this.cache.fetchedAt < this.CACHE_DURATION) {
+      const elapsed = now - this.cache.fetchedAt;
+      return this.cache.timestamp + elapsed;
+    }
+    try {
+      const response = await fetch(this.TIME_API_URL);
+      if (!response.ok) {
+        throw new Error(`Time API responded with status: ${response.status}`);
+      }
+      const timestampText = await response.text();
+      const timestamp = parseInt(timestampText, 10);
+      if (isNaN(timestamp)) {
+        throw new Error(`Invalid timestamp received: ${timestampText}`);
+      }
+      this.cache = {
+        timestamp,
+        fetchedAt: now
+      };
+      return timestamp;
+    } catch (error) {
+      return Date.now();
+    }
+  }
+  /**
+   * Synchronous version that uses cached time if available,
+   * otherwise falls back to Date.now()
+   */
+  nowSync() {
+    if (this.cache) {
+      const elapsed = Date.now() - this.cache.fetchedAt;
+      if (elapsed < this.CACHE_DURATION) {
+        return this.cache.timestamp + elapsed;
+      }
+    }
+    return Date.now();
+  }
+  /**
+   * Clear the cache (useful for testing)
+   */
+  clearCache() {
+    this.cache = null;
+  }
+};
+var timeService = TimeService.getInstance();
+var getSecureTimestamp = () => timeService.now();
+var getSecureTimestampSync = () => timeService.nowSync();
+
+// src/network.ts
+function isEthereumChain(networkId) {
+  const network = networkId.split(":")[0].toLowerCase();
+  return network === "eip155";
+}
+function getChainPrefix(networkId) {
+  return networkId.split(":")[0].toLowerCase();
+}
+export {
+  getChainPrefix,
+  getSecureTimestamp,
+  getSecureTimestampSync,
+  isEthereumChain,
+  randomString,
+  randomUUID
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@phantom/utils",
+  "version": "1.0.0-beta.19",
+  "description": "Utility functions for Phantom Wallet SDK",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "?pack-release": "When https://github.com/changesets/changesets/issues/432 has a solution we can remove this trick",
+    "pack-release": "rimraf ./_release && yarn pack && mkdir ./_release && tar zxvf ./package.tgz --directory ./_release && rm ./package.tgz",
+    "build": "rimraf ./dist && tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "lint": "tsc --noEmit && eslint --cache . --ext .ts,.tsx",
+    "check-types": "tsc --noEmit",
+    "prettier": "prettier --write \"src/**/*.{ts,tsx}\""
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.0",
+    "eslint": "8.53.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.5.2",
+    "rimraf": "^6.0.1",
+    "ts-jest": "^29.1.2",
+    "tsup": "^6.7.0",
+    "typescript": "^5.0.4"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "directory": "_release/package"
+  }
+}