Fixed bad fift asm compilation, added SourceResolver callback

Author: krigga

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ton-community/func-js",
-    "version": "0.1.5",
+    "version": "0.2.0",
     "description": "The TON FunC smart-contract compiler",
     "main": "dist/index.js",
     "author": "TonTech",

src/index.ts

@@ -6,6 +6,19 @@ const {FuncFiftLibWasm} = require('./wasmlib/funcfiftlib.wasm.js')
 // Prepare binary
 const WasmBinary = base64Decode(FuncFiftLibWasm)
 
+export type SourcesMap = { [filename: string]: string }
+
+export type SourceResolver = (path: string) => string;
+
+export const mapSourceResolver = (map: SourcesMap): SourceResolver => {
+    return (path: string) => {
+        if (path in map) {
+            return map[path];
+        }
+        throw new Error('Cannot find source file ' + path);
+    };
+};
+
 /*
  * CompilerConfig example:
  * {
@@ -26,11 +39,9 @@ const WasmBinary = base64Decode(FuncFiftLibWasm)
  * }
  *
  */
-export type SourcesMap = { [filename: string]: string }
-
 export type CompilerConfig = {
     entryPoints: string[],
-    sources: SourcesMap,
+    sources: SourcesMap | SourceResolver,
     optLevel?: number
 };
 
@@ -54,46 +65,85 @@ export type CompilerVersion = {
     funcFiftLibCommitDate: string
 }
 
+const copyToCString = (mod: any, str: string) => {
+    const len = mod.lengthBytesUTF8(str) + 1;
+    const ptr = mod._malloc(len);
+    mod.stringToUTF8(str, ptr, len);
+    return ptr;
+}
+
+const copyToCStringPtr = (mod: any, str: string, ptr: any) => {
+    const allocated = copyToCString(mod, str);
+    mod.setValue(ptr, allocated, '*');
+    return allocated;
+};
+
+const copyFromCString = (mod: any, ptr: any) => {
+    return mod.UTF8ToString(ptr);
+};
+
 export async function compilerVersion(): Promise<CompilerVersion> {
-    let mod = await CompilerModule({ wasmBinary: WasmBinary });
+    const mod = await CompilerModule({ wasmBinary: WasmBinary });
 
-    let versionJsonPointer = mod._version();
-    let versionJson = mod.UTF8ToString(versionJsonPointer);
+    const versionJsonPointer = mod._version();
+    const versionJson = copyFromCString(mod, versionJsonPointer);
     mod._free(versionJsonPointer);
 
     return JSON.parse(versionJson);
 }
 
 export async function compileFunc(compileConfig: CompilerConfig): Promise<CompileResult> {
-
-    let entryWithNoSource = compileConfig.entryPoints.find(filename => typeof compileConfig.sources[filename] !== 'string')
+    const resolver = typeof compileConfig.sources === 'function' ? compileConfig.sources : mapSourceResolver(compileConfig.sources);
+
+    const entryWithNoSource = compileConfig.entryPoints.find(filename => {
+        try {
+            resolver(filename);
+            return false;
+        } catch (e) {
+            return true;
+        }
+    });
     if (entryWithNoSource) {
         throw new Error(`The entry point ${entryWithNoSource} has not provided in sources.`)
     }
 
-    let mod = await CompilerModule({ wasmBinary: WasmBinary });
-
-    // Write sources to virtual FS
-    for (let fileName in compileConfig.sources) {
-        let source = compileConfig.sources[fileName];
-        mod.FS.writeFile(fileName, source);
-    }
-
-    let configStr = JSON.stringify({
+    const mod = await CompilerModule({ wasmBinary: WasmBinary });
+
+    const allocatedPointers = [];
+
+    const callbackPtr = mod.addFunction((_kind: any, _data: any, contents: any, error: any) => {
+        const kind: string = copyFromCString(mod, _kind);
+        const data: string = copyFromCString(mod, _data);
+        if (kind === 'realpath') {
+            allocatedPointers.push(copyToCStringPtr(mod, data, contents));
+        } else if (kind === 'source') {
+            try {
+                const source = resolver(data);
+                allocatedPointers.push(copyToCStringPtr(mod, source, contents));
+            } catch (err) {
+                const e = err as any;
+                allocatedPointers.push(copyToCStringPtr(mod, 'message' in e ? e.message : e.toString(), error));
+            }
+        } else {
+            allocatedPointers.push(copyToCStringPtr(mod, 'Unknown callback kind ' + kind, error));
+        }
+    }, 'viiii');
+
+    const configStr = JSON.stringify({
         sources: compileConfig.entryPoints,
         optLevel: compileConfig.optLevel || 2
     });
 
-    let configStrPointer = mod._malloc(configStr.length + 1);
-    mod.stringToUTF8(configStr, configStrPointer, configStr.length + 1);
+    const configStrPointer = copyToCString(mod, configStr);
+    allocatedPointers.push(configStrPointer);
 
-    let resultPointer = mod._func_compile(configStrPointer);
-    let retJson = mod.UTF8ToString(resultPointer);
+    const resultPointer = mod._func_compile(configStrPointer, callbackPtr);
+    allocatedPointers.push(resultPointer);
+    const retJson = copyFromCString(mod, resultPointer);
 
     // Cleanup
-    mod._free(resultPointer);
-    mod._free(configStrPointer);
-    mod = null
+    allocatedPointers.forEach(ptr => mod._free(ptr));
+    mod.removeFunction(callbackPtr);
 
     return JSON.parse(retJson);
 }

src/wasmlib/funcfiftlib.js

@@ -1,15 +1,15 @@
-import {compileFunc, compilerVersion, SuccessResult, ErrorResult} from '../src/index';
+import {compileFunc, compilerVersion, SuccessResult, ErrorResult, mapSourceResolver} from '../src/index';
 import fs from 'fs';
 import {Cell} from 'ton';
 
 describe('ton-compiler', () => {
     const walletCodeCellHash = Buffer.from("hA3nAz+xEJePYGrDyjJ+BXBcxSp9Y2xaAFLRgGntfDs=", 'base64');
 
     const compilerVersionExpected = {
-        funcVersion: "0.2.0",
-        funcFiftLibCommitHash: "a18a5ed15c8c5a149d48a7d8b0523f13b76f5123",
-        funcFiftLibCommitDate: "2022-09-21 14:11:40 +0700"
-    }
+        funcVersion: "0.3.0",
+        funcFiftLibCommitHash: "3dd87ae7a703d2771c4e299a4490eb66787eb270",
+        funcFiftLibCommitDate: "2022-11-15 17:17:07 +0300"
+    };
 
     it('should return compiler version', async () => {
         let version = await compilerVersion();
@@ -26,13 +26,28 @@ describe('ton-compiler', () => {
             }
         });
 
+        expect(result.status).toEqual('ok');
+        result = result as SuccessResult;
+
+        let codeCell = Cell.fromBoc(Buffer.from(result.codeBoc, "base64"))[0];
+        expect(codeCell.hash().equals(walletCodeCellHash)).toBe(true);
+    });
 
+    it('should compile using map source resolver', async () => {
+        let result = await compileFunc({
+            optLevel: 2,
+            entryPoints: ["stdlib.fc", "wallet-code.fc"],
+            sources: mapSourceResolver({
+                "stdlib.fc": fs.readFileSync('./test/contracts/stdlib.fc', { encoding: 'utf-8' }),
+                "wallet-code.fc":  fs.readFileSync('./test/contracts/wallet-code.fc', { encoding: 'utf-8' })
+            })
+        });
 
         expect(result.status).toEqual('ok');
         result = result as SuccessResult;
 
         let codeCell = Cell.fromBoc(Buffer.from(result.codeBoc, "base64"))[0];
-        expect(codeCell.hash().equals(walletCodeCellHash)).toBe(true)
+        expect(codeCell.hash().equals(walletCodeCellHash)).toBe(true);
     });
 
     it('should handle includes', async () => {
@@ -50,15 +65,14 @@ describe('ton-compiler', () => {
         result = result as SuccessResult;
 
         let codeCell = Cell.fromBoc(Buffer.from(result.codeBoc, "base64"))[0];
-        expect(codeCell.hash().equals(walletCodeCellHash)).toBe(true)
+        expect(codeCell.hash().equals(walletCodeCellHash)).toBe(true);
     });
 
     it('should fail if entry point source is not provided', async () => {
         expect(compileFunc({
             optLevel: 2,
             entryPoints: ["main.fc"],
-            sources: {
-            }
+            sources: {}
         })).rejects.toThrowError('The entry point main.fc has not provided in sources.');
     });
 
@@ -67,7 +81,7 @@ describe('ton-compiler', () => {
             #pragma version ^${compilerVersionExpected.funcVersion};
             
             () main() { return(); }
-        `
+        `;
         let result = await compileFunc({
             optLevel: 1,
             entryPoints: ["main.fc"],
@@ -82,7 +96,7 @@ describe('ton-compiler', () => {
             #pragma version <${compilerVersionExpected.funcVersion};
             
             () main() { return(); }
-        `
+        `;
         result = await compileFunc({
             optLevel: 1,
             entryPoints: ["main.fc"],
@@ -91,8 +105,22 @@ describe('ton-compiler', () => {
             }
         });
 
-        expect(result.status).toEqual('error')
+        expect(result.status).toEqual('error');
+        result = result as ErrorResult;
+        expect(result.message.indexOf(`FunC version ${compilerVersionExpected.funcVersion} does not satisfy condition <${compilerVersionExpected.funcVersion}`) >= 0).toBeTruthy();
+    });
+
+    it('should fail if a non-existing source is included', async () => {
+        let result = await compileFunc({
+            optLevel: 2,
+            entryPoints: ["main.fc"],
+            sources: {
+                "main.fc": '#include "non-existing.fc";'
+            }
+        });
+
+        expect(result.status).toEqual('error');
         result = result as ErrorResult;
-        expect(result.message.indexOf(`FunC version ${compilerVersionExpected.funcVersion} does not satisfy condition <0.2.0`) != undefined);
-    })
+        expect(result.message.indexOf('Cannot find source file non-existing.fc') >= 0).toBeTruthy();
+    });
 });

src/wasmlib/funcfiftlib.wasm

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "ESNext",
+    "target": "ES2019",
     "outDir": "dist",
     "module": "commonjs",
     "declaration": true,

src/wasmlib/funcfiftlib.wasm.js

@@ -1,5 +1,5 @@
 {
-    "funcVersion": "0.2.0",
-    "funcFiftLibCommitHash": "4dc54cefc49250fd39dcbe6d764b4493870354dc",
-    "funcFiftLibCommitDate": "2022-09-15 00:53:02 +0700"
+    "funcVersion": "0.3.0",
+    "funcFiftLibCommitHash": "3dd87ae7a703d2771c4e299a4490eb66787eb270",
+    "funcFiftLibCommitDate": "2022-11-15 17:17:07 +0300"
 }