@alephium/web3 0.3.0-rc.7 → 0.3.0-rc.8

package/dist/src/api/api-alephium.d.ts

@@ -908,7 +908,7 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 1.6.2
+ * @version 1.6.4
  * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

package/dist/src/api/api-alephium.js

@@ -149,7 +149,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 1.6.2
+ * @version 1.6.4
  * @baseUrl ../
  */
 class Api extends HttpClient {

package/dist/src/contract/contract.d.ts

@@ -27,9 +27,10 @@ declare class SourceInfo {
     contractRelativePath: string;
     sourceCode: string;
     sourceCodeHash: string;
+    isExternal: boolean;
     getArtifactPath(artifactsRootDir: string): string;
-    constructor(type: SourceKind, name: string, sourceCode: string, sourceCodeHash: string, contractRelativePath: string);
-    static from(type: SourceKind, name: string, sourceCode: string, contractRelativePath: string): Promise<SourceInfo>;
+    constructor(type: SourceKind, name: string, sourceCode: string, sourceCodeHash: string, contractRelativePath: string, isExternal: boolean);
+    static from(type: SourceKind, name: string, sourceCode: string, contractRelativePath: string, isExternal: boolean): Promise<SourceInfo>;
 }
 declare class Compiled<T extends Artifact> {
     sourceInfo: SourceInfo;
@@ -62,6 +63,7 @@ export declare class Project {
     readonly contractsRootDir: string;
     readonly artifactsRootDir: string;
     static currentProject: Project;
+    static readonly importRegex: RegExp;
     static readonly abstractContractMatcher: TypedMatcher<SourceKind>;
     static readonly contractMatcher: TypedMatcher<SourceKind.Contract>;
     static readonly interfaceMatcher: TypedMatcher<SourceKind.Interface>;
@@ -76,11 +78,13 @@ export declare class Project {
     contractByCodeHash(codeHash: string): Contract;
     private static compile;
     private static loadArtifacts;
+    private static getImportSourcePath;
+    private static handleImports;
     private static loadSourceFile;
     private static loadSourceFiles;
     static readonly DEFAULT_CONTRACTS_DIR = "contracts";
     static readonly DEFAULT_ARTIFACTS_DIR = "artifacts";
-    static build(compilerOptionsPartial?: Partial<CompilerOptions>, contractsRootDir?: string, artifactsRootDir?: string): Promise<void>;
+    static build(compilerOptionsPartial?: Partial<CompilerOptions>, projectRootDir?: string, contractsRootDir?: string, artifactsRootDir?: string): Promise<void>;
 }
 export declare abstract class Artifact {
     readonly version: string;

package/dist/src/contract/contract.js

@@ -76,20 +76,39 @@ class TypedMatcher {
         this.type = type;
     }
 }
+function removeParentsPrefix(parts) {
+    let index = 0;
+    for (let i = 0; i < parts.length; i++) {
+        if (parts[`${i}`] === '..') {
+            index += 1;
+        }
+        else {
+            break;
+        }
+    }
+    return path.join(...parts.slice(index));
+}
 class SourceInfo {
-    constructor(type, name, sourceCode, sourceCodeHash, contractRelativePath) {
+    constructor(type, name, sourceCode, sourceCodeHash, contractRelativePath, isExternal) {
         this.type = type;
         this.name = name;
         this.sourceCode = sourceCode;
         this.sourceCodeHash = sourceCodeHash;
         this.contractRelativePath = contractRelativePath;
+        this.isExternal = isExternal;
     }
     getArtifactPath(artifactsRootDir) {
+        if (this.isExternal) {
+            const relativePath = removeParentsPrefix(this.contractRelativePath.split(path.sep));
+            const externalPath = path.join('.external', relativePath);
+            return path.join(artifactsRootDir, externalPath) + '.json';
+        }
         return path.join(artifactsRootDir, this.contractRelativePath) + '.json';
     }
-    static async from(type, name, sourceCode, contractRelativePath) {
+    static async from(type, name, sourceCode, contractRelativePath, isExternal) {
         const sourceCodeHash = await crypto_1.webcrypto.subtle.digest('SHA-256', buffer_1.Buffer.from(sourceCode));
-        return new SourceInfo(type, name, sourceCode, buffer_1.Buffer.from(sourceCodeHash).toString('hex'), contractRelativePath);
+        const sourceCodeHashHex = buffer_1.Buffer.from(sourceCodeHash).toString('hex');
+        return new SourceInfo(type, name, sourceCode, sourceCodeHashHex, contractRelativePath, isExternal);
     }
 }
 class Compiled {
@@ -301,49 +320,91 @@ class Project {
             return Project.compile(provider, sourceInfos, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
         }
     }
-    static async loadSourceFile(contractsRootDir, dirPath, filename) {
-        const contractPath = path.join(dirPath, filename);
-        const contractRelativePath = path.relative(contractsRootDir, contractPath);
-        if (!filename.endsWith('.ral')) {
-            throw new Error(`Invalid filename: ${contractPath}, smart contract file name should end with ".ral"`);
+    static getImportSourcePath(projectRootDir, importPath) {
+        const parts = importPath.split(path.sep);
+        if (parts.length > 1 && parts[0] === 'std') {
+            const currentDir = path.dirname(__filename);
+            return path.join(...[currentDir, '..', '..', '..', importPath]);
         }
-        const sourceBuffer = await fs_2.promises.readFile(contractPath);
-        const sourceStr = sourceBuffer.toString();
-        const sourceInfos = [];
+        let moduleDir = projectRootDir;
+        while (true) {
+            const expectedPath = path.join(...[moduleDir, 'node_modules', importPath]);
+            if (fs_1.default.existsSync(expectedPath)) {
+                return expectedPath;
+            }
+            const oldModuleDir = moduleDir;
+            moduleDir = path.join(moduleDir, '..');
+            if (oldModuleDir === moduleDir) {
+                throw new Error(`Specified import file does not exist: ${importPath}`);
+            }
+        }
+    }
+    static async handleImports(projectRootDir, contractRootDir, sourceStr, importsCache) {
+        const localImportsCache = [];
+        const result = sourceStr.replace(Project.importRegex, (match) => {
+            localImportsCache.push(match);
+            return '';
+        });
+        const externalSourceInfos = [];
+        for (const myImport of localImportsCache) {
+            const originImportPath = myImport.slice(8, -1);
+            const importPath = originImportPath.endsWith('.ral') ? originImportPath : originImportPath + '.ral';
+            if (!importsCache.includes(importPath)) {
+                importsCache.push(importPath);
+                const sourcePath = Project.getImportSourcePath(projectRootDir, importPath);
+                const sourceInfos = await Project.loadSourceFile(projectRootDir, contractRootDir, sourcePath, importsCache, true);
+                externalSourceInfos.push(...sourceInfos);
+            }
+        }
+        return [result, externalSourceInfos];
+    }
+    static async loadSourceFile(projectRootDir, contractsRootDir, sourcePath, importsCache, isExternal) {
+        const contractRelativePath = path.relative(contractsRootDir, sourcePath);
+        if (!sourcePath.endsWith('.ral')) {
+            throw new Error(`Invalid filename: ${sourcePath}, smart contract file name should end with ".ral"`);
+        }
+        const sourceBuffer = await fs_2.promises.readFile(sourcePath);
+        const [sourceStr, externalSourceInfos] = await Project.handleImports(projectRootDir, contractsRootDir, sourceBuffer.toString(), importsCache);
+        if (sourceStr.match(new RegExp('^import "', 'mg')) !== null) {
+            throw new Error(`Invalid import statements, source: ${sourcePath}`);
+        }
+        const sourceInfos = externalSourceInfos;
         for (const matcher of this.matchers) {
             const results = sourceStr.matchAll(matcher.matcher);
             for (const result of results) {
-                const sourceInfo = await SourceInfo.from(matcher.type, result[1], sourceStr, contractRelativePath);
+                const sourceInfo = await SourceInfo.from(matcher.type, result[1], sourceStr, contractRelativePath, isExternal);
                 sourceInfos.push(sourceInfo);
             }
         }
         return sourceInfos;
     }
-    static async loadSourceFiles(contractsRootDir) {
-        const loadDir = async function (dirPath, results) {
+    static async loadSourceFiles(projectRootDir, contractsRootDir) {
+        const importsCache = [];
+        const sourceInfos = [];
+        const loadDir = async function (dirPath) {
             const dirents = await fs_2.promises.readdir(dirPath, { withFileTypes: true });
             for (const dirent of dirents) {
                 if (dirent.isFile()) {
-                    const sourceInfos = await Project.loadSourceFile(contractsRootDir, dirPath, dirent.name);
-                    results.push(...sourceInfos);
+                    const sourcePath = path.join(dirPath, dirent.name);
+                    const infos = await Project.loadSourceFile(projectRootDir, contractsRootDir, sourcePath, importsCache, false);
+                    sourceInfos.push(...infos);
                 }
                 else {
                     const newPath = path.join(dirPath, dirent.name);
-                    await loadDir(newPath, results);
+                    await loadDir(newPath);
                 }
             }
         };
-        const sourceInfos = [];
-        await loadDir(contractsRootDir, sourceInfos);
+        await loadDir(contractsRootDir);
         const contractAndScriptSize = sourceInfos.filter((f) => f.type === SourceKind.Contract || f.type === SourceKind.Script).length;
         if (sourceInfos.length === 0 || contractAndScriptSize === 0) {
             throw new Error('Project have no source files');
         }
         return sourceInfos.sort((a, b) => a.type - b.type);
     }
-    static async build(compilerOptionsPartial = {}, contractsRootDir = Project.DEFAULT_CONTRACTS_DIR, artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR) {
+    static async build(compilerOptionsPartial = {}, projectRootDir = '.', contractsRootDir = Project.DEFAULT_CONTRACTS_DIR, artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR) {
         const provider = (0, global_1.getCurrentNodeProvider)();
-        const sourceFiles = await Project.loadSourceFiles(contractsRootDir);
+        const sourceFiles = await Project.loadSourceFiles(projectRootDir, contractsRootDir);
         const { errorOnWarnings, ...nodeCompilerOptions } = { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial };
         const projectArtifact = await ProjectArtifact.from(artifactsRootDir);
         if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {
@@ -357,9 +418,10 @@ class Project {
     }
 }
 exports.Project = Project;
+Project.importRegex = new RegExp('^import "[^"./]+/[^"]*[a-z][a-z_0-9]*(.ral)?"', 'mg');
 Project.abstractContractMatcher = new TypedMatcher('^Abstract Contract ([A-Z][a-zA-Z0-9]*)', SourceKind.AbstractContract);
 Project.contractMatcher = new TypedMatcher('^Contract ([A-Z][a-zA-Z0-9]*)', SourceKind.Contract);
-Project.interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*) \\{', SourceKind.Interface);
+Project.interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*)', SourceKind.Interface);
 Project.scriptMatcher = new TypedMatcher('^TxScript ([A-Z][a-zA-Z0-9]*)', SourceKind.Script);
 Project.matchers = [
     Project.abstractContractMatcher,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.3.0-rc.7",
+  "version": "0.3.0-rc.8",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -27,7 +27,7 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "1.6.2",
+    "alephium_version": "1.6.4",
     "explorer_backend_version": "1.12.0-rc2"
   },
   "scripts": {

package/src/api/api-alephium.ts

@@ -1332,7 +1332,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 1.6.2
+ * @version 1.6.4
  * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

package/src/contract/contract.ts

@@ -86,14 +86,32 @@ class TypedMatcher<T extends SourceKind> {
   }
 }
 
+function removeParentsPrefix(parts: string[]): string {
+  let index = 0
+  for (let i = 0; i < parts.length; i++) {
+    if (parts[`${i}`] === '..') {
+      index += 1
+    } else {
+      break
+    }
+  }
+  return path.join(...parts.slice(index))
+}
+
 class SourceInfo {
   type: SourceKind
   name: string
   contractRelativePath: string
   sourceCode: string
   sourceCodeHash: string
+  isExternal: boolean
 
   getArtifactPath(artifactsRootDir: string): string {
+    if (this.isExternal) {
+      const relativePath = removeParentsPrefix(this.contractRelativePath.split(path.sep))
+      const externalPath = path.join('.external', relativePath)
+      return path.join(artifactsRootDir, externalPath) + '.json'
+    }
     return path.join(artifactsRootDir, this.contractRelativePath) + '.json'
   }
 
@@ -102,23 +120,27 @@ class SourceInfo {
     name: string,
     sourceCode: string,
     sourceCodeHash: string,
-    contractRelativePath: string
+    contractRelativePath: string,
+    isExternal: boolean
   ) {
     this.type = type
     this.name = name
     this.sourceCode = sourceCode
     this.sourceCodeHash = sourceCodeHash
     this.contractRelativePath = contractRelativePath
+    this.isExternal = isExternal
   }
 
   static async from(
     type: SourceKind,
     name: string,
     sourceCode: string,
-    contractRelativePath: string
+    contractRelativePath: string,
+    isExternal: boolean
   ): Promise<SourceInfo> {
     const sourceCodeHash = await crypto.subtle.digest('SHA-256', Buffer.from(sourceCode))
-    return new SourceInfo(type, name, sourceCode, Buffer.from(sourceCodeHash).toString('hex'), contractRelativePath)
+    const sourceCodeHashHex = Buffer.from(sourceCodeHash).toString('hex')
+    return new SourceInfo(type, name, sourceCode, sourceCodeHashHex, contractRelativePath, isExternal)
   }
 }
 
@@ -223,12 +245,13 @@ export class Project {
 
   static currentProject: Project
 
+  static readonly importRegex = new RegExp('^import "[^"./]+/[^"]*[a-z][a-z_0-9]*(.ral)?"', 'mg')
   static readonly abstractContractMatcher = new TypedMatcher<SourceKind>(
     '^Abstract Contract ([A-Z][a-zA-Z0-9]*)',
     SourceKind.AbstractContract
   )
   static readonly contractMatcher = new TypedMatcher('^Contract ([A-Z][a-zA-Z0-9]*)', SourceKind.Contract)
-  static readonly interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*) \\{', SourceKind.Interface)
+  static readonly interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*)', SourceKind.Interface)
   static readonly scriptMatcher = new TypedMatcher('^TxScript ([A-Z][a-zA-Z0-9]*)', SourceKind.Script)
   static readonly matchers = [
     Project.abstractContractMatcher,
@@ -445,45 +468,107 @@ export class Project {
     }
   }
 
+  private static getImportSourcePath(projectRootDir: string, importPath: string): string {
+    const parts = importPath.split(path.sep)
+    if (parts.length > 1 && parts[0] === 'std') {
+      const currentDir = path.dirname(__filename)
+      return path.join(...[currentDir, '..', '..', '..', importPath])
+    }
+    let moduleDir = projectRootDir
+    while (true) {
+      const expectedPath = path.join(...[moduleDir, 'node_modules', importPath])
+      if (fs.existsSync(expectedPath)) {
+        return expectedPath
+      }
+      const oldModuleDir = moduleDir
+      moduleDir = path.join(moduleDir, '..')
+      if (oldModuleDir === moduleDir) {
+        throw new Error(`Specified import file does not exist: ${importPath}`)
+      }
+    }
+  }
+
+  private static async handleImports(
+    projectRootDir: string,
+    contractRootDir: string,
+    sourceStr: string,
+    importsCache: string[]
+  ): Promise<[string, SourceInfo[]]> {
+    const localImportsCache: string[] = []
+    const result = sourceStr.replace(Project.importRegex, (match) => {
+      localImportsCache.push(match)
+      return ''
+    })
+    const externalSourceInfos: SourceInfo[] = []
+    for (const myImport of localImportsCache) {
+      const originImportPath = myImport.slice(8, -1)
+      const importPath = originImportPath.endsWith('.ral') ? originImportPath : originImportPath + '.ral'
+      if (!importsCache.includes(importPath)) {
+        importsCache.push(importPath)
+        const sourcePath = Project.getImportSourcePath(projectRootDir, importPath)
+        const sourceInfos = await Project.loadSourceFile(
+          projectRootDir,
+          contractRootDir,
+          sourcePath,
+          importsCache,
+          true
+        )
+        externalSourceInfos.push(...sourceInfos)
+      }
+    }
+    return [result, externalSourceInfos]
+  }
+
   private static async loadSourceFile(
+    projectRootDir: string,
     contractsRootDir: string,
-    dirPath: string,
-    filename: string
+    sourcePath: string,
+    importsCache: string[],
+    isExternal: boolean
   ): Promise<SourceInfo[]> {
-    const contractPath = path.join(dirPath, filename)
-    const contractRelativePath = path.relative(contractsRootDir, contractPath)
-    if (!filename.endsWith('.ral')) {
-      throw new Error(`Invalid filename: ${contractPath}, smart contract file name should end with ".ral"`)
+    const contractRelativePath = path.relative(contractsRootDir, sourcePath)
+    if (!sourcePath.endsWith('.ral')) {
+      throw new Error(`Invalid filename: ${sourcePath}, smart contract file name should end with ".ral"`)
     }
 
-    const sourceBuffer = await fsPromises.readFile(contractPath)
-    const sourceStr = sourceBuffer.toString()
-    const sourceInfos: SourceInfo[] = []
+    const sourceBuffer = await fsPromises.readFile(sourcePath)
+    const [sourceStr, externalSourceInfos] = await Project.handleImports(
+      projectRootDir,
+      contractsRootDir,
+      sourceBuffer.toString(),
+      importsCache
+    )
+    if (sourceStr.match(new RegExp('^import "', 'mg')) !== null) {
+      throw new Error(`Invalid import statements, source: ${sourcePath}`)
+    }
+    const sourceInfos = externalSourceInfos
     for (const matcher of this.matchers) {
       const results = sourceStr.matchAll(matcher.matcher)
       for (const result of results) {
-        const sourceInfo = await SourceInfo.from(matcher.type, result[1], sourceStr, contractRelativePath)
+        const sourceInfo = await SourceInfo.from(matcher.type, result[1], sourceStr, contractRelativePath, isExternal)
         sourceInfos.push(sourceInfo)
       }
     }
     return sourceInfos
   }
 
-  private static async loadSourceFiles(contractsRootDir: string): Promise<SourceInfo[]> {
-    const loadDir = async function (dirPath: string, results: SourceInfo[]): Promise<void> {
+  private static async loadSourceFiles(projectRootDir: string, contractsRootDir: string): Promise<SourceInfo[]> {
+    const importsCache: string[] = []
+    const sourceInfos: SourceInfo[] = []
+    const loadDir = async function (dirPath: string): Promise<void> {
       const dirents = await fsPromises.readdir(dirPath, { withFileTypes: true })
       for (const dirent of dirents) {
         if (dirent.isFile()) {
-          const sourceInfos = await Project.loadSourceFile(contractsRootDir, dirPath, dirent.name)
-          results.push(...sourceInfos)
+          const sourcePath = path.join(dirPath, dirent.name)
+          const infos = await Project.loadSourceFile(projectRootDir, contractsRootDir, sourcePath, importsCache, false)
+          sourceInfos.push(...infos)
         } else {
           const newPath = path.join(dirPath, dirent.name)
-          await loadDir(newPath, results)
+          await loadDir(newPath)
         }
       }
     }
-    const sourceInfos: SourceInfo[] = []
-    await loadDir(contractsRootDir, sourceInfos)
+    await loadDir(contractsRootDir)
     const contractAndScriptSize = sourceInfos.filter(
       (f) => f.type === SourceKind.Contract || f.type === SourceKind.Script
     ).length
@@ -498,11 +583,12 @@ export class Project {
 
   static async build(
     compilerOptionsPartial: Partial<CompilerOptions> = {},
+    projectRootDir = '.',
     contractsRootDir = Project.DEFAULT_CONTRACTS_DIR,
     artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR
   ): Promise<void> {
     const provider = getCurrentNodeProvider()
-    const sourceFiles = await Project.loadSourceFiles(contractsRootDir)
+    const sourceFiles = await Project.loadSourceFiles(projectRootDir, contractsRootDir)
     const { errorOnWarnings, ...nodeCompilerOptions } = { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial }
     const projectArtifact = await ProjectArtifact.from(artifactsRootDir)
     if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {

package/std/token_interface.ral

@@ -0,0 +1,9 @@
+Interface IToken {
+  pub fn getSymbol() -> ByteVec
+
+  pub fn getName() -> ByteVec
+
+  pub fn getDecimals() -> U256
+
+  pub fn getTotalSupply() -> U256
+}