before rewrite to have callbacks as FIRST parameter

src/Frontend.ts

 import * as T from './Types';
 import * as I from './Interfaces';
 import { stripAfterEquals, appendComma } from './Utils';
-import { DESTROY_PREFIX, SOCKET_NOT_CONNECTED, UNKNOWN_RPC_IDENTIFIER, USER_DEFINED_TIMEOUT } from './Strings';
+import { CALLBACK_NAME, DESTROY_PREFIX, SOCKET_NOT_CONNECTED, UNKNOWN_RPC_IDENTIFIER, USER_DEFINED_TIMEOUT } from './Strings';
 import { DeserializerFactory } from './Decorator';
 DeserializerFactory
 
 
     private socket: I.Socket
     private handlers: {
-        [name in string]: T.AnyFunction[]
+        [name in string]: T.GenericFunction[]
     } = {
             error: [],
             close: []
         }
-    private hooks: { [name in string]: T.AnyFunction } = {}
+    private hooks: { [name in string]: T.GenericFunction } = {}
 
     /**
      * 
      * @param type 'error' or 'close'
      * @param f The listener to attach
      */
-    public on(type: string, f: T.AnyFunction) {
+    public on(type: string, f: T.GenericFunction) {
         if (!this.socket) {
             if (!this.handlers[type])
                 this.handlers[type] = []
             v.forEach(h => this.socket.on(k, h))
         })
 
-        Object.entries(this.hooks).forEach((kv: [string, T.AnyFunction]) => {
+        Object.entries(this.hooks).forEach((kv: [string, T.GenericFunction]) => {
             this.socket.hook(kv[0], kv[1])
         })
         const info: T.ExtendedRpcInfo[] = await this.info(sesame)
      * @param fnName The function name
      * @param fnArgs A string-list of parameters
      */
-    private callGenerator(fnName: string, fnArgs: string[], sesame?: string): T.AnyFunction {
+    private callGenerator(fnName: string, fnArgs: string[], sesame?: string): T.GenericFunction {
         const headerArgs = fnArgs.join(",")
         const argParams = fnArgs.map(stripAfterEquals).join(",")
         sesame = appendComma(sesame)
      * @param fnName The function name
      * @param fnArgs A string-list of parameters
      */
-    private frontEndHookGenerator(fnName: string, fnArgs: string[], sesame?: string): T.HookFunction {
+    private frontEndHookGenerator(fnName: string, fnArgs: string[], sesame?: string): T.GenericFunction {
 
         if (sesame)
             fnArgs.shift()
         const destroy_prefix = DESTROY_PREFIX
 
         const frontendHookStr = `
-        async (${headerArgs} $__callback__$) => {
+        async (${headerArgs} ${CALLBACK_NAME}) => {
             const r = await this.call("${fnName}", ${sesame} ${argParams})
             try{
                 if(r){
                     if(r.uuid){
-                        $__callback__$['destroy'] = () => {
+                        ${CALLBACK_NAME}['destroy'] = () => {
                             this.socket.fire(destroy_prefix+r.uuid)
                             this.socket.unhook(r.uuid) 
                         }
-                        this.socket.hook(r.uuid, $__callback__$)
+                        ${CALLBACK_NAME} = ${CALLBACK_NAME}.bind({
+                            destroy: ${CALLBACK_NAME}['destroy']
+                        })
+
+                        this.socket.hook(r.uuid, (...args) => {
+                            ${CALLBACK_NAME}.apply(${CALLBACK_NAME}, args.map(deserializer.from))
+                        })
                     }
                     return deserializer.from(r.return)
                 }else{

src/Interfaces.ts

     id?: string
     bind: (name: string, listener: T.PioBindListener) => void
     hook: (rpcname: string, handler: T.PioHookListener) => void
-    unhook: (rpcname: string, listener?:T.AnyFunction) => void
+    unhook: (rpcname: string, listener?:T.GenericFunction) => void
     call: (rpcname: string, ...args: any[]) => Promise<any>
     fire: (rpcname: string, ...args: any[]) => Promise<any>
-    on: (type: string, f: T.AnyFunction)=>any
+    on: (type: string, f: T.GenericFunction)=>any
     emit: (eventName: string, ...args: any[]) => void
     close(): void
   }

src/Strings.ts

 \n${name}
 \n>------------OFFENDING RPC`
 export const CLASSNAME_ATTRIBUTE = "$__CLASSNAME__$"
-export const DESTROY_PREFIX = "$__DESTROY__$_"
+export const DESTROY_PREFIX = "$__DESTROY__$_"
+export const CALLBACK_NAME = "$__CALLBACK__$"

src/Types.ts

 import * as I from "./Interfaces";
 import { RPCSocket } from "./Frontend";
-import { PromiseIO } from "./PromiseIO/Server";
 
 export type PioBindListener = (...args: any) => void
-export type PioHookListener = AnyFunction
+export type PioHookListener = GenericFunction
+
+export type GenericFunction<Parameters extends any[] = any[], Result = any> = {(...args: Parameters): Result}
+
+export type BackendHook<Func extends GenericFunction> =
+    GenericFunction<
+        [
+            ...Head<Parameters<Func>>,
+            GenericFunction<
+                Parameters<
+                    AsFunction<
+                        Last<Parameters<Func>>
+                    >
+                >,
+                void
+            >
+        ],
+        ReturnType<Func>
+    >
+
 
-export type AnyFunction = (...args: any[]) => any
-export type HookFunction = AnyFunction
 export type AccessFilter<InterfaceT extends RPCInterface = RPCInterface> = (sesame: string | undefined, exporter: I.RPCExporter<InterfaceT, keyof InterfaceT>) => Promise<boolean> | boolean
 export type Visibility = "127.0.0.1" | "0.0.0.0"
 export type ConnectionHandler = (socket: I.Socket) => void
 
 export type RPCType = 'Hook' | 'Unhook' | 'Call'
 
-export type CallRPC<Name, Func extends AnyFunction> = {
+export type CallRPC<Name, Func extends GenericFunction> = {
     name: Name
     call: Func
 }
 
-
-export type HookRPC<Name, Func extends AnyFunction> = {
+export type HookRPC<Name, Func extends GenericFunction> = {
     name: Name
-    hook: AnyFunction
-    onCallback?: AnyFunction
+    hook: BackendHook<Func>
+    onCallback?: GenericFunction
     onDestroy?: HookCloseFunction<ReturnType<Func> extends Promise<infer T> ? T : ReturnType<Func>>
 }
 
-export type RPC<Name, Func extends AnyFunction> = HookRPC<Name, Func> | CallRPC<Name, Func> | Func
+export type RPC<Name, Func extends GenericFunction> = HookRPC<Name, Func> | CallRPC<Name, Func> | Func
 
 export type RPCInterface<Impl extends RPCInterface = {}> = {
     [grp in string]: {
-        [rpc in string]: AnyFunction
+        [rpc in string]: GenericFunction
     }
 } & Impl
 
 }
 
 export type RPCDefinitions<Ifc extends RPCInterface> = {
-    [grp in keyof Ifc]: ({ 
-        [rpc in keyof Ifc[grp]]: RPC<rpc, Ifc[grp][rpc]> 
+    [grp in keyof Ifc]: ({
+        [rpc in keyof Ifc[grp]]: RPC<rpc, Ifc[grp][rpc]>
     }[keyof Ifc[grp]])[]
 }
 
 
 export type CallInfo = BaseInfo & {
     type: 'Call',
-    call: AnyFunction
+    call: GenericFunction
 }
 
 export type RpcInfo = HookInfo | CallInfo
 export type HookCloseFunction<T> = (res: T, rpc: HookRPC<any, any>) => any
 
 
-export type AsyncIfc<Ifc extends RPCInterface> = { [grp in keyof Ifc]: { [rpcname in keyof Ifc[grp]]: AsyncAnyFunction<Ifc[grp][rpcname]> } }
+export type AsyncIfc<Ifc extends RPCInterface> = { [grp in keyof Ifc]: { [rpcname in keyof Ifc[grp]]: AsyncGenericFunction<Ifc[grp][rpcname]> } }
 
-export type AsyncAnyFunction<F extends AnyFunction = AnyFunction> = F extends (...args: Parameters<F>) => infer R
+export type AsyncGenericFunction<F extends GenericFunction = GenericFunction> = F extends (...args: Parameters<F>) => infer R
     ? ((...args: Parameters<F>) => R extends Promise<any> ? R : Promise<R>)
     : Promise<any>
 
-type DYN_PARAM<
-    A = void, 
-    B = void,
-    C = void,
-    D = void,
-    E = void,
-    F = void,
-    G = void,
-    H = void,
-> = H extends void ?
-     G extends void ?
-      F extends void ?
-       E extends void ?
-        D extends void ?
-         C extends void ?
-          B extends void ?
-           A extends void ?
-            []
-            : [A]
-          : [A,B]
-         :[A,B,C]
-        :[A,B,C,D]
-       :[A,B,C,D,E]
-      :[A,B,C,D,E,F]
-     :[A,B,C,D,E,F,G]
-    :[A,B,C,D,E,F,G,H] 
 
 type Destroyable = { destroy: () => void }
-export type Callback<A0 = void, A1 = void, A2 = void, A3 = void, A4 = void, A5 = void, A6 = void, A7 = void> = 
-    (this: Destroyable, ...args: DYN_PARAM<A0, A1, A2, A3, A4, A5, A6, A7>) => void 
+export type Callback<Params extends any[] = []> =
+    (this: Destroyable, ...args: Params) => void
+
+type AsFunction<F> = F extends GenericFunction ? F : GenericFunction
+
+type Last<Tuple extends any[]> = Tuple[ Subtract<Length<Tuple>, 1> ]
+type Head<T extends any[]> = T extends [ ...infer Head, any ] ? Head : any[]
+type Tail<T extends any[]> = T extends [any, ...infer Tail] ? Tail: []
+
+type Length<T extends any[]> = 
+    T extends { length: infer L } ? L : never;
+
+type BuildTuple<L extends number, T extends any[] = []> = 
+    T extends { length: L } ? T : BuildTuple<L, [...T, any]>;
+
+type Subtract<A extends number, B extends number> = 
+    BuildTuple<A> extends [...(infer U), ...BuildTuple<B>]
+        ? Length<U>
+        : never;

src/Utils.ts

  * Decorate an RPC with the error handler
  * @param rpcFunction the function to decorate
  */
-const callGenerator = (rpcName: string, $__socket__$: I.Socket, rpcFunction: T.AnyFunction, errorHandler: T.ErrorHandler): T.AnyFunction => {
+const callGenerator = (rpcName: string, $__socket__$: I.Socket, rpcFunction: T.GenericFunction, errorHandler: T.ErrorHandler): T.GenericFunction => {
     const argsArr = extractArgs(rpcFunction)
     const args = argsArr.join(',')
     const argsStr = argsArr.map(stripAfterEquals).join(',')
  * @returns A {@link HookFunction}
  */
 const hookGenerator = (rpc: T.HookRPC<any, any>, errorHandler: T.ErrorHandler, sesameFn?: T.SesameFunction, injectSocket?: boolean): T.HookInfo['generator'] => {
+    const deserializer = DeserializerFactory 
     let argsArr = extractArgs(rpc.hook)
     argsArr.pop() //remove callback param
 
             const uuid = uuidv4()
             const res = await rpc.hook(${callArgs} (...cbargs) => {
                 ${rpc.onCallback ? `rpc.onCallback.apply({}, cbargs)` : ``}
+                cbargs = cbargs.map(deserializer.makeDeserializable)
                 $__socket__$.call.apply($__socket__$, [uuid, ...cbargs])
             })
             ${rpc.onDestroy ? `$__socket__$.bind(destroy_prefix+uuid, () => {
             res(undefined)
         }),
 
-        unhook: (name: string, listener?: T.AnyFunction) => {
+        unhook: (name: string, listener?: T.GenericFunction) => {
             if (listener) {
                 socket.removeListener(name, listener)
             } else {

test/Test.ts

 import { describe, it } from "mocha";
 import { RPCServer, RPCSocket, Serializable } from '../Index'
 import { RPCExporter, Socket } from "../src/Interfaces";
-import { ConnectedSocket, Callback } from "../src/Types";
+import { ConnectedSocket, Callback, GenericFunction } from "../src/Types";
 import * as log from 'why-is-node-running';
 import * as http from 'http';
 import * as express from 'express';
 import { PromiseIO } from "../src/PromiseIO/Server";
 import { PromiseIOClient } from "../src/PromiseIO/Client";
 import { assert, expect } from 'chai';
-import { USER_DEFINED_TIMEOUT } from "../src/Strings";
+import { CLASSNAME_ATTRIBUTE, USER_DEFINED_TIMEOUT } from "../src/Strings";
 var should = require('chai').should();
 var chai = require("chai");
 var chaiAsPromised = require("chai-as-promised");
- 
+
 chai.use(chaiAsPromised);
 const noop = (...args) => { }
 
     })
 
 
-    it('should have rpc echo', async() => {
+    it('should have rpc echo', async () => {
         const x = await client['test'].echo("x")
         expect(x).to.be.equal('x')
     })
 
-    it('should add up to 6', async() => {
+    it('should add up to 6', async () => {
         const sum = await client['test'].add(1, 2, 3)
         expect(sum).to.be.equal(6)
     })
     let run = 0
     const expected = [yesCandy, noCandy, noCandy, noCandy]
 
-    it('Unhook+unsubscribe should stop callbacks', async() => {
+    it('Unhook+unsubscribe should stop callbacks', async () => {
         await client['test'].subscribe(function myCallback(c) {
             if (run == 1)
                 (myCallback as any).destroy()
 type SesameTestIfc = {
     test: {
         checkCandy: () => Promise<string>
-        subscribe: (callback: Callback<string>) => Promise<topicDTO>
+        subscribe: (callback: Callback<[string]>) => Promise<topicDTO>
         manyParams: <A = string, B = number, C = boolean, D = Object>(a: A, b: B, c: C, d: D) => Promise<[A, B, C, D]>
     }
 }
     })
 
     it('callback should work with sesame', (done) => {
-        client.test.subscribe(function(c){
+        client.test.subscribe(function (c) {
             if (c === candy) {
                 done()
             }
                 a: 'a',
                 b: 'b'
             })
-            .then(r => {
-                if (r != null)
-                    done(new Error("UNEXPECTED RESULT " + r))
-            })
-            .catch((e) => {
-                if (e.message === errtxt)
-                    done()
-                else
-                    done(e)
-            })
-            .finally(() => {
-                cli.close()
-                sock.close()
-                server.close()
-            })
+                .then(r => {
+                    if (r != null)
+                        done(new Error("UNEXPECTED RESULT " + r))
+                })
+                .catch((e) => {
+                    if (e.message === errtxt)
+                        done()
+                    else
+                        done(e)
+                })
+                .finally(() => {
+                    cli.close()
+                    sock.close()
+                    server.close()
+                })
         })
     })
 
 describe("class (de-)serialization", () => {
 
     @Serializable()
-    class SubClass{
+    class SubClass {
         fString = "F"
     }
 
     @Serializable()
-    class TestClass{
+    class TestClass {
         aString = "A"
         aNumber = 46
         aObject = {
         }
         aClassObject = new SubClass()
 
-        public returnOK(){
+        public returnOK() {
             return "OK"
         }
     }
 
-    let myServer: RPCServer;
-    let mySocket: RPCSocket;
-
-    before(function(done){
-        myServer = new RPCServer([{
-            name: "Test",
-            RPCs: [
-                function returnClass(){
-                    return new TestClass()
-                }
-            ]
-        }])
-        myServer.listen(8084)
-
-        mySocket = new RPCSocket(8084, 'localhost')
-        mySocket.connect().then(() => done())
-    })
-
-    after(function(done){
-        mySocket.close()
-        myServer.close()
-        done()
-    })
-
-
-    it("receives class in call response", async () => {
-        const obj: TestClass = await mySocket['Test'].returnClass()
-
+    const verifyObject = (obj: any) => {
         expect(obj).to.be.an.instanceOf(TestClass)
         expect(obj.aString).to.be.a('string')
         expect(obj.aNumber).to.be.a('number')
         expect(obj.aObject.y).to.be.undefined
         expect(obj.aObject.sub).to.be.an.instanceOf(SubClass)
         expect(obj.aClassObject).to.be.an.instanceOf(SubClass)
-
+        expect(obj).to.not.have.key(CLASSNAME_ATTRIBUTE)
+        expect(obj.aObject.sub).to.not.have.key(CLASSNAME_ATTRIBUTE)
+        expect(obj.aClassObject).to.not.have.key(CLASSNAME_ATTRIBUTE)
         expect(obj.returnOK()).to.be.equal('OK')
-    })
+    }
 
-    it("receives class in hook response", async () => {
-        const obj: TestClass = await mySocket['Test'].returnClass()
+    describe("Responses", () => {
+        type TestIfc = {
+            Test: {
+                returnClass: () => Promise<TestClass>
+                classCallback: (callback: Callback<[TestClass]>) => Promise<TestClass>
+            }
+        }
 
-        expect(obj).to.be.an.instanceOf(TestClass)
-        expect(obj.aString).to.be.a('string')
-        expect(obj.aNumber).to.be.a('number')
-        expect(obj.aObject).to.be.a('object')
-        expect(obj.aObject.x).to.be.a('string')
-        expect(obj.aObject.y).to.be.undefined
-        expect(obj.aObject.sub).to.be.an.instanceOf(SubClass)
-        expect(obj.aClassObject).to.be.an.instanceOf(SubClass)
+        let myServer: RPCServer<TestIfc>;
+        let mySocket: ConnectedSocket<TestIfc>;
+
+        before(function (done) {
+            myServer = new RPCServer<TestIfc>([{
+                name: "Test",
+                RPCs: [
+                    async function returnClass() {
+                        return new TestClass()
+                    }, {
+                        name: "classCallback",
+                        hook: async function (callback) {
+                            setTimeout(_ => callback(new TestClass()), 250)
+                            return new TestClass()
+                        }
+                    }
+                ]
+            }])
+            myServer.listen(8084)
 
-        expect(obj.returnOK()).to.be.equal('OK')
+            new RPCSocket<TestIfc>(8084, 'localhost').connect().then(connsock => {
+                mySocket = connsock
+                done()
+            })
+        })
+
+        after(function (done) {
+            mySocket.close()
+            myServer.close()
+            done()
+        })
+
+
+        it("receives class object in call response", async () => {
+            const obj: TestClass = await mySocket['Test'].returnClass()
+            verifyObject(obj)
+        })
+
+        it("receives class object in hook response", async function () {
+            const obj: TestClass = await mySocket.Test.classCallback(noop)
+            verifyObject(obj)
+        })
+
+        it("receives class object in callback", function (done) {
+            mySocket.Test.classCallback(function (cbValue) {
+                verifyObject(cbValue)
+                done()
+            }).then(verifyObject)
+        })
+    })
+    describe("Parameters", () => {
+        it("Class object in call", function(done){
+            const server = new RPCServer([
+                {
+                    name: "Test",
+                    RPCs: [
+                        function callWithClass(testObj: TestClass){
+                            verifyObject(testObj)
+                            done()
+                        }
+                    ]
+                }
+            ]).listen(8086)
+
+            new RPCSocket(8086, 'localhost').connect().then(sock => {
+                sock['Test'].callWithClass(new TestClass()).then(_ => {
+                    sock.close()
+                    server.close()
+                })
+            })
+        })
     })
 })