dequanto 0.1.15 → 0.1.22

package/lib/cjs/gen/GeneratorFromAbi.js

@@ -21,6 +21,7 @@ class GeneratorFromAbi {
         return Gen;
     }
     async generate(abiJson, opts) {
+        let targetType = opts.target ?? 'ts';
         let methodsArr = (0, alot_1.default)(abiJson)
             .filter(x => x.type === 'function' || x.type === 'constructor')
             .groupBy(x => x.name)
@@ -36,18 +37,9 @@ class GeneratorFromAbi {
             return null;
         })
             .filter(Boolean)
+            .map(x => x[opts?.target ?? 'ts'])
             .map(Str_1.Str.formatMethod)
             .toArray();
-        // let methodInterfacesArr = alot(abiJson)
-        //     .filter(x => x.type === 'function')
-        //     .groupBy(x => x.name)
-        //     .map(group => {
-        //         let item = group.values[0];
-        //         return Gen.serializeMethodInterfacesTs(item.name, group.values);
-        //     })
-        //     .filter(Boolean)
-        //     .toArray();
-        //let methodInterfacesAll = Gen.serializeMethodInterfacesAllTs(methodInterfacesArr);
         let methodTypes = (0, alot_1.default)(abiJson)
             .filter(x => x.type === 'function')
             .groupBy(x => x.name)
@@ -61,6 +53,7 @@ class GeneratorFromAbi {
             .filter(x => x.type === 'event')
             .map(x => Gen.serializeEvent(x))
             .filter(Boolean)
+            .map(x => x[opts?.target ?? 'ts'])
             .map(Str_1.Str.formatMethod);
         let eventTypes = (0, alot_1.default)(abiJson)
             .filter(x => x.type === 'event')
@@ -76,11 +69,13 @@ class GeneratorFromAbi {
             .filter(x => x.type === 'event')
             .map(x => Gen.serializeEventExtractor(x))
             .filter(Boolean)
+            .map(x => x[opts?.target ?? 'ts'])
             .map(Str_1.Str.formatMethod);
         let eventsFetchersArr = abiJson
             .filter(x => x.type === 'event')
             .map(x => Gen.serializeEventFetcher(x))
             .filter(Boolean)
+            .map(x => x[opts?.target ?? 'ts'])
             .map(Str_1.Str.formatMethod);
         // let eventInterfaces = abiJson
         //     .filter(x => x.type === 'event')
@@ -92,7 +87,7 @@ class GeneratorFromAbi {
         let eventsExtractors = eventsExtractorsArr.join('\n\n');
         let eventsFetchers = eventsFetchersArr.join('\n\n');
         let name = opts.name;
-        let templatePath = _path_1.$path.resolve(`/src/gen/ContractTemplate.ts`);
+        let templatePath = _path_1.$path.resolve(`/src/gen/ContractTemplate.${targetType}`);
         let template = await atma_io_1.File.readAsync(templatePath, { skipHooks: true });
         let EtherscanStr;
         let EthWeb3ClientStr;
@@ -100,13 +95,14 @@ class GeneratorFromAbi {
         let sourceUri;
         let Web3ClientOptions = '';
         let EvmScanOptions = '';
+        let importPfx = targetType === 'js' ? 'dequanto' : '@dequanto';
         switch (opts.network) {
             case 'bsc':
                 EtherscanStr = 'Bscscan';
                 EthWeb3ClientStr = 'BscWeb3Client';
                 imports = [
-                    `import { Bscscan } from '@dequanto/explorer/Bscscan'`,
-                    `import { BscWeb3Client } from '@dequanto/clients/BscWeb3Client'`,
+                    `import { Bscscan } from '${importPfx}/explorer/Bscscan'`,
+                    `import { BscWeb3Client } from '${importPfx}/clients/BscWeb3Client'`,
                 ];
                 sourceUri = `https://bscscan.com/address/${opts.address}#code`;
                 break;
@@ -114,8 +110,8 @@ class GeneratorFromAbi {
                 EtherscanStr = 'Polyscan';
                 EthWeb3ClientStr = 'PolyWeb3Client';
                 imports = [
-                    `import { Polyscan } from '@dequanto/explorer/Polyscan'`,
-                    `import { PolyWeb3Client } from '@dequanto/clients/PolyWeb3Client'`,
+                    `import { Polyscan } from '${importPfx}/explorer/Polyscan'`,
+                    `import { PolyWeb3Client } from '${importPfx}/clients/PolyWeb3Client'`,
                 ];
                 sourceUri = `https://polygonscan.com/address/${opts.address}#code`;
                 break;
@@ -123,8 +119,8 @@ class GeneratorFromAbi {
                 EtherscanStr = 'XDaiscan';
                 EthWeb3ClientStr = 'XDaiWeb3Client';
                 imports = [
-                    `import { XDaiscan } from '@dequanto/chains/xdai/XDaiscan'`,
-                    `import { XDaiWeb3Client } from '@dequanto/chains/xdai/XDaiWeb3Client'`,
+                    `import { XDaiscan } from '${importPfx}/chains/xdai/XDaiscan'`,
+                    `import { XDaiWeb3Client } from '${importPfx}/chains/xdai/XDaiWeb3Client'`,
                 ];
                 sourceUri = `https://blockscout.com/xdai/mainnet/address/${opts.address}/contracts`;
                 break;
@@ -132,8 +128,8 @@ class GeneratorFromAbi {
                 EtherscanStr = 'Etherscan';
                 EthWeb3ClientStr = 'EthWeb3Client';
                 imports = [
-                    `import { Etherscan } from '@dequanto/explorer/Etherscan'`,
-                    `import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client'`,
+                    `import { Etherscan } from '${importPfx}/explorer/Etherscan'`,
+                    `import { EthWeb3Client } from '${importPfx}/clients/EthWeb3Client'`,
                 ];
                 sourceUri = `https://etherscan.io/address/${opts.address}#code`;
                 break;
@@ -141,8 +137,8 @@ class GeneratorFromAbi {
                 EtherscanStr = 'Etherscan';
                 EthWeb3ClientStr = 'HardhatWeb3Client';
                 imports = [
-                    `import { Etherscan } from '@dequanto/explorer/Etherscan'`,
-                    `import { HardhatWeb3Client } from '@dequanto/hardhat/HardhatWeb3Client'`,
+                    `import { Etherscan } from '${importPfx}/explorer/Etherscan'`,
+                    `import { HardhatWeb3Client } from '${importPfx}/hardhat/HardhatWeb3Client'`,
                 ];
                 sourceUri = ``;
                 break;
@@ -152,8 +148,8 @@ class GeneratorFromAbi {
                     EtherscanStr = 'Evmscan';
                     EthWeb3ClientStr = 'EvmWeb3Client';
                     imports = [
-                        `import { Evmscan } from '@dequanto/explorer/Evmscan'`,
-                        `import { EvmWeb3Client } from '@dequanto/clients/EvmWeb3Client'`,
+                        `import { Evmscan } from '${importPfx}/explorer/Evmscan'`,
+                        `import { EvmWeb3Client } from '${importPfx}/clients/EvmWeb3Client'`,
                     ];
                     Web3ClientOptions = `{ platform: '${opts.network}' }`;
                     EvmScanOptions = `{ platform: '${opts.network}' }`;
@@ -171,7 +167,7 @@ class GeneratorFromAbi {
         let outputFilename = /[^\\/]+$/.exec(name)[0];
         let outputPath = /\.(ts|js)$/.test(opts.output)
             ? opts.output
-            : atma_utils_1.class_Uri.combine(opts.output, outputDirectory, `${outputFilename}.ts`);
+            : atma_utils_1.class_Uri.combine(opts.output, outputDirectory, `${outputFilename}.${opts.outputFileExt ?? targetType}`);
         let meta = {
             artifact: opts.artifact
                 ? this.getRelativePath(opts.artifact)
@@ -187,13 +183,13 @@ class GeneratorFromAbi {
         let storageReaderClass = '';
         try {
             let storageReaderGenerator = new GeneratorStorageReader_1.GeneratorStorageReader();
-            let reader = await storageReaderGenerator.generate({ ...opts });
+            let reader = await storageReaderGenerator.generate({ ...opts, target: targetType });
             if (reader.sourcePath != null && opts.address == null) {
                 sourceUri = this.getRelativePath(reader.sourcePath);
             }
             if (reader.className) {
                 storageReaderClass = reader.code;
-                storageReaderProperty = `declare storage: ${reader.className}`;
+                storageReaderProperty = targetType === 'ts' ? `declare storage: ${reader.className}` : '';
                 storageReaderInitializer = `this.storage = new ${reader.className}(this.address, this.client, this.explorer);`;
                 _logger_1.$logger.log(`green<StorageReader> was generated`);
             }
@@ -226,13 +222,13 @@ class GeneratorFromAbi {
             .replace(`/* STORAGE_READER_INITIALIZER */`, storageReaderInitializer)
             .replace(`/* STORAGE_READER_PROPERTY */`, storageReaderProperty)
             .replace(`/* STORAGE_READER_CLASS */`, () => storageReaderClass)
-            .replace(`/* TX_CALLER_METHODS */`, () => Gen.serializeTxCallerMethods(className, abiJson))
-            .replace(`/* TX_DATA_METHODS */`, () => Gen.serializeTxDataMethods(className, abiJson))
+            .replace(`/* TX_CALLER_METHODS */`, () => Gen.serializeTxCallerMethods(className, abiJson)[targetType])
+            .replace(`/* TX_DATA_METHODS */`, () => Gen.serializeTxDataMethods(className, abiJson)[targetType])
             .replace(`/* $EVENT_TYPES$ */`, () => Str_1.Str.indent(eventTypes.map(x => x.code).join('\n'), '        '))
             .replace(`/* $METHOD_TYPES$ */`, () => Str_1.Str.indent(methodTypes.map(x => x.code).join('\n'), '        '));
         await atma_io_1.File.writeAsync(outputPath, code, { skipHooks: true });
         if (opts.saveAbi) {
-            let path = atma_utils_1.class_Uri.combine(opts.output, outputDirectory, `${outputFilename}.json`);
+            let path = atma_utils_1.class_Uri.combine(opts.output, outputDirectory, `${outputFilename}Abi.json`);
             await atma_io_1.File.writeAsync(path, abiJson);
         }
         _logger_1.$logger.log(`bold<green<${className}>> ABI wrapper class created: bold<${outputPath}>`);
@@ -302,8 +298,8 @@ var Gen;
     // abi.length > 1 if has method overloads
     function serializeMethodInterfacesTs(name, abis) {
         let args = abis.map(abi => {
-            let { fnInputArguments } = serializeArgumentsTs(abi);
-            return `[ ${fnInputArguments} ]`;
+            let { fnInputArgumentsTargets } = serializeArgumentsTs(abi);
+            return `[ ${fnInputArgumentsTargets.ts} ]`;
         }).join(' | ');
         let iface = `IMethod${name[0].toUpperCase()}${name.substring(1)}`;
         let code = [
@@ -321,8 +317,8 @@ var Gen;
     Gen.serializeMethodInterfacesTs = serializeMethodInterfacesTs;
     function serializeMethodTypeTs(name, abis) {
         let args = abis.map(abi => {
-            let { fnInputArguments } = serializeArgumentsTs(abi);
-            return `[ ${fnInputArguments} ]`;
+            let { fnInputArgumentsTargets } = serializeArgumentsTs(abi);
+            return `[ ${fnInputArgumentsTargets.ts} ]`;
         }).join(' | ');
         let iface = `IMethod${name[0].toUpperCase()}${name.substring(1)}`;
         let code = [
@@ -369,9 +365,9 @@ var Gen;
     }
     Gen.serializeEventsInterfacesAllTs = serializeEventsInterfacesAllTs;
     function serializeEventType(event) {
-        let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(event);
-        let outputParams = `{ ${fnInputArguments} }`;
-        let outputArgs = `[ ${fnInputArguments.replace('\n', '')} ]`;
+        let { fnInputArgumentsTargets, callInputArguments, fnResult } = serializeArgumentsTs(event);
+        let outputParams = `{ ${fnInputArgumentsTargets.ts} }`;
+        let outputArgs = `[ ${fnInputArgumentsTargets.ts.replace('\n', '')} ]`;
         let code = [
             `${event.name}: {`,
             `    outputParams: ${outputParams},`,
@@ -384,36 +380,67 @@ var Gen;
     }
     Gen.serializeEventType = serializeEventType;
     function serializeEvent(abi) {
-        let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
-        return `
-            on${abi.name} (fn?: (event: TClientEventsStreamData<TEventArguments<'${abi.name}'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'${abi.name}'>>> {
-                return this.$onLog('${abi.name}', fn);
-            }
-        `;
+        let { fnInputArgumentsTargets, callInputArguments, fnResult } = serializeArgumentsTs(abi);
+        return {
+            ts: `
+                on${abi.name} (fn?: (event: TClientEventsStreamData<TEventArguments<'${abi.name}'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'${abi.name}'>>> {
+                    return this.$onLog('${abi.name}', fn);
+                }
+            `,
+            js: `
+                on${abi.name} (fn) {
+                    return this.$onLog('${abi.name}', fn);
+                }
+            `
+        };
     }
     Gen.serializeEvent = serializeEvent;
     function serializeEventExtractor(abi) {
-        return `
-            extractLogs${abi.name} (tx: TEth.TxReceipt): ITxLogItem<TEventParams<'${abi.name}'>>[] {
-                let abi = this.$getAbiItem('event', '${abi.name}');
-                return this.$extractLogs(tx, abi) as any as ITxLogItem<TEventParams<'${abi.name}'>>[];
-            }
-        `;
+        return {
+            ts: `
+                extractLogs${abi.name} (tx: TEth.TxReceipt): ITxLogItem<TEventParams<'${abi.name}'>>[] {
+                    let abi = this.$getAbiItem('event', '${abi.name}');
+                    return this.$extractLogs(tx, abi) as any as ITxLogItem<TEventParams<'${abi.name}'>>[];
+                }
+            `,
+            js: `
+                extractLogs${abi.name} (tx) {
+                    let abi = this.$getAbiItem('event', '${abi.name}');
+                    return this.$extractLogs(tx, abi);
+                }
+            `
+        };
     }
     Gen.serializeEventExtractor = serializeEventExtractor;
     function serializeEventFetcher(abi) {
         let inputs = abi.inputs;
         let indexed = (0, alot_1.default)(inputs).takeWhile(x => x.indexed).toArray();
         let indexedParams = indexed.map(param => `${param.name}?: ${_abiType_1.$abiType.getTsType(param.type, param)}`);
-        return `
-            async getPastLogs${abi.name} (options?: {
-                fromBlock?: number | Date
-                toBlock?: number | Date
-                params?: { ${indexedParams} }
-            }): Promise<ITxLogItem<TEventParams<'${abi.name}'>>[]> {
-                return await this.$getPastLogsParsed('${abi.name}', options) as any;
-            }
-        `;
+        return {
+            ts: `
+                async getPastLogs${abi.name} (options?: {
+                    fromBlock?: number | Date
+                    toBlock?: number | Date
+                    params?: { ${indexedParams} }
+                }): Promise<ITxLogItem<TEventParams<'${abi.name}'>>[]> {
+                    return await this.$getPastLogsParsed('${abi.name}', options) as any;
+                }
+            `,
+            types: `
+                async getPastLogs${abi.name} (options?: {
+                    fromBlock?: number | Date
+                    toBlock?: number | Date
+                    params?: { ${indexedParams} }
+                }): Promise<ITxLogItem<TEventParams<'${abi.name}'>>[]> {
+                    return await this.$getPastLogsParsed('${abi.name}', options) as any;
+                }
+            `,
+            js: `
+                async getPastLogs${abi.name} (options) {
+                    return await this.$getPastLogsParsed('${abi.name}', options);
+                }
+            `
+        };
     }
     Gen.serializeEventFetcher = serializeEventFetcher;
     // export function serializeEventInterface (abi: TAbiItem) {
@@ -442,76 +469,134 @@ var Gen;
     }
     Gen.serializeMethodAbi = serializeMethodAbi;
     function serializeReadMethodTs(abi) {
-        let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
+        let { fnInputArgumentsTargets, callInputArguments, fnResult } = serializeArgumentsTs(abi);
         if (callInputArguments) {
             callInputArguments = `, ${callInputArguments}`;
         }
-        return `
-            // ${_abiUtils_1.$abiUtils.getMethodSignature(abi)}
-            async ${abi.name} (${fnInputArguments}): ${fnResult} {
-                return this.$read(this.$getAbiItem('function', '${abi.name}')${callInputArguments});
-            }
-        `;
+        return {
+            ts: `
+                // ${_abiUtils_1.$abiUtils.getMethodSignature(abi)}
+                async ${abi.name} (${fnInputArgumentsTargets.ts}): ${fnResult} {
+                    return this.$read(this.$getAbiItem('function', '${abi.name}')${callInputArguments});
+                }
+            `,
+            types: `
+                // ${_abiUtils_1.$abiUtils.getMethodSignature(abi)}
+                async ${abi.name} (${fnInputArgumentsTargets.ts}): ${fnResult}
+            `,
+            js: `
+                // ${_abiUtils_1.$abiUtils.getMethodSignature(abi)}
+                async ${abi.name} (${fnInputArgumentsTargets.js}) {
+                    return this.$read(this.$getAbiItem('function', '${abi.name}')${callInputArguments});
+                }
+            `
+        };
     }
     function serializeReadMethodTsOverloads(abis) {
         let overrides = abis.map(abi => {
-            let { fnInputArguments, fnResult } = serializeArgumentsTs(abi);
+            let { fnInputArgumentsTargets, fnResult } = serializeArgumentsTs(abi);
             return `
             // ${_abiUtils_1.$abiUtils.getMethodSignature(abi)}
-            async ${abi.name} (${fnInputArguments}): ${fnResult}
+            async ${abi.name} (${fnInputArgumentsTargets.ts}): ${fnResult}
             `;
         }).join('\n');
         let abi = abis[0];
         let { fnResult } = serializeArgumentsTs(abi);
         let sigs = abis.map(abi => serializeMethodAbi(abi)).map(x => `'${x}'`).join(', ');
-        return `
-            ${overrides}
-            async ${abi.name} (...args): ${fnResult} {
-                let abi = this.$getAbiItemOverload([ ${sigs} ], args);
-                return this.$read(abi, ...args);
-            }
-        `;
+        return {
+            ts: `
+                ${overrides}
+                async ${abi.name} (...args): ${fnResult} {
+                    let abi = this.$getAbiItemOverload([ ${sigs} ], args);
+                    return this.$read(abi, ...args);
+                }
+            `,
+            types: `
+                ${overrides}
+                async ${abi.name} (...args): ${fnResult}
+            `,
+            js: `
+                async ${abi.name} (...args) {
+                    let abi = this.$getAbiItemOverload([ ${sigs} ], args);
+                    return this.$read(abi, ...args);
+                }
+            `
+        };
     }
     function serializeWriteMethodTs(abi) {
-        let { fnInputArguments, callInputArguments } = serializeArgumentsTs(abi);
+        let { fnInputArgumentsTargets, callInputArguments } = serializeArgumentsTs(abi);
         if (callInputArguments) {
             callInputArguments = `, ${callInputArguments}`;
         }
-        return `
-            // ${_abiUtils_1.$abiUtils.getMethodSignature(abi)}
-            async ${abi.name} (sender: TSender, ${fnInputArguments}): Promise<TxWriter> {
-                return this.$write(this.$getAbiItem('function', '${abi.name}'), sender${callInputArguments});
-            }
-        `;
+        return {
+            ts: `
+                // ${_abiUtils_1.$abiUtils.getMethodSignature(abi)}
+                async ${abi.name} (sender: TSender, ${fnInputArgumentsTargets.ts}): Promise<TxWriter> {
+                    return this.$write(this.$getAbiItem('function', '${abi.name}'), sender${callInputArguments});
+                }
+            `,
+            types: `
+                // ${_abiUtils_1.$abiUtils.getMethodSignature(abi)}
+                async ${abi.name} (sender: TSender, ${fnInputArgumentsTargets.ts}): Promise<TxWriter>
+            `,
+            js: `
+                // ${_abiUtils_1.$abiUtils.getMethodSignature(abi)}
+                async ${abi.name} (sender, ${fnInputArgumentsTargets.js}) {
+                    return this.$write(this.$getAbiItem('function', '${abi.name}'), sender${callInputArguments});
+                }
+            `
+        };
     }
     function serializeConstructorMethodTs(abi) {
-        let { fnInputArguments, callInputArguments } = serializeArgumentsTs(abi);
+        let { fnInputArgumentsTargets, callInputArguments } = serializeArgumentsTs(abi);
         if (callInputArguments) {
             callInputArguments = `, ${callInputArguments}`;
         }
-        return `
-            async $constructor (deployer: TSender, ${fnInputArguments}): Promise<TxWriter> {
-                throw new Error('Not implemented. Typing purpose. Use the ContractDeployer class to deploy the contract');
-            }
-        `;
+        return {
+            ts: `
+                async $constructor (deployer: TSender, ${fnInputArgumentsTargets.ts}): Promise<TxWriter> {
+                    throw new Error('Not implemented. Typing purpose. Use the ContractDeployer class to deploy the contract');
+                }
+            `,
+            types: `
+                async $constructor (deployer: TSender, ${fnInputArgumentsTargets.ts}): Promise<TxWriter>
+            `,
+            js: `
+                async $constructor (deployer, ${fnInputArgumentsTargets.js}) {
+                    throw new Error('Not implemented. Typing purpose. Use the ContractDeployer class to deploy the contract');
+                }
+            `
+        };
     }
     function serializeWriteMethodTsOverloads(abis) {
         let overrides = abis.map(abi => {
-            let { fnInputArguments, fnResult } = serializeArgumentsTs(abi);
+            let { fnInputArgumentsTargets, fnResult } = serializeArgumentsTs(abi);
             return `
             // ${_abiUtils_1.$abiUtils.getMethodSignature(abi)}
-            async ${abi.name} (sender: TSender, ${fnInputArguments}): Promise<TxWriter>
+            async ${abi.name} (sender: TSender, ${fnInputArgumentsTargets.ts}): Promise<TxWriter>
             `;
         }).join('\n');
         let abi = abis[0];
         let sigs = abis.map(abi => serializeMethodAbi(abi)).map(x => `'${x}'`).join(', ');
-        return `
-            ${overrides}
-            async ${abi.name} (sender: TSender, ...args): Promise<TxWriter> {
-                let abi = this.$getAbiItemOverload([ ${sigs} ], args);
-                return this.$write(abi, sender, ...args);
-            }
-        `;
+        return {
+            ts: `
+                ${overrides}
+                async ${abi.name} (sender: TSender, ...args): Promise<TxWriter> {
+                    let abi = this.$getAbiItemOverload([ ${sigs} ], args);
+                    return this.$write(abi, sender, ...args);
+                }
+            `,
+            types: `
+                ${overrides}
+                async ${abi.name} (sender: TSender, ...args): Promise<TxWriter>
+            `,
+            js: `
+                async ${abi.name} (sender, ...args) {
+                    let abi = this.$getAbiItemOverload([ ${sigs} ], args);
+                    return this.$write(abi, sender, ...args);
+                }
+            `
+        };
     }
     function serializeArgumentsTs(abi) {
         let inputs = abi.inputs.map((input, i) => {
@@ -524,22 +609,38 @@ var Gen;
             }
             return result;
         });
-        let fnInputArguments = inputs
+        let fnInputArgumentsArr = inputs
             ?.map((input) => {
             let tsType = _abiType_1.$abiType.getTsType(input.type, input);
             if (tsType == null) {
                 throw new Error(`Unknown abi type in arguments: ${input.type}`);
             }
-            return `${input.name}: ${tsType}`;
+            return { name: input.name, type: tsType };
+        }) ?? [];
+        let fnInputArgumentsTs = fnInputArgumentsArr
+            .map((input) => {
+            return `${input.name}: ${input.type}`;
         })
-            ?.join(', ') ?? '';
+            .join(', ');
+        let fnInputArgumentsJs = fnInputArgumentsArr
+            .map((input) => {
+            return `${input.name}`;
+        })
+            .join(', ');
         let callInputArguments = inputs
             ?.map(input => {
             return `${input.name}`;
         })
             ?.join(', ') ?? '';
         let fnResult = serializeMethodTsReturns(abi.outputs);
-        return { fnInputArguments, callInputArguments, fnResult };
+        return {
+            fnInputArgumentsTargets: {
+                ts: fnInputArgumentsTs,
+                js: fnInputArgumentsJs,
+            },
+            callInputArguments,
+            fnResult
+        };
     }
     function isObjectParams(params) {
         return params?.every(x => Boolean(x.name));
@@ -617,34 +718,44 @@ var Gen;
     function serializeTxCallerMethods(className, abiJson) {
         let methods = abiJson.filter(x => x.type === 'function');
         let writeMethods = methods.filter(abi => _abiUtils_1.$abiUtils.isReadMethod(abi) === false);
-        let lines = [];
-        writeMethods.forEach(method => {
-            lines.push(serializeMethodTs(method));
+        let lines = writeMethods.map(method => {
+            return serializeMethodTs(method);
         });
-        return lines.join('\n');
+        return {
+            ts: lines.map(x => x.ts).join('\n'),
+            js: lines.map(x => x.js).join('\n'),
+        };
         function serializeMethodTs(abi) {
-            let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
+            let { fnInputArgumentsTargets, callInputArguments, fnResult } = serializeArgumentsTs(abi);
             if (callInputArguments) {
                 callInputArguments = `, ${callInputArguments}`;
             }
-            return `    ${abi.name} (sender: TSender, ${fnInputArguments}): Promise<{ error?: Error & { data?: { type: string, params } }, result? }>`;
+            return {
+                ts: `    ${abi.name} (sender: TSender, ${fnInputArgumentsTargets.ts}): Promise<{ error?: Error & { data?: { type: string, params } }, result? }>`,
+                js: `    ${abi.name} (sender, ${fnInputArgumentsTargets.js})`,
+            };
         }
     }
     Gen.serializeTxCallerMethods = serializeTxCallerMethods;
     function serializeTxDataMethods(className, abiJson) {
         let methods = abiJson.filter(x => x.type === 'function');
         let writeMethods = methods.filter(abi => _abiUtils_1.$abiUtils.isReadMethod(abi) === false);
-        let lines = [];
-        writeMethods.forEach(method => {
-            lines.push(serializeInterfaceMethodTs(method));
+        let lines = writeMethods.map(method => {
+            return serializeInterfaceMethodTs(method);
         });
-        return lines.join('\n');
+        return {
+            ts: lines.map(x => x.ts).join('\n'),
+            js: lines.map(x => x.js).join('\n'),
+        };
         function serializeInterfaceMethodTs(abi) {
-            let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
+            let { fnInputArgumentsTargets, callInputArguments, fnResult } = serializeArgumentsTs(abi);
             if (callInputArguments) {
                 callInputArguments = `, ${callInputArguments}`;
             }
-            return `    ${abi.name} (sender: TSender, ${fnInputArguments}): Promise<TEth.TxLike>`;
+            return {
+                ts: `    ${abi.name} (sender: TSender, ${fnInputArgumentsTargets.ts}): Promise<TEth.TxLike>`,
+                js: `    ${abi.name} (sender, ${fnInputArgumentsTargets.js})`,
+            };
         }
     }
     Gen.serializeTxDataMethods = serializeTxDataMethods;