some cleanup

src/Frontend.ts

         const argParams = fnArgs.map(stripAfterEquals).join(",")
 
         if(!sesame){
-            const headerArgs = fnArgs.join(",")
-            const argParams = fnArgs.map(stripAfterEquals).join(",")
-
-            const f = eval( `( () => async (`+headerArgs+(headerArgs.length!==0?",":"")+` callback) => {
+            return eval( `( () => async (`+headerArgs+(headerArgs.length!==0?",":"")+` callback) => {
                 const r = await this.socket.call("`+fnName+`", `+argParams+`)
                 if(r && r.result === 'Success'){
                     this.socket.hook(r.uuid, callback)
                 }
                 return r
             } )()` )
-            return f
         }else{
-
             return eval( `( () => async (`+headerArgs+(headerArgs.length!==0?",":"")+` callback) => {
                 const r = await this.socket.call("`+fnName+`", "`+sesame+`", `+argParams+`)
                 if(r && r.result === 'Success'){

src/Utils.ts

                     argNames: extractArgs(rpc['call']),
                     type: "Call",
                     name: rpc.name,
-                    call: sesame?async (_sesame, ...args) => {if(sesame(_sesame)) return await rpc['call'].apply({}, args)}:rpc['call'], // check & remove sesame 
+                    call: sesame?async (_sesame, ...args) => {if(sesame(_sesame)) return await rpc['call'].apply({}, args); throw new Error('Bad sesame')}:rpc['call'], // check & remove sesame 
                 }
             }else{
                 const generator = hookGenerator(<T.HookRPC<any, any, any>>rpc, sesame)

test/Test.ts

 const add = (...args:number[]) => {return args.reduce((a,b)=>a+b, 0)}
 function makeServer(){
     let subcallback
-    return new RPCServer<{ topic: string }>(20000, [{
+    return new RPCServer<{ topic: string }>(21000, [{
         name: "test",
         exportRPCs: () => [
             {
         
         const echo = (x) => x
         
-        const server = new RPCServer(20003, [{
+        const server = new RPCServer(21003, [{
             name: 'HelloWorldRPCGroup',
             exportRPCs: ()  => [
                 echo, //named function variable
                 function echof(x){ return x }, //named function
                 {
                     name: 'echoExplicit', //describing object
-                    call: async (x) => x
+                    call: async (x,y,z) => [x,y,z]
                 }
             ]
         }])
 
-        const client = new RPCSocket(20003, 'localhost')
+        const client = new RPCSocket(21003, 'localhost')
 
         client.connect().then(async () => {
             const r0 = await client['HelloWorldRPCGroup'].echo('Hello')
             const r1 = await client['HelloWorldRPCGroup'].echof('World')
-            const r2 = await client['HelloWorldRPCGroup'].echoExplicit('RPC!')
+            const r2 = await client['HelloWorldRPCGroup'].echoExplicit('R','P','C!')
 
-            if(r0 === 'Hello' && r1 === 'World' && r2 ==='RPC!'){
+            if(r0 === 'Hello' && r1 === 'World' && r2.join('') ==='RPC!'){
                 client.destroy()
                 server.destroy()
                 done()
 
     before(async() => {
         server = makeServer()
-        client = new RPCSocket(20000, "localhost")
+        client = new RPCSocket(21000, "localhost")
         return await client.connect()
     })
 
     let server: RPCServer<{topic: string}> 
 
     before(async() => {
-        server = new RPCServer<{ topic: string }>(20000, [{
+        server = new RPCServer<{ topic: string }>(21000, [{
             name: "test",
             exportRPCs: () => [{
                 name: 'subscribe',
             closeHandler: (socket) => { console.log("closeHandler OK") },
             errorHandler: (socket, err) => { console.error("errorHandler OK SO YOU SHOULDN'T SEE THIS"); throw err }
         })
-        client = new RPCSocket(20000, "localhost")
+        client = new RPCSocket(21000, "localhost")
         return await client.connect()
     })
 
     let cb = (...args) => {}
 
     before(async() => {
-        server = new RPCServer(20004, [{
+        server = new RPCServer(21004, [{
             name: "test",
             exportRPCs: () => [
                 {
                     }
                 },
                 async function checkCandy():Promise<string> { cb(candy); cb=()=>{}; return candy },
+                async function manyParams(a,b,c,d) {return [a,b,c,d]}
             ]}
         ],{
             sesame: (_sesame) => _sesame === 'sesame!' 
         })
-        const sock = new RPCSocket(20004, "localhost")
+        const sock = new RPCSocket(21004, "localhost")
         client = await sock.connect<SesameTestIfc>('sesame!')
     })
 
         client.test.checkCandy().then(c => done())
     })
 
+    it('should work with multiple params', (done) => {
+        client.test['manyParams']('a','b','c','d').then(c => {
+            if(c[0] == 'a' && c[1] === 'b' && c[2] === 'c'  && c[3] === 'd')
+                done()
+        })
+    })
+
     it('should not work without sesame', (done) => {
-        const sock = new RPCSocket(20004, "localhost")
+        const sock = new RPCSocket(21004, "localhost")
         sock.connect<SesameTestIfc>( /* no sesame */).then(async (c) => {
             c.test.checkCandy().then(d => {
                 if(d === candy)
     })
 
     it('callback should not work without sesame', (done) => {
-        const sock = new RPCSocket(20004, "localhost")
+        const sock = new RPCSocket(21004, "localhost")
         sock.connect<SesameTestIfc>( /* no sesame */).then(async (c) => {
             c.test.subscribe((c) => {
                 console.log("CALLBACK TRIGGERED UNEXPECTED");
         })
     })
 })
+
+/*
+class myServer{
+    server = new RPCServer(21004, [ {
+        name: 'createUser' as 'createUser',
+        exportRPCs: () => [{
+            name: 'createUser' as 'createUser',
+            call: this.createUser
+        }]
+    }
+    ])
+
+    createUser = async( user: {a:any,b:any}) => {
+        console.log(user)
+        return user
+    }
+}
+
+describe('Should pass the createUser edge case', ()=>{
+    let server
+
+    before(()=>{
+        server = new myServer()
+    })
+
+    after(()=>{
+        server.server.destroy()
+    })
+
+    it("should work", async ()=>{
+        let sock = new RPCSocket(21004, 'localhost')
+        let client = await sock.connect()
+        client["createUser"]["createUser"]({
+            a:'a',
+            b:'b'
+        }).then(console.log)
+    })
+    
+})
+*/