improve routing

iframes/iframe-com-interface.ts

@@ -56,12 +56,13 @@ export class IFrameCommunicationInterface extends CommonInterface<[HTMLIFrameEle
     }
 
     onReceive = (event: MessageEvent) => {
-        if (event.origin == this.otherOrigin) {
+
+        if (event.source === this.other) {
             const data = event.data;
             if (data instanceof ArrayBuffer) {
                 InterfaceManager.handleReceiveBlock(data, this.endpoint, this);
             }
-            else if (data?.type == "INIT") {
+            else if (data?.type == "INIT" && !this.endpoint) {
                 this.endpoint = Target.get(data.endpoint) as Datex.Endpoint;
 
                 // if in parent: send INIT to iframe after initialized

network/blockchain_adapter.ts

@@ -88,7 +88,7 @@ export type BCData<T extends BCEntryType> =
 
 	public async sign(){
 		const data_dx = Datex.Compiler.encodeValue(this.data);
-		this.creator = Datex.Runtime.endpoint;
+		this.creator = Datex.Runtime.endpoint.main;
 		this.signature = await Datex.Crypto.sign(data_dx);
 		return this;
 	}

network/client.ts

@@ -150,6 +150,7 @@ export abstract class CommonInterface<Args extends unknown[] = []> implements Co
 
     // use this per default for all outgoing datex requests
     public static default_interface:ComInterface;
+    public static proxy_interface?:ComInterface;
 
     public type = "local"
     public persistent = false; // interface can be disconnected (per default)
@@ -167,9 +168,11 @@ export abstract class CommonInterface<Args extends unknown[] = []> implements Co
     }
 
     public set endpoint(endpoint: Endpoint|undefined) {
+        if (endpoint === this._endpoint) return;
         this.logger.debug("updated endpoint to " + endpoint);
         this._endpoint = endpoint;
         this.updateEndpoint();
+        this.onEndpointSet?.(endpoint);
     }
 
     private updateEndpoint() {
@@ -179,6 +182,8 @@ export abstract class CommonInterface<Args extends unknown[] = []> implements Co
         }
     }
 
+    private onEndpointSet?: Function
+
 
     protected declare initial_arguments:Args
 
@@ -806,10 +811,15 @@ export class InterfaceManager {
             return InterfaceManager.handleNoRedirectFound(to);
         }
 
+        // prefere proxy_interface
+        if (CommonInterface.proxy_interface) comInterface = CommonInterface.proxy_interface;
+
         // error: loopback
         if (source && !source?.is_bidirectional_hub && (source == comInterface || comInterface.isEqualSource?.(source, to))) {
             // fallback to default interface
             if (CommonInterface.default_interface && comInterface !== CommonInterface.default_interface) comInterface = CommonInterface.default_interface;
+            // fallback to proxy interface
+            if (CommonInterface.proxy_interface && comInterface !== CommonInterface.proxy_interface) comInterface = CommonInterface.proxy_interface;
             else return InterfaceManager.handleNoRedirectFound(to);
         }
 
@@ -823,7 +833,7 @@ export class InterfaceManager {
         const exclude_endpoints = new Set([exclude]);
 
         // iterate over all active endpoints
-        for (const interf of this.active_interfaces) {
+        for (const interf of CommonInterface.proxy_interface ? [CommonInterface.proxy_interface]: this.active_interfaces) {
             if (interf.endpoint && !exclude_endpoints.has(interf.endpoint) && !interf.endpoint.equals(Runtime.endpoint)) {
             exclude_endpoints.add(interf.endpoint);
             //console.log("FLOOD > " + interf.endpoint)

network/supranet.ts

@@ -121,14 +121,20 @@ export class Supranet {
         else {
             // existing locally available endpoint instances -> hashes
             const hashes = await Storage.loadOrCreate("Datex.Supranet.ENDPOINT_INSTANCE_HASHES", () => new Map<Endpoint, string>())
-
-            logger.debug("available cached instances: " + [...hashes.keys()].map(e=>e.toString()).join(", "))
+
+            try {
+                logger.debug("available cached instances: " + [...hashes.keys()].map(e=>e.toString()).join(", "))
+            }
+            catch (e) {
+                console.error("invalid hashes", hashes)
+                throw e;
+            }
 
             const activeEndpoints = Runtime.getActiveLocalStorageEndpoints();
             let hash: string|undefined = undefined;
             let endpoint = Runtime.endpoint;
             for (const [storedEndpoint, storedHash] of hashes) {
-                if (!activeEndpoints.includes(storedEndpoint)) {
+                if (Runtime.endpoint.main == storedEndpoint.main && !activeEndpoints.includes(storedEndpoint)) {
                     hash = storedHash;
                     endpoint = storedEndpoint;
                     break;

types/function-utils.ts

@@ -114,11 +114,19 @@ export async function getDeclaredExternalVariablesAsync(fn: (...args:unknown[])=
 }
 
 export function getSourceWithoutUsingDeclaration(fn: (...args:unknown[])=>unknown) {
-    return fn
-        .toString()
+    let fnSource = fn.toString();
+	// object methods check if 'this' context is component context;
+	if (isObjectMethod(fnSource)) {
+        if (fnSource.startsWith("async")) fnSource = fnSource.replace("async", "async function") 
+		else fnSource = "function " + fnSource
+	}
+    return fnSource
         .replace(/(?<=(?:(?:[\w\s*])+\(.*\)\s*{|\(.*\)\s*=>\s*{?|.*\s*=>\s*{?)\s*)(use\s*\((?:[\s\S]*?)\))/, 'true /*$1*/')
 }
-
+
+function isObjectMethod(fnSrc:string) {
+	return !!fnSrc.match(/^(async\s+)?[^\s(]+ *(\(|\*)/)
+}
 
 /**
  * Create a new function from JS source code with injected dependency variables
@@ -139,9 +147,16 @@ export function createFunctionWithDependencyInjections(source: string, dependenc
         return val;
     };`
 
-    let creatorFn = new Function(...renamedVars, `"use strict";${varMapping?createStaticFn:''}${varMapping}; return (${source})`)
-    if (hasThis) creatorFn = creatorFn.bind(dependencies['this'])
-    return creatorFn(...Object.values(dependencies));
+    try {
+        let creatorFn = new Function(...renamedVars, `"use strict";${varMapping?createStaticFn:''}${varMapping}; return (${source})`)
+        if (hasThis) creatorFn = creatorFn.bind(dependencies['this'])
+        return creatorFn(...Object.values(dependencies));
+    }
+    catch (e) {
+        console.error(source)
+        throw e;
+    }
+
 }
 
 export class ExtensibleFunction {

windows/window-com-interface.ts

@@ -21,8 +21,8 @@ export class WindowCommunicationInterface extends CommonInterface<[Window, strin
 
     protected async connect() {
         // is the parent document
-        if (!this.initial_arguments[0]?.opener || 
-            (this.initial_arguments[0].opener === self.window)) {
+        console.log("iinit", this.initial_arguments)
+        if (this.initial_arguments[0] !== self.window.opener) {
             this.window = this.initial_arguments[0];
             this.otherOrigin = this.initial_arguments[1];
             this.logger.info("initializing as parent window, window origin: " + this.otherOrigin)
@@ -40,6 +40,7 @@ export class WindowCommunicationInterface extends CommonInterface<[Window, strin
 		}
         globalThis.addEventListener("message", this.onReceive);
         // if in sub window: send INIT to parent immediately
+        console.log("SEND sendInit", this.parentDocument)
         if (this.parentDocument)
             this.sendInit();
 
@@ -55,6 +56,7 @@ export class WindowCommunicationInterface extends CommonInterface<[Window, strin
             }
 
             else if (data?.type == "INIT") {
+                console.warn(" && !this.endpoint",  !this.endpoint)
                 this.endpoint = Target.get(data.endpoint) as Datex.Endpoint;
 
                 // if in parent: send INIT to window after initialized
@@ -64,6 +66,7 @@ export class WindowCommunicationInterface extends CommonInterface<[Window, strin
     }
 
     private sendInit() {
+        console.log("SEND sendInit...")
         this.other.postMessage({
             type:"INIT",
             endpoint:Datex.Runtime.endpoint.toString()
@@ -78,7 +81,7 @@ export class WindowCommunicationInterface extends CommonInterface<[Window, strin
     get other() {
         return this.window ?
             this.window :
-            this.parentDocument?.opener
+            this.parentDocument
     }
 
     protected sendBlock(datex: ArrayBuffer) {