diff --git a/package-lock.json b/package-lock.json
index 136079500..a9f89cea0 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -21,7 +21,7 @@
         "@dcl/kernel-interface": "^2.0.0-20210922153939.commit-017905d",
         "@dcl/legacy-ecs": "^6.11.8",
         "@dcl/protocol": "^1.0.0-3373991894.commit-8aa3a49",
-        "@dcl/rpc": "^1.0.4-20221113192916.commit-3ef5187",
+        "@dcl/rpc": "^1.1.1-20221115000939.commit-9a51ad0",
         "@dcl/scene-runtime": "^1.0.0-20221102005705.commit-05d463c",
         "@dcl/schemas": "^5.21.0",
         "@dcl/urn-resolver": "^2.0.2",
@@ -283,9 +283,9 @@
       }
     },
     "node_modules/@dcl/rpc": {
-      "version": "1.0.4-20221113192916.commit-3ef5187",
-      "resolved": "https://registry.npmjs.org/@dcl/rpc/-/rpc-1.0.4-20221113192916.commit-3ef5187.tgz",
-      "integrity": "sha512-pf3gv20y1dMT867jRy/4uH3SZsng/1Oxn106bDc9qrUQRIz8PwHoiI640IFfLKVwz8BKbn2t0EX28YBi0CdC4g==",
+      "version": "1.1.1-20221115000939.commit-9a51ad0",
+      "resolved": "https://registry.npmjs.org/@dcl/rpc/-/rpc-1.1.1-20221115000939.commit-9a51ad0.tgz",
+      "integrity": "sha512-KqCrwX+NCRKyPs4IIuTzq1fcngI3zu1wpSStGGY6HreBDWRZNIE7WTtcwg9ks8CPq8qNUsbJIhlw5U9lcJRpSA==",
       "dependencies": {
         "mitt": "^3.0.0",
         "ts-proto": "^1.126.1"
@@ -8352,9 +8352,9 @@
       }
     },
     "@dcl/rpc": {
-      "version": "1.0.4-20221113192916.commit-3ef5187",
-      "resolved": "https://registry.npmjs.org/@dcl/rpc/-/rpc-1.0.4-20221113192916.commit-3ef5187.tgz",
-      "integrity": "sha512-pf3gv20y1dMT867jRy/4uH3SZsng/1Oxn106bDc9qrUQRIz8PwHoiI640IFfLKVwz8BKbn2t0EX28YBi0CdC4g==",
+      "version": "1.1.1-20221115000939.commit-9a51ad0",
+      "resolved": "https://registry.npmjs.org/@dcl/rpc/-/rpc-1.1.1-20221115000939.commit-9a51ad0.tgz",
+      "integrity": "sha512-KqCrwX+NCRKyPs4IIuTzq1fcngI3zu1wpSStGGY6HreBDWRZNIE7WTtcwg9ks8CPq8qNUsbJIhlw5U9lcJRpSA==",
       "requires": {
         "mitt": "^3.0.0",
         "ts-proto": "^1.126.1"
diff --git a/package.json b/package.json
index 49294865a..a4002f698 100644
--- a/package.json
+++ b/package.json
@@ -66,7 +66,7 @@
     "@dcl/kernel-interface": "^2.0.0-20210922153939.commit-017905d",
     "@dcl/legacy-ecs": "^6.11.8",
     "@dcl/protocol": "^1.0.0-3373991894.commit-8aa3a49",
-    "@dcl/rpc": "^1.0.4-20221113192916.commit-3ef5187",
+    "@dcl/rpc": "^1.1.1-20221115000939.commit-9a51ad0",
     "@dcl/scene-runtime": "^1.0.0-20221102005705.commit-05d463c",
     "@dcl/schemas": "^5.21.0",
     "@dcl/urn-resolver": "^2.0.2",
diff --git a/packages/entryPoints/inject.js b/packages/entryPoints/inject.js
index e36f06a45..094c26671 100644
--- a/packages/entryPoints/inject.js
+++ b/packages/entryPoints/inject.js
@@ -4,6 +4,6 @@ globalThis.process = {
   browser: true,
   env: {},
   nextTick(fn, ...args) {
-    require('queue-microtask')(() => fn(...args))
+    queueMicrotask(() => fn(...args))
   }
 }
\ No newline at end of file
diff --git a/packages/renderer-protocol/rpcClient.ts b/packages/renderer-protocol/rpcClient.ts
index 5f5d1fe98..278baf13b 100644
--- a/packages/renderer-protocol/rpcClient.ts
+++ b/packages/renderer-protocol/rpcClient.ts
@@ -1,19 +1,8 @@
-import { createRpcClient, Transport } from '@dcl/rpc'
-import future, { IFuture } from 'fp-future'
-import { registerCRDTService } from './services/crdtService'
-import { RendererProtocol } from './types'
+import { createRpcClient, RpcClientPort, Transport } from '@dcl/rpc'
 
-export const rendererProtocol: IFuture<RendererProtocol> = future()
-
-export async function createRendererRpcClient(transport: Transport): Promise<RendererProtocol> {
+export async function createRendererRpcClient(transport: Transport): Promise<RpcClientPort> {
   const rpcClient = await createRpcClient(transport)
   const clientPort = await rpcClient.createPort('renderer-protocol')
 
-  const crdtService = registerCRDTService(clientPort)
-
-  rendererProtocol.resolve({
-    crdtService
-  })
-
-  return rendererProtocol
+  return clientPort
 }
diff --git a/packages/renderer-protocol/transports/webSocketTransportAdapter.ts b/packages/renderer-protocol/transports/webSocketTransportAdapter.ts
index add420145..86cbad42c 100644
--- a/packages/renderer-protocol/transports/webSocketTransportAdapter.ts
+++ b/packages/renderer-protocol/transports/webSocketTransportAdapter.ts
@@ -90,6 +90,9 @@ export function webSocketTransportAdapter(url: string, options: CommonRendererOp
 
   const transport: Transport = {
     ...events,
+    get isConnected(): boolean {
+      return (socket && socket.readyState === socket.OPEN) || false
+    },
     sendMessage(message: any) {
       send(message)
     },
diff --git a/packages/renderer-protocol/transports/webTransport.ts b/packages/renderer-protocol/transports/webTransport.ts
index 34aeb361d..a5bfe81ac 100644
--- a/packages/renderer-protocol/transports/webTransport.ts
+++ b/packages/renderer-protocol/transports/webTransport.ts
@@ -5,7 +5,7 @@ export type WebTransportOptions = {
   wasmModule: any
 }
 
-export function webTransport(options: WebTransportOptions): Transport {
+export function webTransport(options: WebTransportOptions, unityDclInstance: any) {
   const events = mitt<TransportEvents>()
   const ALLOC_SIZE = 8388608
   let heapPtr: number
@@ -17,15 +17,25 @@ export function webTransport(options: WebTransportOptions): Transport {
   }
 
   let isClosed = false
+  let didConnect = false
 
-  ;(globalThis as any).DCL.BinaryMessageFromEngine = function (data: Uint8Array) {
+  unityDclInstance.BinaryMessageFromEngine = function (data: Uint8Array) {
+    if (!didConnect) {
+      throw new Error('Received data from unity before connection was established')
+    }
     const copiedData = new Uint8Array(data)
     events.emit('message', copiedData)
   }
 
   const transport: Transport = {
     ...events,
+    get isConnected() {
+      return didConnect
+    },
     sendMessage(message) {
+      if (!didConnect) {
+        throw new Error('Tried to send a message before connection was established')
+      }
       if (!!sendMessageToRenderer && !isClosed) {
         options.wasmModule.HEAPU8.set(message, heapPtr)
         sendMessageToRenderer(heapPtr, message.length)
@@ -39,7 +49,12 @@ export function webTransport(options: WebTransportOptions): Transport {
     }
   }
 
-  queueMicrotask(() => events.emit('connect', {}))
+  events.on('connect', () => {
+    didConnect = true
+  })
+
+  // connect the transport
+  events.emit('connect', {})
 
   return transport
 }
diff --git a/packages/shared/apis/host/EngineAPI.ts b/packages/shared/apis/host/EngineAPI.ts
index 856d74d15..b7c251ed0 100644
--- a/packages/shared/apis/host/EngineAPI.ts
+++ b/packages/shared/apis/host/EngineAPI.ts
@@ -11,8 +11,7 @@ import {
 
 import { PortContext } from './context'
 import { EntityAction, EntityActionType } from 'shared/types'
-
-import { rendererProtocol } from './../../../renderer-protocol/rpcClient'
+import { registerCRDTService } from 'renderer-protocol/services/crdtService'
 
 function getPayload(payloadType: EAType, payload: Payload): any {
   switch (payloadType) {
@@ -60,60 +59,62 @@ function getPayload(payloadType: EAType, payload: Payload): any {
 }
 
 export function registerEngineApiServiceServerImplementation(port: RpcServerPort<PortContext>) {
-  codegen.registerService(port, EngineApiServiceDefinition, async () => ({
-    async sendBatch(req: ManyEntityAction, ctx) {
-      const actions: EntityAction[] = []
+  codegen.registerService(port, EngineApiServiceDefinition, async (port, ctx) => {
+    const crdtService = registerCRDTService(ctx.rendererPort)
+
+    return {
+      async sendBatch(req: ManyEntityAction, ctx) {
+        const actions: EntityAction[] = []
 
-      for (const action of req.actions) {
-        const actionType = eaTypeToStr(action.type)
-        if (actionType && action.payload) {
-          actions.push({
-            type: actionType,
-            tag: action.tag,
-            payload: getPayload(action.type, action.payload as any)
-          })
+        for (const action of req.actions) {
+          const actionType = eaTypeToStr(action.type)
+          if (actionType && action.payload) {
+            actions.push({
+              type: actionType,
+              tag: action.tag,
+              payload: getPayload(action.type, action.payload as any)
+            })
+          }
         }
-      }
 
-      if (actions.length) {
-        ctx.sendBatch(actions)
-      }
+        if (actions.length) {
+          ctx.sendBatch(actions)
+        }
 
-      const events: EventData[] = ctx.events
+        const events: EventData[] = ctx.events
 
-      if (events.length) {
-        ctx.events = []
-      }
+        if (events.length) {
+          ctx.events = []
+        }
 
-      return { events }
-    },
+        return { events }
+      },
 
-    async subscribe(req, ctx) {
-      ctx.subscribedEvents.add(req.eventId)
-      return {}
-    },
-    async unsubscribe(req, ctx) {
-      ctx.subscribedEvents.delete(req.eventId)
-      return {}
-    },
-    async crdtSendToRenderer(req, ctx) {
-      const protocol = await rendererProtocol
-      return protocol.crdtService.sendCrdt({
-        sceneId: ctx.sceneData.id,
-        payload: req.data,
-        sceneNumber: ctx.sceneData.sceneNumber
-      })
-    },
+      async subscribe(req, ctx) {
+        ctx.subscribedEvents.add(req.eventId)
+        return {}
+      },
+      async unsubscribe(req, ctx) {
+        ctx.subscribedEvents.delete(req.eventId)
+        return {}
+      },
+      async crdtSendToRenderer(req, ctx) {
+        return crdtService.sendCrdt({
+          sceneId: ctx.sceneData.id,
+          payload: req.data,
+          sceneNumber: ctx.sceneData.sceneNumber
+        })
+      },
 
-    async crdtGetMessageFromRenderer(_, ctx) {
-      const protocol = await rendererProtocol
-      const response = await protocol.crdtService.pullCrdt({
-        sceneId: ctx.sceneData.id,
-        sceneNumber: ctx.sceneData.sceneNumber
-      })
-      return { data: [response.payload] }
+      async crdtGetMessageFromRenderer(_, ctx) {
+        const response = await crdtService.pullCrdt({
+          sceneId: ctx.sceneData.id,
+          sceneNumber: ctx.sceneData.sceneNumber
+        })
+        return { data: [response.payload] }
+      }
     }
-  }))
+  })
 }
 function eaTypeToStr(type: EAType): EntityActionType | null {
   switch (type) {
diff --git a/packages/shared/apis/host/context.ts b/packages/shared/apis/host/context.ts
index 12ac9148f..c8186ecd4 100644
--- a/packages/shared/apis/host/context.ts
+++ b/packages/shared/apis/host/context.ts
@@ -2,6 +2,7 @@ import { ILogger } from './../../logger'
 import { EntityAction, LoadableScene } from './../../types'
 import { PermissionItem } from '@dcl/protocol/out-ts/decentraland/kernel/apis/permissions.gen'
 import { EventData } from '@dcl/protocol/out-ts/decentraland/kernel/apis/engine_api.gen'
+import { RpcClientPort } from '@dcl/rpc'
 
 type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] }
 
@@ -22,4 +23,7 @@ export type PortContext = {
   sendSceneEvent<K extends keyof IEvents>(id: K, event: IEvents[K]): void
   sendProtoSceneEvent(event: EventData): void
   logger: ILogger
+
+  // port used for this specific scene in the renderer
+  rendererPort: RpcClientPort
 }
diff --git a/packages/shared/comms/adapters/OfflineAdapter.ts b/packages/shared/comms/adapters/OfflineAdapter.ts
index 57a8955f9..f9927e3e3 100644
--- a/packages/shared/comms/adapters/OfflineAdapter.ts
+++ b/packages/shared/comms/adapters/OfflineAdapter.ts
@@ -10,7 +10,7 @@ export class OfflineAdapter implements MinimumCommunicationsAdapter {
   async getVoiceHandler(): Promise<VoiceHandler> {
     return createOpusVoiceHandler()
   }
-  async disconnect(error?: Error | undefined): Promise<void> {}
-  send(data: Uint8Array, hints: SendHints): void {}
+  async disconnect(_error?: Error | undefined): Promise<void> {}
+  send(_data: Uint8Array, _hints: SendHints): void {}
   async connect(): Promise<void> {}
 }
diff --git a/packages/shared/comms/adapters/SimulatorAdapter.ts b/packages/shared/comms/adapters/SimulatorAdapter.ts
index 99ff1b069..de8ee727f 100644
--- a/packages/shared/comms/adapters/SimulatorAdapter.ts
+++ b/packages/shared/comms/adapters/SimulatorAdapter.ts
@@ -46,9 +46,9 @@ export class SimulationRoom implements RoomConnection {
     this.tick = setInterval(this.update.bind(this), 60)
     this.roomConnection = new Rfc4RoomConnection({
       events: mitt<CommsAdapterEvents>(),
-      send(data: Uint8Array, hints: SendHints): void {},
+      send(_data: Uint8Array, _hints: SendHints): void {},
       async connect(): Promise<void> {},
-      async disconnect(error?: Error): Promise<void> {},
+      async disconnect(_error?: Error): Promise<void> {},
       async getVoiceHandler() {
         throw new Error('not implemented')
       }
@@ -190,11 +190,11 @@ export class SimulationRoom implements RoomConnection {
     }
   }
 
-  async disconnect(error?: Error | undefined): Promise<void> {
+  async disconnect(_error?: Error | undefined): Promise<void> {
     clearInterval(this.tick)
   }
 
-  send(data: Uint8Array, hints: SendHints): void {}
+  send(_data: Uint8Array, _hints: SendHints): void {}
 
   async connect(): Promise<void> {
     await Promise.all(new Array(100).fill(0).map(() => this.spawnPeer()))
diff --git a/packages/shared/comms/adapters/WebSocketAdapter.ts b/packages/shared/comms/adapters/WebSocketAdapter.ts
index 07f3ef5ef..9f206b9ae 100644
--- a/packages/shared/comms/adapters/WebSocketAdapter.ts
+++ b/packages/shared/comms/adapters/WebSocketAdapter.ts
@@ -158,7 +158,7 @@ export class WebSocketAdapter implements MinimumCommunicationsAdapter {
     this.internalDisconnect(false, error)
   }
 
-  internalDisconnect(kicked: boolean, error?: Error) {
+  internalDisconnect(kicked: boolean, _error?: Error) {
     if (this.ws) {
       const ws = this.ws
       this.ws = null
diff --git a/packages/shared/comms/adapters/voice/audioDebugger.ts b/packages/shared/comms/adapters/voice/audioDebugger.ts
index 32bf8e7ea..3f2f30526 100644
--- a/packages/shared/comms/adapters/voice/audioDebugger.ts
+++ b/packages/shared/comms/adapters/voice/audioDebugger.ts
@@ -1,4 +1,5 @@
 import mitt from 'mitt'
+// eslint-ignore @typescript-eslint/no-unused-vars
 
 type BaseNode = {
   cyId: number
@@ -194,7 +195,7 @@ if (document.location.search.includes('AUDIO_DEBUG')) {
 
   AudioNode.prototype.disconnect = decoratePrototype(
     AudioNode.prototype.disconnect,
-    function (this: any, result: any, args: any[]) {
+    function (this: any, _result: any, _args: any[]) {
       events.emit('removeNode', {
         node: this
       })
@@ -203,7 +204,7 @@ if (document.location.search.includes('AUDIO_DEBUG')) {
 
   AudioBufferSourceNode.prototype.start = decoratePrototype(
     AudioBufferSourceNode.prototype.start,
-    function (this: any, result: any, args: any[]) {
+    function (this: any, _result: any, _args: any[]) {
       console.log('WebAudioDebugger: AudioBufferSourceNode start')
     }
   )
@@ -220,14 +221,14 @@ if (document.location.search.includes('AUDIO_DEBUG')) {
 
   PannerNode.prototype.setPosition = decoratePrototype(
     PannerNode.prototype.setPosition,
-    function (this: PannerNode, result: any, args: any[]) {
+    function (this: PannerNode, _result: any, _args: any[]) {
       events.emit('graphChanged', { ...currentGraphState })
     }
   )
 
   AudioListener.prototype.setPosition = decoratePrototype(
     AudioListener.prototype.setPosition,
-    function (this: PannerNode, result: any, args: any[]) {
+    function (this: PannerNode, _result: any, _args: any[]) {
       events.emit('graphChanged', { ...currentGraphState })
     }
   )
diff --git a/packages/shared/index.ts b/packages/shared/index.ts
index 15bb209bf..087043038 100644
--- a/packages/shared/index.ts
+++ b/packages/shared/index.ts
@@ -1,4 +1,3 @@
-import { DEBUG_PREFIX } from 'config'
 import { notStarted } from './loading/types'
 import { buildStore } from './store/store'
 import { globalObservable } from './observables'
@@ -6,14 +5,11 @@ import { isRendererVisible } from './loading/selectors'
 import { RootStore } from './store/rootTypes'
 import { initializeSessionObserver } from './session/sagas'
 import { hookAnalyticsObservables } from './analytics/hook-observable'
-import wrapConsoleLogger from './logger/wrap'
 import { beforeUnloadAction } from './actions'
 
 declare const globalThis: { globalStore: RootStore }
 
 export function initShared() {
-  wrapConsoleLogger(DEBUG_PREFIX || '')
-
   if (globalThis.globalStore) {
     return
   }
diff --git a/packages/shared/realm/connections/BFFLegacy.ts b/packages/shared/realm/connections/BFFLegacy.ts
index 103d1db97..1acc50e34 100644
--- a/packages/shared/realm/connections/BFFLegacy.ts
+++ b/packages/shared/realm/connections/BFFLegacy.ts
@@ -5,7 +5,7 @@ import { localCommsService } from '../local-services/comms'
 import { legacyServices } from '../local-services/legacy'
 import { AboutResponse } from '@dcl/protocol/out-ts/decentraland/bff/http_endpoints.gen'
 
-export function localBff(baseUrl: string, about: AboutResponse, identity: ExplorerIdentity): IRealmAdapter {
+export function localBff(baseUrl: string, about: AboutResponse, _identity: ExplorerIdentity): IRealmAdapter {
   const events = mitt<RealmConnectionEvents>()
 
   const services: BffServices = {
diff --git a/packages/shared/renderer/actions.ts b/packages/shared/renderer/actions.ts
index f2ec7b381..f29e37eb0 100644
--- a/packages/shared/renderer/actions.ts
+++ b/packages/shared/renderer/actions.ts
@@ -3,11 +3,18 @@ import { action } from 'typesafe-actions'
 import type { UnityGame } from '@dcl/unity-renderer/src/index'
 
 import { RENDERER_INITIALIZED_CORRECTLY, PARCEL_LOADING_STARTED, RENDERER_INITIALIZE } from './types'
+import { RpcClientPort, Transport } from '@dcl/rpc'
 
-export const initializeRenderer = (delegate: (container: HTMLElement) => Promise<UnityGame>, container: HTMLElement) =>
-  action(RENDERER_INITIALIZE, { delegate, container })
+export const initializeRenderer = (
+  delegate: (container: HTMLElement) => Promise<{ renderer: UnityGame; transport: Transport }>,
+  container: HTMLElement
+) => action(RENDERER_INITIALIZE, { delegate, container })
 export type InitializeRenderer = ReturnType<typeof initializeRenderer>
 
+export const REGISTER_RPC_PORT = 'REGISTER_RPC_PORT'
+export const registerRendererPort = (clientPort: RpcClientPort) => action(REGISTER_RPC_PORT, { clientPort })
+export type RegisterRendererPort = ReturnType<typeof registerRendererPort>
+
 export const signalRendererInitializedCorrectly = () => action(RENDERER_INITIALIZED_CORRECTLY)
 export type SignalRendererInitialized = ReturnType<typeof signalRendererInitializedCorrectly>
 
diff --git a/packages/shared/renderer/reducer.ts b/packages/shared/renderer/reducer.ts
index 4e0d7748f..0f69499d0 100644
--- a/packages/shared/renderer/reducer.ts
+++ b/packages/shared/renderer/reducer.ts
@@ -1,9 +1,11 @@
 import { AnyAction } from 'redux'
+import { RegisterRendererPort, REGISTER_RPC_PORT } from './actions'
 import { PARCEL_LOADING_STARTED, RendererState, RENDERER_INITIALIZED_CORRECTLY } from './types'
 
 const INITIAL_STATE: RendererState = {
   initialized: false,
-  parcelLoadingStarted: false
+  parcelLoadingStarted: false,
+  clientPort: undefined
 }
 
 export function rendererReducer(state?: RendererState, action?: AnyAction): RendererState {
@@ -19,6 +21,11 @@ export function rendererReducer(state?: RendererState, action?: AnyAction): Rend
         ...state,
         initialized: true
       }
+    case REGISTER_RPC_PORT:
+      return {
+        ...state,
+        clientPort: (action as RegisterRendererPort).payload.clientPort
+      }
     case PARCEL_LOADING_STARTED:
       return {
         ...state,
diff --git a/packages/shared/renderer/sagas.ts b/packages/shared/renderer/sagas.ts
index 7a552d2d1..1e164978e 100644
--- a/packages/shared/renderer/sagas.ts
+++ b/packages/shared/renderer/sagas.ts
@@ -2,7 +2,7 @@ import { call, put, select, take, takeEvery, takeLatest, fork } from 'redux-saga
 import { waitingForRenderer } from 'shared/loading/types'
 import { initializeEngine } from 'unity-interface/dcl'
 import type { UnityGame } from '@dcl/unity-renderer/src/index'
-import { InitializeRenderer } from './actions'
+import { InitializeRenderer, registerRendererPort } from './actions'
 import { getParcelLoadingStarted } from './selectors'
 import { RENDERER_INITIALIZE } from './types'
 import { trackEvent } from 'shared/analytics'
@@ -53,6 +53,8 @@ import { getVoiceHandler } from 'shared/voiceChat/selectors'
 import { SceneWorker } from 'shared/world/SceneWorker'
 import { getSceneWorkerBySceneID } from 'shared/world/parcelSceneManager'
 import { LoadingState } from 'shared/loading/reducer'
+import { RpcClientPort, Transport } from '@dcl/rpc'
+import { createRendererRpcClient } from 'renderer-protocol/rpcClient'
 
 export function* rendererSaga() {
   yield takeEvery(SEND_PROFILE_TO_RENDERER, handleSubmitProfileToRenderer)
@@ -234,12 +236,16 @@ function* initializeRenderer(action: InitializeRenderer) {
 
   // start loading the renderer
   try {
-    const renderer: UnityGame = yield call(delegate, container)
+    const { renderer, transport }: { renderer: UnityGame; transport: Transport } = yield call(delegate, container)
 
     const startTime = performance.now()
 
     trackEvent('renderer_initializing_start', {})
 
+    // register the RPC port
+    const rpcClientPort: RpcClientPort = yield call(createRendererRpcClient, transport)
+    yield put(registerRendererPort(rpcClientPort))
+
     // wire the kernel to the renderer, at some point, the `initializeEngine`
     // function _MUST_ send the `signalRendererInitializedCorrectly` action
     // to signal that the renderer successfuly loaded
diff --git a/packages/shared/renderer/selectors.ts b/packages/shared/renderer/selectors.ts
index ccbecfc2a..66cc751ac 100644
--- a/packages/shared/renderer/selectors.ts
+++ b/packages/shared/renderer/selectors.ts
@@ -3,6 +3,11 @@ import { RootRendererState } from './types'
 export function isRendererInitialized(state: RootRendererState) {
   return state && state.renderer && state.renderer.initialized
 }
+
 export function getParcelLoadingStarted(state: RootRendererState) {
   return state && state.renderer && state.renderer.parcelLoadingStarted
 }
+
+export function getClientPort(state: RootRendererState) {
+  return state && state.renderer && state.renderer.clientPort
+}
diff --git a/packages/shared/renderer/types.ts b/packages/shared/renderer/types.ts
index f76798956..758f610cf 100644
--- a/packages/shared/renderer/types.ts
+++ b/packages/shared/renderer/types.ts
@@ -1,3 +1,5 @@
+import { RpcClientPort } from '@dcl/rpc'
+
 export const RENDERER_INITIALIZED_CORRECTLY = '[RENDERER] Renderer initialized correctly'
 export const PARCEL_LOADING_STARTED = '[RENDERER] Parcel loading started'
 export const RENDERER_INITIALIZE = '[RENDERER] Initializing'
@@ -5,6 +7,7 @@ export const RENDERER_INITIALIZE = '[RENDERER] Initializing'
 export type RendererState = {
   initialized: boolean
   parcelLoadingStarted: boolean
+  clientPort: RpcClientPort | undefined
 }
 
 export type RootRendererState = {
diff --git a/packages/shared/scene-loader/world-loader-impl/index.ts b/packages/shared/scene-loader/world-loader-impl/index.ts
index a9928e89d..5a65b7dc1 100644
--- a/packages/shared/scene-loader/world-loader-impl/index.ts
+++ b/packages/shared/scene-loader/world-loader-impl/index.ts
@@ -4,10 +4,10 @@ import { ISceneLoader } from '../types'
 export async function createWorldLoader(options: { urns: string[] }): Promise<ISceneLoader> {
   const scenes = await Promise.all(options.urns.map((urn) => getPortableExperienceFromUrn(urn)))
   return {
-    async fetchScenesByLocation(parcels) {
+    async fetchScenesByLocation(_parcels) {
       return { scenes }
     },
-    async reportPosition(positionReport) {
+    async reportPosition(_positionReport) {
       return { scenes }
     },
     async stop() {}
diff --git a/packages/shared/session/getPerformanceInfo.ts b/packages/shared/session/getPerformanceInfo.ts
index 17961ab77..a7fb316d2 100644
--- a/packages/shared/session/getPerformanceInfo.ts
+++ b/packages/shared/session/getPerformanceInfo.ts
@@ -47,7 +47,7 @@ export function incrementAvatarSceneMessages(value: number) {
   commsPerfObservable.emit('avatar-renderer', { value })
 }
 
-export function incrementCommsMessageSent(bytes: number) {
+export function incrementCommsMessageSent(_bytes: number) {
   sentCommsMessagesCounter++
 }
 
diff --git a/packages/shared/web3.ts b/packages/shared/web3.ts
index f6d0692bd..ed9b1367e 100644
--- a/packages/shared/web3.ts
+++ b/packages/shared/web3.ts
@@ -389,7 +389,7 @@ export async function fetchENSOwnersContains(url: string, name: string, maxResul
   }
 }
 
-async function queryGraph(url: string, query: string, variables: any, totalAttempts: number = 5) {
+async function queryGraph(url: string, query: string, variables: any, _totalAttempts: number = 5) {
   const ret = await fetch(url, {
     body: JSON.stringify({ query, variables }),
     headers: { 'Content-Type': 'application/json' }
diff --git a/packages/shared/world/SceneWorker.ts b/packages/shared/world/SceneWorker.ts
index b088b5004..bd7e94205 100644
--- a/packages/shared/world/SceneWorker.ts
+++ b/packages/shared/world/SceneWorker.ts
@@ -8,7 +8,7 @@ import {
   WSS_ENABLED
 } from 'config'
 import { PositionReport } from './positionThings'
-import { createRpcServer, RpcServer, Transport } from '@dcl/rpc'
+import { createRpcServer, RpcClientPort, RpcServer, Transport } from '@dcl/rpc'
 import { WebWorkerTransport } from '@dcl/rpc/dist/transports/WebWorker'
 import { EventDataType } from '@dcl/protocol/out-ts/decentraland/kernel/apis/engine_api.gen'
 import { registerServices } from 'shared/apis/host'
@@ -106,6 +106,7 @@ export class SceneWorker {
 
   constructor(
     public readonly loadableScene: Readonly<LoadableScene>,
+    rendererPort: RpcClientPort,
     public readonly transport: Transport = buildWebWorkerTransport(loadableScene)
   ) {
     ++globalSceneNumberCounter
@@ -124,6 +125,7 @@ export class SceneWorker {
     }
 
     this.rpcContext = {
+      rendererPort,
       sceneData: {
         isPortableExperience: false,
         useFPSThrottling: false,
@@ -243,7 +245,7 @@ export class SceneWorker {
   }
 
   // when an user leaves the scene
-  onLeave(userId: string, self: boolean) {
+  onLeave(userId: string, _self: boolean) {
     // if the scene is a portable experience, then people never leaves the scene
     if (this.rpcContext.sceneData.isPortableExperience) return
     this.rpcContext.sendSceneEvent('onLeaveScene', { userId })
diff --git a/packages/shared/world/TeleportController.ts b/packages/shared/world/TeleportController.ts
index 459f82686..442fa887f 100644
--- a/packages/shared/world/TeleportController.ts
+++ b/packages/shared/world/TeleportController.ts
@@ -105,7 +105,7 @@ export class TeleportController {
     }
   }
 
-  public static LoadingHUDReadyForTeleport(data: { x: number; y: number }) {
+  public static LoadingHUDReadyForTeleport(_data: { x: number; y: number }) {
     /// This doesn't work when the logic of activate/deactivate rendering is so tightly coupled with the loading
     /// screen. The code needs rework
     // store.dispatch(teleportToAction({ position: gridToWorld(data.x, data.y) }))
diff --git a/packages/shared/world/parcelSceneManager.ts b/packages/shared/world/parcelSceneManager.ts
index e1271e15f..0a278951f 100644
--- a/packages/shared/world/parcelSceneManager.ts
+++ b/packages/shared/world/parcelSceneManager.ts
@@ -7,6 +7,7 @@ import { ParcelSceneLoadingState } from './types'
 import { getFeatureFlagVariantValue } from 'shared/meta/selectors'
 import { Transport } from '@dcl/rpc'
 import { defaultParcelPermissions } from 'shared/apis/host/Permissions'
+import { getClientPort } from 'shared/renderer/selectors'
 
 declare const globalThis: any
 
@@ -82,7 +83,10 @@ export function loadParcelSceneWorker(loadableScene: LoadableScene, transport?:
   let parcelSceneWorker = loadedSceneWorkers.get(sceneId)
 
   if (!parcelSceneWorker) {
-    parcelSceneWorker = new SceneWorker(loadableScene, transport)
+    const rendererPort = getClientPort(store.getState())
+    if (!rendererPort) throw new Error('Cannot create a scene because there is no clientPort')
+
+    parcelSceneWorker = new SceneWorker(loadableScene, rendererPort, transport)
     setNewParcelScene(parcelSceneWorker)
     queueMicrotask(() => store.dispatch(scenesChanged()))
   }
diff --git a/packages/unity-interface/BrowserInterface.ts b/packages/unity-interface/BrowserInterface.ts
index 76f136e96..70c259f64 100644
--- a/packages/unity-interface/BrowserInterface.ts
+++ b/packages/unity-interface/BrowserInterface.ts
@@ -1036,7 +1036,7 @@ export class BrowserInterface {
     )
   }
 
-  public UnpublishScene(data: any) {
+  public UnpublishScene(_data: any) {
     // deprecated
   }
 
diff --git a/packages/unity-interface/initializer.ts b/packages/unity-interface/initializer.ts
index c1b9af200..1eb4a18ec 100644
--- a/packages/unity-interface/initializer.ts
+++ b/packages/unity-interface/initializer.ts
@@ -18,7 +18,7 @@ import defaultLogger from 'shared/logger'
 import { trackEvent } from '../shared/analytics'
 import { browserInterface } from './BrowserInterface'
 import { webTransport } from '../renderer-protocol/transports/webTransport'
-import { createRendererRpcClient } from '../renderer-protocol/rpcClient'
+import { Transport } from '@dcl/rpc'
 
 export type InitializeUnityResult = {
   container: HTMLElement
@@ -43,7 +43,9 @@ const defaultOptions: CommonRendererOptions = traceDecoratorRendererOptions({
   }
 })
 
-async function loadInjectedUnityDelegate(container: HTMLElement): Promise<UnityGame> {
+async function loadInjectedUnityDelegate(
+  container: HTMLElement
+): Promise<{ renderer: UnityGame; transport: Transport }> {
   // inject unity loader
   const rootArtifactsUrl = rendererOptions.baseUrl || ''
 
@@ -96,11 +98,7 @@ async function loadInjectedUnityDelegate(container: HTMLElement): Promise<UnityG
     return true
   }
 
-  const transport = webTransport({ wasmModule: originalUnity.Module })
-  createRendererRpcClient(transport).catch((e) => {
-    console.error(e)
-    debugger
-  })
+  const transport = webTransport({ wasmModule: originalUnity.Module }, (globalThis as any).DCL)
 
   await engineStartedFuture
   await browserInterface.startedFuture
@@ -112,11 +110,11 @@ async function loadInjectedUnityDelegate(container: HTMLElement): Promise<UnityG
     browserInterface.onUserInteraction.resolve()
   })
 
-  return originalUnity
+  return { renderer: originalUnity, transport }
 }
 
 /** Initialize engine using WS transport (UnityEditor) */
-async function loadWsEditorDelegate(container: HTMLElement): Promise<UnityGame> {
+async function loadWsEditorDelegate(container: HTMLElement) {
   const queryParams = new URLSearchParams(document.location.search)
 
   return initializeUnityEditor(queryParams.get('ws')!, container, defaultOptions)
diff --git a/packages/unity-interface/wsEditorAdapter.ts b/packages/unity-interface/wsEditorAdapter.ts
index c821e43d9..6aa5a7a04 100644
--- a/packages/unity-interface/wsEditorAdapter.ts
+++ b/packages/unity-interface/wsEditorAdapter.ts
@@ -1,14 +1,14 @@
 import type { UnityGame } from '@dcl/unity-renderer/src/index'
 import { CommonRendererOptions } from './loader'
 import { webSocketTransportAdapter } from '../renderer-protocol/transports/webSocketTransportAdapter'
-import { createRendererRpcClient } from '../renderer-protocol/rpcClient'
+import { Transport } from '@dcl/rpc'
 
 /** This connects the local game to a native client via WebSocket */
 export async function initializeUnityEditor(
   wsUrl: string,
   container: HTMLElement,
   options: CommonRendererOptions
-): Promise<UnityGame> {
+): Promise<{ renderer: UnityGame; transport: Transport }> {
   container.innerHTML = `<h3>Connecting...</h3>`
 
   const transport = webSocketTransportAdapter(wsUrl, options)
@@ -22,7 +22,7 @@ export async function initializeUnityEditor(
     container.innerHTML = `<h3 style='color:red'>Disconnected</h3>`
   })
 
-  const gameInstance: UnityGame = {
+  const renderer: UnityGame = {
     Module: {},
     SendMessage(_obj, type, payload) {
       transport.sendMessage({ type, payload } as any)
@@ -35,7 +35,5 @@ export async function initializeUnityEditor(
     }
   }
 
-  createRendererRpcClient(transport).catch((_e) => {})
-
-  return gameInstance
+  return { renderer, transport }
 }
diff --git a/test/unit/RestrictedActions.test.tsx b/test/unit/RestrictedActions.test.tsx
index 8ed29fb65..9d37f3780 100644
--- a/test/unit/RestrictedActions.test.tsx
+++ b/test/unit/RestrictedActions.test.tsx
@@ -123,6 +123,7 @@ describe('RestrictedActions tests', () => {
     return {
       sceneData,
       logger: defaultLogger,
+      rendererPort: null as any,
       permissionGranted: new Set(permissions),
       subscribedEvents: new Set(),
       events: [],