@dcl/sdk 7.3.31-7169243942.commit-5f044c6 → 7.3.32-7170667436.commit-11a2181

package/network/utils.js

@@ -0,0 +1,69 @@
+import { EngineInfo as _EngineInfo, Schemas } from '@dcl/ecs';
+import { componentNumberFromName } from '@dcl/ecs/dist/components/component-number';
+export const definePlayersInScene = (engine) => engine.defineComponent('players-scene', {
+    timestamp: Schemas.Number,
+    userId: Schemas.String
+});
+export let stateInitialized = false;
+export let playerSceneEntity;
+export function setInitialized() {
+    stateInitialized = true;
+}
+export let INITIAL_CRDT_RENDERER_MESSAGES_SENT = false;
+export function fetchProfile(myProfile, getUserData) {
+    void getUserData({}).then(({ data }) => {
+        if (data?.userId) {
+            const userId = data.userId;
+            const networkId = componentNumberFromName(data.userId);
+            myProfile.networkId = networkId;
+            myProfile.userId = userId;
+        }
+        else {
+            throw new Error(`Couldn't fetch profile data`);
+        }
+    });
+}
+export function createPlayerTimestampData(engine, profile, syncEntity) {
+    if (!profile?.userId)
+        return undefined;
+    const PlayersInScene = definePlayersInScene(engine);
+    const entity = engine.addEntity();
+    PlayersInScene.create(entity, { timestamp: Date.now(), userId: profile.userId });
+    syncEntity(entity, [PlayersInScene.componentId]);
+    playerSceneEntity = entity;
+    return playerSceneEntity;
+}
+export function oldestUser(engine, profile, syncEntity) {
+    const PlayersInScene = definePlayersInScene(engine);
+    if (!PlayersInScene.has(playerSceneEntity)) {
+        createPlayerTimestampData(engine, profile, syncEntity);
+        return oldestUser(engine, profile, syncEntity);
+    }
+    const { timestamp } = PlayersInScene.get(playerSceneEntity);
+    for (const [_, player] of engine.getEntitiesWith(PlayersInScene)) {
+        if (player.timestamp < timestamp)
+            return false;
+    }
+    return true;
+}
+export function syncTransportIsReady(engine) {
+    const EngineInfo = engine.getComponent(_EngineInfo.componentId);
+    if (!INITIAL_CRDT_RENDERER_MESSAGES_SENT) {
+        const engineInfo = EngineInfo.getOrNull(engine.RootEntity);
+        if (engineInfo && engineInfo.tickNumber > 2) {
+            INITIAL_CRDT_RENDERER_MESSAGES_SENT = true;
+        }
+    }
+    return INITIAL_CRDT_RENDERER_MESSAGES_SENT;
+}
+export function stateInitializedChecker(engine, _profile, _syncEntity) {
+    const EngineInfo = engine.getComponent(_EngineInfo.componentId);
+    async function enterScene() {
+        if ((EngineInfo.getOrNull(engine.RootEntity)?.tickNumber ?? 0) > 100) {
+            setInitialized();
+            return;
+        }
+    }
+    void enterScene();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/network/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  EngineInfo as _EngineInfo,\n  Entity,\n  IEngine,\n  NetworkEntity as _NetworkEntity,\n  Schemas,\n  LastWriteWinElementSetComponentDefinition,\n  PBEngineInfo\n} from '@dcl/ecs'\nimport { componentNumberFromName } from '@dcl/ecs/dist/components/component-number'\n\nimport type { GetUserDataRequest, GetUserDataResponse } from '~system/UserIdentity'\nimport { SyncEntity } from './entities'\nimport { IProfile } from './message-bus-sync'\n\n// Component to track all the players and when they enter to the scene.\n// Know who is in charge of sending the initial state (oldest one)\nexport const definePlayersInScene = (engine: IEngine) =>\n  engine.defineComponent('players-scene', {\n    timestamp: Schemas.Number,\n    userId: Schemas.String\n  })\n\n// Already initialized my state. Ignore new states messages.\nexport let stateInitialized = false\n\n// My player entity to check if I'm the oldest player in the scend\nexport let playerSceneEntity: Entity\n\nexport function setInitialized() {\n  stateInitialized = true\n}\n\n// Flag to avoid sending over the wire all the initial messages that the engine add's to the rendererTransport\n// INITIAL_CRDT_MESSAGES that are being processed on the onStart loop, before the onUpdate.\nexport let INITIAL_CRDT_RENDERER_MESSAGES_SENT = false\n\n// Retrieve userId to start sending this info as the networkId\nexport function fetchProfile(\n  myProfile: IProfile,\n  getUserData: (value: GetUserDataRequest) => Promise<GetUserDataResponse>\n) {\n  void getUserData({}).then(({ data }) => {\n    if (data?.userId) {\n      const userId = data.userId\n      const networkId = componentNumberFromName(data.userId)\n      myProfile.networkId = networkId\n      myProfile.userId = userId\n    } else {\n      throw new Error(`Couldn't fetch profile data`)\n    }\n  })\n}\n\n/**\n * Add's the user information about when he joined the scene.\n * It's used to check who is the oldest one, to sync the state\n */\nexport function createPlayerTimestampData(engine: IEngine, profile: IProfile, syncEntity: SyncEntity) {\n  if (!profile?.userId) return undefined\n  const PlayersInScene = definePlayersInScene(engine)\n  const entity = engine.addEntity()\n  PlayersInScene.create(entity, { timestamp: Date.now(), userId: profile.userId })\n  syncEntity(entity, [PlayersInScene.componentId])\n  playerSceneEntity = entity\n  return playerSceneEntity\n}\n\n/**\n * Check if I'm the older user to send the initial state\n */\nexport function oldestUser(engine: IEngine, profile: IProfile, syncEntity: SyncEntity): boolean {\n  const PlayersInScene = definePlayersInScene(engine)\n  // When the user leaves the scene but it's still connected.\n  if (!PlayersInScene.has(playerSceneEntity)) {\n    createPlayerTimestampData(engine, profile, syncEntity)\n    return oldestUser(engine, profile, syncEntity)\n  }\n  const { timestamp } = PlayersInScene.get(playerSceneEntity)\n  for (const [_, player] of engine.getEntitiesWith(PlayersInScene)) {\n    if (player.timestamp < timestamp) return false\n  }\n  return true\n}\n\n/**\n * Ignore CRDT's initial messages from the renderer.\n */\nexport function syncTransportIsReady(engine: IEngine) {\n  const EngineInfo = engine.getComponent(\n    _EngineInfo.componentId\n  ) as LastWriteWinElementSetComponentDefinition<PBEngineInfo>\n  if (!INITIAL_CRDT_RENDERER_MESSAGES_SENT) {\n    const engineInfo = EngineInfo.getOrNull(engine.RootEntity)\n    if (engineInfo && engineInfo.tickNumber > 2) {\n      INITIAL_CRDT_RENDERER_MESSAGES_SENT = true\n    }\n  }\n  return INITIAL_CRDT_RENDERER_MESSAGES_SENT\n}\n\n/**\n * Check if we are already initialized\n * Add the playerSceneData component and syncronize it till we receive the state.\n * This fn should be added as a system so it runs on every tick\n */\n// TODO: Had to comment all the logic because getConnectedPlayers was not working as expected\n// A lot of raise conditions. For now we will go with the approach that every client that it's initialized will send his crdt state.\nexport function stateInitializedChecker(engine: IEngine, _profile: IProfile, _syncEntity: SyncEntity) {\n  // const PlayersInScene = definePlayersInScene(engine)\n  const EngineInfo = engine.getComponent(_EngineInfo.componentId) as typeof _EngineInfo\n  // const NetworkEntity = engine.getComponent(_NetworkEntity.componentId) as INetowrkEntity\n  async function enterScene() {\n    // if (!playerSceneEntity) {\n    //   createPlayerTimestampData(engine, profile, syncEntity)\n    // }\n\n    /**\n     * Keeps PlayersInScene up-to-date with the current players.\n     */\n    // const connectedPlayers = await getConnectedPlayers({})\n    // for (const [entity, player] of engine.getEntitiesWith(PlayersInScene)) {\n    //   if (!connectedPlayers.players.find(($) => $.userId === player.userId)) {\n    //     PlayersInScene.deleteFrom(entity)\n    //   }\n    // }\n\n    // Wait for comms to be ready ?? ~3000ms\n    if ((EngineInfo.getOrNull(engine.RootEntity)?.tickNumber ?? 0) > 100) {\n      setInitialized()\n      return\n    }\n\n    // If we already have data from players, dont send the heartbeat messages\n    // if (connectedPlayers.players.length) return\n\n    // if (!stateInitialized && playerSceneEntity) {\n    //   // Send this data to all the players connected (new and old)\n    //   // So everyone can decide if it's the oldest one or no.\n    //   // It's for the case that multiple users enters ~ at the same time.\n    //   PlayersInScene.getMutable(playerSceneEntity)\n    // }\n  }\n  void enterScene()\n}\n"]}

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@dcl/sdk",
   "description": "",
-  "version": "7.3.31-7169243942.commit-5f044c6",
+  "version": "7.3.32-7170667436.commit-11a2181",
   "author": "Decentraland",
   "dependencies": {
-    "@dcl/ecs": "7.3.31-7169243942.commit-5f044c6",
+    "@dcl/ecs": "7.3.32-7170667436.commit-11a2181",
     "@dcl/ecs-math": "2.0.2",
     "@dcl/explorer": "1.0.157791-20231211140501.commit-65632e4",
-    "@dcl/js-runtime": "7.3.31-7169243942.commit-5f044c6",
-    "@dcl/react-ecs": "7.3.31-7169243942.commit-5f044c6",
-    "@dcl/sdk-commands": "7.3.31-7169243942.commit-5f044c6",
+    "@dcl/js-runtime": "7.3.32-7170667436.commit-11a2181",
+    "@dcl/react-ecs": "7.3.32-7170667436.commit-11a2181",
+    "@dcl/sdk-commands": "7.3.32-7170667436.commit-11a2181",
     "text-encoding": "0.7.0"
   },
   "keywords": [],
@@ -35,5 +35,5 @@
   },
   "types": "./index.d.ts",
   "typings": "./index.d.ts",
-  "commit": "5f044c65cc86498ef4a73f87e0082c070b9730f5"
+  "commit": "11a21816f9bf404c90ba02782ad7e359262a909d"
 }

package/src/internal/transports/logger.ts

@@ -1,4 +1,4 @@
-import { IEngine, CrdtMessage, CrdtMessageType } from '@dcl/ecs'
+import { IEngine, CrdtMessage, CrdtMessageType, CRDT_MESSAGE_HEADER_LENGTH } from '@dcl/ecs'
 import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer'
 import { readMessage } from '@dcl/ecs/dist/serialization/crdt/message'
 
@@ -8,14 +8,16 @@ export function* serializeCrdtMessages(prefix: string, data: Uint8Array, engine:
   let message: CrdtMessage | null
 
   while ((message = readMessage(buffer))) {
-    const ent = `0x${message.entityId.toString(16)}`
+    const ent = message.entityId
     const preface = `${prefix}: ${CrdtMessageType[message.type]} e=${ent}`
-    if (message.type === CrdtMessageType.DELETE_ENTITY) {
+    if (message.type === CrdtMessageType.DELETE_ENTITY || message.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {
       yield `${preface}`
     }
 
     if (
       message.type === CrdtMessageType.PUT_COMPONENT ||
+      message.type === CrdtMessageType.PUT_COMPONENT_NETWORK ||
+      message.type === CrdtMessageType.DELETE_COMPONENT_NETWORK ||
       message.type === CrdtMessageType.DELETE_COMPONENT ||
       message.type === CrdtMessageType.APPEND_VALUE
     ) {
@@ -30,7 +32,10 @@ export function* serializeCrdtMessages(prefix: string, data: Uint8Array, engine:
       } catch {
         yield `${preface} c=${componentId} t=${timestamp} data=?`
       }
-    } else if (message.type === CrdtMessageType.DELETE_ENTITY) {
+    } else if (
+      message.type === CrdtMessageType.DELETE_ENTITY ||
+      message.type === CrdtMessageType.DELETE_ENTITY_NETWORK
+    ) {
       yield preface
     } else {
       yield `${preface} Unknown CrdtMessageType`

package/src/internal/transports/rendererTransport.ts

@@ -42,7 +42,8 @@ export function createRendererTransport(engineApi: EngineApiForTransport): Trans
       }
 
       return !!message
-    }
+    },
+    type: 'renderer'
   }
 
   return rendererTransport

package/src/message-bus.ts

@@ -14,11 +14,13 @@ export class MessageBus {
 
   on(message: string, callback: (value: any, sender: string) => void): Observer<IEvents['comms']> {
     return onCommsMessage.add((e) => {
-      const m = JSON.parse(e.message)
+      try {
+        const m = JSON.parse(e.message)
 
-      if (m.message === message) {
-        callback(m.payload, e.sender)
-      }
+        if (m.message === message) {
+          callback(m.payload, e.sender)
+        }
+      } catch (_) {}
     })!
   }
 
@@ -28,7 +30,6 @@ export class MessageBus {
 
     this.flush()
   }
-
   emit(message: string, payload: Record<any, any>) {
     const messageToSend = JSON.stringify({ message, payload })
     this.sendRaw(messageToSend)
@@ -36,13 +37,10 @@ export class MessageBus {
   }
 
   private flush() {
-    if (this.messageQueue.length === 0) return
+    if (!this.messageQueue.length) return
     if (this.flushing) return
 
     const message = this.messageQueue.shift()!
-
-    this.flushing = true
-
     communicationsController.send({ message }).then(
       (_) => {
         this.flushing = false

package/src/network/README.md

@@ -0,0 +1,122 @@
+## Mapping syncronized Entities
+How this works ?
+We create a new component created NetworkEntity.
+This network component consists in the id of the entity that was created in that client, and the networkId is the user address converted to a number. So its kind of the unique user id in a int64 format.
+
+type NetwokEntity = { entityId: Entity; networkId: number }
+
+We also introduce a new kind of messages that are going to be sent through the wire, and that the SDK knows how to read.
+PutNetworkComponent message.
+This message is the same as the PUT_COMPONENT BUT! with the difference that we are sending always the NetworkEntity mapping.
+So this message will not have the local entityId, it will always send the NetworkEntity component associated to the entity.
+PUT_NETWORK_MESSAGE = { networkId: networkEntity.networkId, entityId: networkEntity.entityId, data: Uint8Array }
+So this way, every client has the internal mapping.
+Once you receive a network message, you iterate the NetworkEntity component to find the one that has the same entityId and networkId. The entity with that component is the entity that the network is talking about.
+When you change a component of that entity, we do the same. We look for the networkEntity and create a PutNetwork message with the NetworkEntity values.
+
+## Syncronize Entities that are created in every client (Main Function)
+
+enum Entities {
+  HOUSE = 1,
+  DOOR = 2
+}
+Same entity for all clients.
+
+This is usefull when you have static entities that are created on every client, and you want to syncronize something about them.
+For example a door of a house. You want every client to create the same door.
+We use the Entities enum to tag the entity with an unique identifier, so every client knows which entity you are modifying, no matter the order they are created
+This is used for code that is being executed on every client, and you want to sync some component about it. If you dont tag them, you can't be sure that both clients are talking about the same entity.
+Maybe for client A the door is the entity 512, but for client B its 513, and you will have some missmatch there.
+i.e.
+const houseEntity = engine.addEntity()
+syncEntity(houseEntity, [Transform.componentId], Entities.HOUSE)
+
+If we dont use the SyncStaticEntities for static models like the house. Then each client will create a new House, and that House will be replicated on every client. So if you have 10 clients, you will have 10 houses being syncronized.
+That's why we use the SyncStaticEntities identifier for things that you want to be created only once, and can syncronized if some component changed.
+
+
+## Syncronize RUNTIME/DYNAMIC entities
+This are entities that are created on a client after some interaction, and you want to replicate them on all the other clients.
+The client that runs this code will create an UNIQUE entity and will be sent to the others.
+
+For example bullets of a gun. Every client will have their own bullets, and every time they shot the gun a new entity (bullet) will be created and replicated on every client.
+Another example could be the spawn cubes. Every client that spawns a cube, will spawn an unique cube, and will be replicated on the others.
+All this examples have the same pattern, code that is being executed in only one client, and need to be syncronize on the other ones.
+
+function onShoot() {
+ const bullet = engine.addEntity()
+ Transform.create(bullet, {})
+ Material.create(bullet, {})
+ syncEntity(bullet, [Transform.componentId, Material.componentId])
+}
+
+## Syncronizing Transform Issue
+Let me tell you a sad story about syncronizing Transforms with different entities ids in each client
+Scene wants to sync a door. (SyncEntities.Door & SyncEntities.ParentDoor).
+We have clients A & B, and both creates the door in the main function.
+Both clients knows that are the same door because we use the SyncEntities enum to map this entity.
+
+A creates sync entity 512 (parent)
+ const parent = engine.addEntity() // 512
+ syncEntity(parent, [Transform.componentId], SyncEntities.ParentDoor)
+A creates sync entity 513 (child)
+ const child = engine.addEntity() // 513
+ Transform.create({ parent, position: {} })
+ syncEntity(child, [Transform.componentId], SyncEntities.ChildDoor)
+
+
+Client B does the same but the entities, we dont know why, result in diff order. (Maybe a race condition)
+B creates sync entity 513 (parent)
+ const parent = engine.addEntity() // 513
+ syncEntity(parent, [Transform.componentId], SyncEntities.ParentDoor)
+B creates sync entity 514 (child)
+ const child = engine.addEntity() // 514
+ Transform.create({ parent, position: {} })
+ syncEntity(child, [Transform.componentId], SyncEntities.ChildDoor)
+
+So now client A & B had different raw data for the Transform component, because they have different parents.
+Meaning that we have an inconsistent CRDT State between two clients.
+So if there is a new message comming from client C we could have conflicts for client A but maybe not for client B.
+
+Same problem would happen if a client after some interaction (i.e. a bullet) creates an entity with a parent. For the client A this could be { parent: 515, child: 516 } but for another user those entities are not going to be the same ones.
+
+Solution 1:
+ What if we introduce a new ParentNetwork component.
+ This ParentNetwork will be in charge of syncronizing the parenting. If we have ParentNetwork then we should always ignore the Transform.parent property.
+ The ParentNetwork will have both entityId and networkId such as the PutNetworkMessage so we can map the entity in every client.
+
+ ParentNetwork.Schema = { entityId: Entity; networkId: number }.
+
+ Being the networkId the id of the user that owns that parent entity, and the entityId the parent entityId of the user that creates that entity.
+ So with this two values, we cant map the real parent entity id on every client.
+
+ ```ts
+ import { syncEntity, parentEntity } from '@dcl/sdk/network'
+ const parentEntity = engine.addEntity()
+ Transform.create(parentEntity, { position: somePosition })
+ syncEntity(parent, Transform.componentId)
+ const childEntity: Entity = engine.addEntity()
+ syncEntity(childEntity, Transform.componentId)
+
+ // create parentNetwork component. This maybe could be done in a system and use the original parent. TBD
+ parentEntity(childEntity, parentEntity)
+ ```
+ Every client will know how to map this entity because the ParentNetwork has the pointers to the parent entity. But we are still having an issue, the parent is not defined. We need to tell the renderer that the child entity has a parent property.
+
+ So every time we send a Transform component to the renderer, we should update the transform.parent property with the mapped Entity that we fetch from the ParentNetwork.
+ if (isTransform(message) && isRendererTransport && ParentNetwork.getOrNull(message.entityId)) {
+   // Generate a new transform raw data with the parent property included
+ }
+
+ And every time we recieve a message from the renderer, we should remove the parent property to keep consistency in all CRDT state clients.
+ if (isTransform(message) && message.type === CrdtMessageType.PUT_COMPONENT && ParentNetwork.has(message.entityId)) {
+ transform.parent = null
+   // Generate a new transform raw data without the parent property included
+ }
+
+ With this approach, all the clients will have the same Transform, so we avoid the inconsistency of crdt's state.
+ And when some user wants to update the transform, it has to modify the ParentNetwork and will update both values, the parent & the network.
+
+I think this will work but there are some developer experience issues, like using the `parentEntity(child, parent)` function instead of the transform.parent.
+This could end up with a lot of unexepcted issues/bugs. Maybe we can have a system that iterates over every syncronized entity and when the transform.parent changes, add the parentEntity function automatically.
+First I wanna try to implement all of this and then came up with this approach to avoid inconsistencies

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

@@ -0,0 +1,72 @@
+import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer'
+
+export enum CommsMessage {
+  CRDT = 1,
+  REQ_CRDT_STATE = 2,
+  RES_CRDT_STATE = 3
+}
+
+export function BinaryMessageBus<T extends CommsMessage>(send: (message: Uint8Array) => void) {
+  const mapping: Map<T, (value: Uint8Array, sender: string) => void> = new Map()
+  return {
+    on: <K extends T>(message: K, callback: (value: Uint8Array, sender: string) => void) => {
+      mapping.set(message, callback)
+    },
+    emit: <K extends T>(message: K, value: Uint8Array) => {
+      send(craftCommsMessage<T>(message, value))
+    },
+    __processMessages: (messages: Uint8Array[]) => {
+      for (const message of messages) {
+        const commsMsg = decodeCommsMessage<T>(message)
+        if (!commsMsg) continue
+        const { sender, messageType, data } = commsMsg
+        const fn = mapping.get(messageType)
+        if (fn) fn(data, sender)
+      }
+    }
+  }
+}
+
+export function craftCommsMessage<T extends CommsMessage>(messageType: T, payload: Uint8Array): Uint8Array {
+  const msg = new Uint8Array(payload.byteLength + 1)
+  msg.set([messageType])
+  msg.set(payload, 1)
+  return msg
+}
+
+export function decodeCommsMessage<T extends CommsMessage>(
+  data: Uint8Array
+): { sender: string; messageType: T; data: Uint8Array } | undefined {
+  try {
+    let offset = 0
+    const r = new Uint8Array(data)
+    const view = new DataView(r.buffer)
+    const senderLength = view.getUint8(offset)
+    offset += 1
+    const sender = decodeString(data.subarray(1, senderLength + 1))
+    offset += senderLength
+    const messageType = view.getUint8(offset) as T
+    offset += 1
+    const message = r.subarray(offset)
+
+    return {
+      sender,
+      messageType,
+      data: message
+    }
+  } catch (e) {
+    console.error('Invalid Comms message', e)
+  }
+}
+
+export function decodeString(data: Uint8Array): string {
+  const buffer = new ReadWriteByteBuffer()
+  buffer.writeBuffer(data, true)
+  return buffer.readUtf8String()
+}
+
+export function encodeString(s: string): Uint8Array {
+  const buffer = new ReadWriteByteBuffer()
+  buffer.writeUtf8String(s)
+  return buffer.readBuffer()
+}

package/src/network/entities.ts

@@ -0,0 +1,132 @@
+import {
+  Entity,
+  IEngine,
+  NetworkEntity as _NetworkEntity,
+  INetowrkEntity,
+  NetworkParent as _NetworkParent,
+  Transform as _Transform,
+  SyncComponents as _SyncComponents,
+  INetowrkParent,
+  TransformComponent,
+  ISyncComponents
+} from '@dcl/ecs'
+import { IProfile } from './message-bus-sync'
+
+export type SyncEntity = (entityId: Entity, componentIds: number[], entityEnumId?: number) => void
+
+export function entityUtils(engine: IEngine, profile: IProfile) {
+  const NetworkEntity = engine.getComponent(_NetworkEntity.componentId) as INetowrkEntity
+  const NetworkParent = engine.getComponent(_NetworkParent.componentId) as INetowrkParent
+  const Transform = engine.getComponent(_Transform.componentId) as TransformComponent
+  const SyncComponents = engine.getComponent(_SyncComponents.componentId) as ISyncComponents
+
+  /**
+   * Create a network entity (sync) through comms, and sync the received components
+   */
+  function syncEntity(entityId: Entity, componentIds: number[], entityEnumId?: number) {
+    // Profile not initialized
+    if (!profile?.networkId) {
+      throw new Error('Profile not initialized. Called syncEntity inside the main() function.')
+    }
+
+    // We use the networkId generated by the user address to identify this entity through the network
+    const networkValue = { entityId, networkId: profile.networkId }
+
+    // If there is an entityEnumId, it means is the same entity for all the clients created on the main funciton.
+    // So the networkId should be the same in all the clients to avoid re-creating this entity.
+    // For this case we use networkId = 0.
+    if (entityEnumId !== undefined) {
+      networkValue.networkId = 0
+      networkValue.entityId = entityEnumId as Entity
+
+      // Check if this enum is already used
+      for (const [_, network] of engine.getEntitiesWith(NetworkEntity)) {
+        if (network.networkId === networkValue.networkId && network.entityId === networkValue.entityId) {
+          throw new Error('syncEntity failed because the id provided is already in use')
+        }
+      }
+    }
+
+    // If is not defined, then is a entity created in runtime (what we called dynamic/runtime entities).
+    NetworkEntity.createOrReplace(entityId, networkValue)
+    SyncComponents.createOrReplace(entityId, { componentIds })
+  }
+
+  /**
+   * Returns an iterable of all the childrens of the given entity.
+   * for (const children of getChildren(parent)) { console.log(children) }
+   * or just => const childrens: Entity[] = Array.from(getChildren(parent))
+   */
+  function* getChildren(parent: Entity): Iterable<Entity> {
+    const network = NetworkEntity.getOrNull(parent)
+    if (network) {
+      for (const [entity, parent] of engine.getEntitiesWith(NetworkParent)) {
+        if (parent.entityId === network.entityId && parent.networkId === network.networkId) {
+          yield entity
+        }
+      }
+    }
+  }
+
+  function getFirstChild(entity: Entity) {
+    return Array.from(getChildren(entity))[0]
+  }
+
+  /**
+   * Returns the parent entity of the given entity.
+   */
+  function getParent(child: Entity): Entity | undefined {
+    const parent = NetworkParent.getOrNull(child)
+    if (!parent) return undefined
+    for (const [entity, network] of engine.getEntitiesWith(NetworkEntity)) {
+      if (parent.networkId === network.networkId && parent.entityId === network.entityId) {
+        return entity
+      }
+    }
+    return undefined
+  }
+
+  /**
+   * Adds the network parenting to sync entities.
+   * Equivalent to Transform.parent for local entities
+   */
+  function parentEntity(entity: Entity, parent: Entity) {
+    const network = NetworkEntity.getOrNull(parent)
+    if (!network) {
+      throw new Error('Entity is not sync. Call syncEntity on the parent.')
+    }
+
+    // Create network parent component
+    NetworkParent.createOrReplace(entity, network)
+
+    // If we dont have a transform for this entity, create an empty one to send it to the renderer
+    if (!Transform.getOrNull(entity)) {
+      Transform.create(entity)
+    } else {
+      // We force to send a tick update of the transform so we can send the NEW parent to the renderer
+      Transform.getMutable(entity)
+    }
+  }
+
+  /**
+   * Removes the network parenting from an entity
+   */
+  function removeParent(entity: Entity) {
+    const network = NetworkEntity.getOrNull(entity)
+
+    if (!network) {
+      throw new Error('Entity is not sync')
+    }
+
+    NetworkParent.deleteFrom(entity)
+  }
+
+  return {
+    syncEntity,
+    getChildren,
+    getParent,
+    parentEntity,
+    removeParent,
+    getFirstChild
+  }
+}

package/src/network/filter.ts

@@ -0,0 +1,64 @@
+import {
+  TransportMessage,
+  PointerEventsResult,
+  GltfContainerLoadingState,
+  EntityUtils,
+  RESERVED_STATIC_ENTITIES,
+  CrdtMessageType,
+  SyncComponents as _SyncComponents,
+  NetworkEntity as _NetworkEntity,
+  NetworkParent as _NetworkParent,
+  IEngine
+} from '@dcl/ecs'
+
+export function syncFilter(engine: IEngine) {
+  const NetworkEntity = engine.getComponent(_NetworkEntity.componentId) as typeof _NetworkEntity
+  const SyncComponents = engine.getComponent(_SyncComponents.componentId) as typeof _SyncComponents
+
+  return function (message: Omit<TransportMessage, 'messageBuffer'>) {
+    const componentId = (message as any).componentId
+
+    if ([PointerEventsResult.componentId, GltfContainerLoadingState.componentId].includes(componentId)) {
+      return false
+    }
+
+    const [entityId] = EntityUtils.fromEntityId(message.entityId)
+
+    // filter messages from reserved entities.
+    if (entityId < RESERVED_STATIC_ENTITIES) {
+      return false
+    }
+
+    const network = NetworkEntity.getOrNull(message.entityId)
+    // Delete Network Entity Always
+    if (
+      message.type === CrdtMessageType.DELETE_ENTITY_NETWORK ||
+      (network && message.type === CrdtMessageType.DELETE_ENTITY)
+    ) {
+      return true
+    }
+
+    const sync = SyncComponents.getOrNull(message.entityId)
+    if (!sync) return false
+
+    // First component
+    if ((message as any).timestamp <= 1) {
+      return true
+    }
+
+    if (componentId === NetworkEntity.componentId) {
+      return false
+    }
+
+    // If there is a change in the network parent or syncComponents we should always sync
+    if (componentId === _NetworkParent.componentId || componentId === SyncComponents.componentId) {
+      return true
+    }
+
+    if (componentId && sync.componentIds.includes(componentId)) {
+      return true
+    }
+
+    return false
+  }
+}

package/src/network/index.ts

@@ -0,0 +1,13 @@
+import { sendBinary } from '~system/CommunicationsController'
+import { engine } from '@dcl/ecs'
+import { addSyncTransport } from './message-bus-sync'
+import { getUserData } from '~system/UserIdentity'
+
+// initialize sync transport for sdk engine
+const { getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent, getFirstChild } = addSyncTransport(
+  engine,
+  sendBinary,
+  getUserData
+)
+
+export { getFirstChild, getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent }