@dcl/sdk 7.20.0 → 7.20.1-21975617794.commit-7189140

package/server/storage/constants.js

@@ -0,0 +1,2 @@
+export const MODULE_NAME = 'Storage';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NlcnZlci9zdG9yYWdlL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsU0FBUyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IE1PRFVMRV9OQU1FID0gJ1N0b3JhZ2UnXG4iXX0=

package/server/storage/index.d.ts

@@ -0,0 +1,21 @@
+import { ISceneStorage } from './scene';
+import { IPlayerStorage } from './player';
+export { ISceneStorage } from './scene';
+export { IPlayerStorage } from './player';
+/**
+ * Storage interface with methods for scene-scoped and player-scoped storage.
+ */
+export interface IStorage extends ISceneStorage {
+    /** Player-scoped storage for key-value pairs */
+    player: IPlayerStorage;
+}
+/**
+ * Storage provides methods to store and retrieve key-value data from the
+ * Server Side Storage service.
+ *
+ * - Use Storage.get/set/delete for scene-scoped storage
+ * - Use Storage.player.get/set/delete for player-scoped storage
+ *
+ * This module only works when running on server-side scenes.
+ */
+export declare const Storage: IStorage;

package/server/storage/index.js

@@ -0,0 +1,28 @@
+import { createSceneStorage } from './scene';
+import { createPlayerStorage } from './player';
+/**
+ * Creates the Storage module with scene-scoped and player-scoped storage.
+ */
+const createStorage = () => {
+    const sceneStorage = createSceneStorage();
+    const playerStorage = createPlayerStorage();
+    return {
+        // Spread scene storage methods at top level
+        get: sceneStorage.get,
+        set: sceneStorage.set,
+        delete: sceneStorage.delete,
+        // Keep player as nested property
+        player: playerStorage
+    };
+};
+/**
+ * Storage provides methods to store and retrieve key-value data from the
+ * Server Side Storage service.
+ *
+ * - Use Storage.get/set/delete for scene-scoped storage
+ * - Use Storage.player.get/set/delete for player-scoped storage
+ *
+ * This module only works when running on server-side scenes.
+ */
+export const Storage = createStorage();
+//# sourceMappingURL=data:application/json;base64,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

package/server/storage/player.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Player-scoped storage interface for key-value pairs from the Server Side Storage service.
+ * This is NOT filesystem storage - data is stored in the remote storage service.
+ */
+export interface IPlayerStorage {
+    /**
+     * Retrieves a value from a player's storage by key from the Server Side Storage service.
+     * @param address - The player's wallet address
+     * @param key - The key to retrieve
+     * @returns A promise that resolves to the parsed JSON value, or null if not found
+     */
+    get<T = unknown>(address: string, key: string): Promise<T | null>;
+    /**
+     * Stores a value in a player's storage in the Server Side Storage service.
+     * @param address - The player's wallet address
+     * @param key - The key to store the value under
+     * @param value - The value to store (will be JSON serialized)
+     * @returns A promise that resolves to true if successful, false otherwise
+     */
+    set<T = unknown>(address: string, key: string, value: T): Promise<boolean>;
+    /**
+     * Deletes a value from a player's storage in the Server Side Storage service.
+     * @param address - The player's wallet address
+     * @param key - The key to delete
+     * @returns A promise that resolves to true if deleted, false if not found
+     */
+    delete(address: string, key: string): Promise<boolean>;
+}
+/**
+ * Creates player-scoped storage that provides methods to interact with
+ * player-specific key-value pairs from the Server Side Storage service.
+ * This module only works when running on server-side scenes.
+ */
+export declare const createPlayerStorage: () => IPlayerStorage;

package/server/storage/player.js

@@ -0,0 +1,61 @@
+import { getStorageServerUrl } from '../storage-url';
+import { assertIsServer, wrapSignedFetch } from '../utils';
+import { MODULE_NAME } from './constants';
+/**
+ * Creates player-scoped storage that provides methods to interact with
+ * player-specific key-value pairs from the Server Side Storage service.
+ * This module only works when running on server-side scenes.
+ */
+export const createPlayerStorage = () => {
+    return {
+        async get(address, key) {
+            assertIsServer(MODULE_NAME);
+            const baseUrl = await getStorageServerUrl();
+            const url = `${baseUrl}/players/${encodeURIComponent(address)}/values/${encodeURIComponent(key)}`;
+            const [error, data] = await wrapSignedFetch({ url });
+            if (error) {
+                console.error(`Failed to get player storage value '${key}' for '${address}': ${error}`);
+                return null;
+            }
+            return data?.value ?? null;
+        },
+        async set(address, key, value) {
+            assertIsServer(MODULE_NAME);
+            const baseUrl = await getStorageServerUrl();
+            const url = `${baseUrl}/players/${encodeURIComponent(address)}/values/${encodeURIComponent(key)}`;
+            const [error] = await wrapSignedFetch({
+                url,
+                init: {
+                    method: 'PUT',
+                    headers: {
+                        'content-type': 'application/json'
+                    },
+                    body: JSON.stringify({ value })
+                }
+            });
+            if (error) {
+                console.error(`Failed to set player storage value '${key}' for '${address}': ${error}`);
+                return false;
+            }
+            return true;
+        },
+        async delete(address, key) {
+            assertIsServer(MODULE_NAME);
+            const baseUrl = await getStorageServerUrl();
+            const url = `${baseUrl}/players/${encodeURIComponent(address)}/values/${encodeURIComponent(key)}`;
+            const [error] = await wrapSignedFetch({
+                url,
+                init: {
+                    method: 'DELETE',
+                    headers: {}
+                }
+            });
+            if (error) {
+                console.error(`Failed to delete player storage value '${key}' for '${address}': ${error}`);
+                return false;
+            }
+            return true;
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/server/storage/scene.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Scene-scoped storage interface for key-value pairs from the Server Side Storage service.
+ * This is NOT filesystem storage - data is stored in the remote storage service.
+ */
+export interface ISceneStorage {
+    /**
+     * Retrieves a value from scene storage by key from the Server Side Storage service.
+     * @param key - The key to retrieve
+     * @returns A promise that resolves to the parsed JSON value, or null if not found
+     */
+    get<T = unknown>(key: string): Promise<T | null>;
+    /**
+     * Stores a value in scene storage in the Server Side Storage service.
+     * @param key - The key to store the value under
+     * @param value - The value to store (will be JSON serialized)
+     */
+    set<T = unknown>(key: string, value: T): Promise<boolean>;
+    /**
+     * Deletes a value from scene storage in the Server Side Storage service.
+     * @param key - The key to delete
+     * @returns A promise that resolves to true if deleted, false if not found
+     */
+    delete(key: string): Promise<boolean>;
+}
+/**
+ * Creates scene-scoped storage that provides methods to interact with
+ * scene-specific key-value pairs from the Server Side Storage service.
+ * This module only works when running on server-side scenes.
+ */
+export declare const createSceneStorage: () => ISceneStorage;

package/server/storage/scene.js

@@ -0,0 +1,61 @@
+import { getStorageServerUrl } from '../storage-url';
+import { assertIsServer, wrapSignedFetch } from '../utils';
+import { MODULE_NAME } from './constants';
+/**
+ * Creates scene-scoped storage that provides methods to interact with
+ * scene-specific key-value pairs from the Server Side Storage service.
+ * This module only works when running on server-side scenes.
+ */
+export const createSceneStorage = () => {
+    return {
+        async get(key) {
+            assertIsServer(MODULE_NAME);
+            const baseUrl = await getStorageServerUrl();
+            const url = `${baseUrl}/values/${encodeURIComponent(key)}`;
+            const [error, data] = await wrapSignedFetch({ url });
+            if (error) {
+                console.error(`Failed to get storage value '${key}': ${error}`);
+                return null;
+            }
+            return data?.value ?? null;
+        },
+        async set(key, value) {
+            assertIsServer(MODULE_NAME);
+            const baseUrl = await getStorageServerUrl();
+            const url = `${baseUrl}/values/${encodeURIComponent(key)}`;
+            const [error] = await wrapSignedFetch({
+                url,
+                init: {
+                    method: 'PUT',
+                    headers: {
+                        'content-type': 'application/json'
+                    },
+                    body: JSON.stringify({ value })
+                }
+            });
+            if (error) {
+                console.error(`Failed to set storage value '${key}': ${error}`);
+                return false;
+            }
+            return true;
+        },
+        async delete(key) {
+            assertIsServer(MODULE_NAME);
+            const baseUrl = await getStorageServerUrl();
+            const url = `${baseUrl}/values/${encodeURIComponent(key)}`;
+            const [error] = await wrapSignedFetch({
+                url,
+                init: {
+                    method: 'DELETE',
+                    headers: {}
+                }
+            });
+            if (error) {
+                console.error(`Failed to delete storage value '${key}': ${error}`);
+                return false;
+            }
+            return true;
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/server/storage-url.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Determines the correct storage server URL based on the current realm.
+ *
+ * - If `isPreview` is true, uses the realm's baseUrl (localhost)
+ * - If the realm's baseUrl contains `.zone`, uses storage.decentraland.zone
+ * - Otherwise, uses storage.decentraland.org (production)
+ *
+ * @returns The storage server base URL
+ */
+export declare function getStorageServerUrl(): Promise<string>;

package/server/storage-url.js

@@ -0,0 +1,29 @@
+import { getRealm } from '~system/Runtime';
+const STORAGE_SERVER_ORG = 'https://storage.decentraland.org';
+const STORAGE_SERVER_ZONE = 'https://storage.decentraland.zone';
+/**
+ * Determines the correct storage server URL based on the current realm.
+ *
+ * - If `isPreview` is true, uses the realm's baseUrl (localhost)
+ * - If the realm's baseUrl contains `.zone`, uses storage.decentraland.zone
+ * - Otherwise, uses storage.decentraland.org (production)
+ *
+ * @returns The storage server base URL
+ */
+export async function getStorageServerUrl() {
+    const { realmInfo } = await getRealm({});
+    if (!realmInfo) {
+        throw new Error('Unable to retrieve realm information');
+    }
+    // Local development / preview mode
+    if (realmInfo.isPreview) {
+        return realmInfo.baseUrl;
+    }
+    // Staging / testing environment
+    if (realmInfo.baseUrl.includes('.zone')) {
+        return STORAGE_SERVER_ZONE;
+    }
+    // Production environment
+    return STORAGE_SERVER_ORG;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/server/utils.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="@dcl/js-runtime" />
+import { SignedFetchRequest } from '~system/SignedFetch';
+/**
+ * Validates that the code is running on a server-side scene.
+ * Throws an error if called from a client-side context.
+ *
+ * @param moduleName - The name of the module for the error message
+ * @throws Error if not running on a server-side scene
+ */
+export declare function assertIsServer(moduleName: string): void;
+/**
+ * Result type for operations that can fail.
+ * Returns a tuple of [error, null] on failure or [null, data] on success.
+ */
+export type Result<T, E = string> = [E, null] | [null, T];
+/**
+ * Extended result type that includes HTTP status code information.
+ */
+export type FetchResult<T> = [string, null, number?] | [null, T, number];
+/**
+ * Wraps a promise to catch errors and return a Result tuple.
+ * This allows for cleaner error handling without try-catch blocks.
+ *
+ * @param promise - The promise to wrap
+ * @returns A tuple of [error, null] on failure or [null, data] on success
+ */
+export declare function tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>>;
+/**
+ * Wraps signedFetch with automatic error handling and JSON parsing.
+ * Returns a FetchResult tuple with parsed JSON data or error message and status code.
+ *
+ * @param signedFetchBody - The signedFetch request configuration
+ * @returns A tuple of [error, null, statusCode?] on failure or [null, data, statusCode] on success
+ */
+export declare function wrapSignedFetch<T = unknown>(signedFetchBody: SignedFetchRequest): Promise<FetchResult<T>>;

package/server/utils.js

@@ -0,0 +1,56 @@
+import { signedFetch } from '~system/SignedFetch';
+import { isServer } from '../network';
+/**
+ * Validates that the code is running on a server-side scene.
+ * Throws an error if called from a client-side context.
+ *
+ * @param moduleName - The name of the module for the error message
+ * @throws Error if not running on a server-side scene
+ */
+export function assertIsServer(moduleName) {
+    if (!isServer()) {
+        throw new Error(`${moduleName} is only available on server-side scenes`);
+    }
+}
+/**
+ * Wraps a promise to catch errors and return a Result tuple.
+ * This allows for cleaner error handling without try-catch blocks.
+ *
+ * @param promise - The promise to wrap
+ * @returns A tuple of [error, null] on failure or [null, data] on success
+ */
+export async function tryCatch(promise) {
+    try {
+        const data = await promise;
+        return [null, data];
+    }
+    catch (error) {
+        return [error, null];
+    }
+}
+/**
+ * Wraps signedFetch with automatic error handling and JSON parsing.
+ * Returns a FetchResult tuple with parsed JSON data or error message and status code.
+ *
+ * @param signedFetchBody - The signedFetch request configuration
+ * @returns A tuple of [error, null, statusCode?] on failure or [null, data, statusCode] on success
+ */
+export async function wrapSignedFetch(signedFetchBody) {
+    const [error, response] = await tryCatch(signedFetch(signedFetchBody));
+    if (error) {
+        console.error(`Error in ${signedFetchBody.url} endpoint`, { error });
+        return [error.message, null, undefined];
+    }
+    if (!response.ok) {
+        const errorMessage = `${response.status} ${response.statusText}`;
+        console.error(`Error in ${signedFetchBody.url} endpoint`, { response });
+        return [errorMessage, null, response.status];
+    }
+    const [parseError, body] = await tryCatch(JSON.parse(response.body || '{}'));
+    if (parseError) {
+        console.error(`Failed to parse response from ${signedFetchBody.url}`);
+        return ['Failed to parse response', null, response.status];
+    }
+    return [null, (body ?? {}), response.status];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/atom.ts

@@ -0,0 +1,98 @@
+import future, { IFuture } from './future'
+
+// atom value wrapper like in clojure
+
+// Simple Observable implementation to replace Babylon.js dependency
+class SimpleObservable<T> {
+  private observers: ((value: T) => void)[] = []
+  private onceObservers: ((value: T) => void)[] = []
+
+  add(callback: (value: T) => void): (value: T) => void {
+    this.observers.push(callback)
+    return callback
+  }
+
+  addOnce(callback: (value: T) => void): void {
+    this.onceObservers.push(callback)
+  }
+
+  remove(callback: (value: T) => void): void {
+    const index = this.observers.indexOf(callback)
+    if (index > -1) {
+      this.observers.splice(index, 1)
+    }
+  }
+
+  notifyObservers(value: T): void {
+    this.observers.forEach((observer) => observer(value))
+
+    if (this.onceObservers.length > 0) {
+      this.onceObservers.forEach((observer) => observer(value))
+      this.onceObservers.length = 0
+    }
+  }
+}
+
+const EMPTY = Symbol('empty')
+type EMPTY = typeof EMPTY
+
+export type Atom<T> = {
+  deref(): Promise<T>
+  getOrNull(): T | null
+  observable: SimpleObservable<T>
+  swap(value: T): T | void
+  pipe(fn: (value: T) => void | Promise<void>): Promise<void>
+}
+
+export function Atom<T>(initialValue: T | EMPTY = EMPTY): Atom<T> {
+  const observable = new SimpleObservable<T>()
+  let value: T | EMPTY = initialValue
+  const valueFutures: IFuture<T>[] = []
+
+  observable.addOnce((value) => {
+    valueFutures.forEach(($) => $.resolve(value))
+    valueFutures.length = 0
+  })
+
+  return {
+    async pipe(fn) {
+      observable.add(async (t) => {
+        try {
+          await fn(t)
+        } catch (err) {
+          console.error(err)
+        }
+      })
+      if (value !== EMPTY) {
+        try {
+          await fn(value)
+        } catch (err) {
+          console.error(err)
+        }
+      }
+    },
+    deref() {
+      if (value === EMPTY) {
+        const ret = future<T>()
+        valueFutures.push(ret)
+        return ret
+      }
+      return Promise.resolve(value)
+    },
+    getOrNull() {
+      if (value === EMPTY) {
+        return null
+      }
+      return value
+    },
+    observable,
+    swap(newValue) {
+      const oldValue = value
+      if (newValue !== value) {
+        value = newValue
+        observable.notifyObservers(value)
+      }
+      return oldValue === EMPTY ? undefined : oldValue
+    }
+  }
+}

package/src/future.ts

@@ -0,0 +1,38 @@
+export type IFuture<T> = Promise<T> & {
+  resolve: (x: T) => void
+  reject: (x: Error) => void
+  finally: (fn: () => void) => void
+  isPending: boolean
+}
+
+export function future<T = any>(): IFuture<T> {
+  let resolver: (x: T) => void
+  let rejecter: (x: Error) => void
+
+  const promise: any = new Promise((ok, err) => {
+    resolver = (x: T) => {
+      ok(x)
+      promise.isPending = false
+    }
+    rejecter = (x: Error) => {
+      err(x)
+      promise.isPending = false
+    }
+  }).catch((e) => Promise.reject(e))
+
+  promise.resolve = resolver!
+  promise.reject = rejecter!
+
+  if (!('finally' in promise)) {
+    promise.finally = (fn: any) => {
+      promise.then(fn)
+      promise.catch(fn)
+    }
+  }
+
+  promise.isPending = true
+
+  return promise as IFuture<T>
+}
+
+export default future

package/src/network/binary-message-bus.ts

@@ -1,9 +1,12 @@
 import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer'
 
 export enum CommsMessage {
-  CRDT = 1,
-  REQ_CRDT_STATE = 2,
-  RES_CRDT_STATE = 3
+  CRDT = 7,
+  REQ_CRDT_STATE = 8,
+  RES_CRDT_STATE = 9,
+  CRDT_SERVER = 4,
+  CRDT_AUTHORITATIVE = 5,
+  CUSTOM_EVENT = 6
 }
 
 export function BinaryMessageBus<T extends CommsMessage>(
@@ -20,7 +23,9 @@ export function BinaryMessageBus<T extends CommsMessage>(
     __processMessages: (messages: Uint8Array[]) => {
       for (const message of messages) {
         const commsMsg = decodeCommsMessage<T>(message)
-        if (!commsMsg) continue
+        if (!commsMsg) {
+          continue
+        }
         const { sender, messageType, data } = commsMsg
         const fn = mapping.get(messageType)
         if (fn) fn(data, sender)

package/src/network/chunking.ts

@@ -0,0 +1,45 @@
+import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer'
+import { readMessages } from './server/utils'
+
+/**
+ * Chunks CRDT messages from a Uint8Array buffer, respecting message boundaries
+ * Uses the comprehensive readMessages function that handles all message types
+ */
+export function chunkCrdtMessages(data: Uint8Array, maxSizeKB: number = 12): Uint8Array[] {
+  if (data.length === 0) {
+    return []
+  }
+
+  const networkBuffer = new ReadWriteByteBuffer()
+  const chunks: Uint8Array[] = []
+
+  for (const message of readMessages(data)) {
+    // Check if adding this message would exceed the size limit
+    const currentBufferSize = networkBuffer.toBinary().byteLength
+    const messageSize = message.messageBuffer.byteLength
+
+    if ((currentBufferSize + messageSize) / 1024 > maxSizeKB) {
+      // If the current buffer has content, save it as a chunk
+      if (currentBufferSize > 0) {
+        chunks.push(networkBuffer.toCopiedBinary())
+        networkBuffer.resetBuffer()
+      }
+
+      // If the message itself is larger than the limit, skip it
+      if (messageSize / 1024 > maxSizeKB) {
+        console.error(`Message too large (${messageSize} bytes), skipping CRDT message`)
+        continue
+      }
+    }
+
+    // Add message to current buffer
+    networkBuffer.writeBuffer(message.messageBuffer, false)
+  }
+
+  // Add any remaining data as the final chunk
+  if (networkBuffer.currentWriteOffset() > 0) {
+    chunks.push(networkBuffer.toBinary())
+  }
+
+  return chunks
+}