@alephium/web3 0.10.1 → 0.10.3

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

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

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

@@ -151,7 +151,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 2.1.1
+ * @version 2.1.2
  * @baseUrl ../
  */
 class Api extends HttpClient {

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

@@ -51,12 +51,13 @@ type CodeInfo = {
 };
 declare class ProjectArtifact {
     static readonly artifactFileName = ".project.json";
+    fullNodeVersion: string;
     compilerOptionsUsed: node.CompilerOptions;
     infos: Map<string, CodeInfo>;
     static checkCompilerOptionsParameter(compilerOptions: node.CompilerOptions): void;
-    constructor(compilerOptionsUsed: node.CompilerOptions, infos: Map<string, CodeInfo>);
+    constructor(fullNodeVersion: string, compilerOptionsUsed: node.CompilerOptions, infos: Map<string, CodeInfo>);
     saveToFile(rootPath: string): Promise<void>;
-    needToReCompile(compilerOptions: node.CompilerOptions, sourceInfos: SourceInfo[]): boolean;
+    needToReCompile(compilerOptions: node.CompilerOptions, sourceInfos: SourceInfo[], fullNodeVersion: string): boolean;
     static from(rootPath: string): Promise<ProjectArtifact | undefined>;
 }
 export declare class Project {
@@ -73,7 +74,7 @@ export declare class Project {
     static readonly interfaceMatcher: TypedMatcher<SourceKind.Interface>;
     static readonly scriptMatcher: TypedMatcher<SourceKind.Script>;
     static readonly matchers: TypedMatcher<SourceKind>[];
-    static buildProjectArtifact(sourceInfos: SourceInfo[], contracts: Map<string, Compiled<Contract>>, scripts: Map<string, Compiled<Script>>, compilerOptions: node.CompilerOptions): ProjectArtifact;
+    static buildProjectArtifact(fullNodeVersion: string, sourceInfos: SourceInfo[], contracts: Map<string, Compiled<Contract>>, scripts: Map<string, Compiled<Script>>, compilerOptions: node.CompilerOptions): ProjectArtifact;
     private constructor();
     static checkCompilerWarnings(warnings: string[], errorOnWarnings: boolean): void;
     static contract(name: string): Contract;
@@ -88,7 +89,7 @@ export declare class Project {
     private static loadSourceFiles;
     static readonly DEFAULT_CONTRACTS_DIR = "contracts";
     static readonly DEFAULT_ARTIFACTS_DIR = "artifacts";
-    static build(compilerOptionsPartial?: Partial<CompilerOptions>, projectRootDir?: string, contractsRootDir?: string, artifactsRootDir?: string): Promise<void>;
+    static build(compilerOptionsPartial?: Partial<CompilerOptions>, projectRootDir?: string, contractsRootDir?: string, artifactsRootDir?: string, defaultFullNodeVersion?: string | undefined): Promise<void>;
 }
 export declare abstract class Artifact {
     readonly version: string;

package/dist/src/contract/contract.js

@@ -130,22 +130,27 @@ class ProjectArtifact {
             throw Error(`There are unknown compiler options: ${compilerOptions}`);
         }
     }
-    constructor(compilerOptionsUsed, infos) {
+    constructor(fullNodeVersion, compilerOptionsUsed, infos) {
         ProjectArtifact.checkCompilerOptionsParameter(compilerOptionsUsed);
+        this.fullNodeVersion = fullNodeVersion;
         this.compilerOptionsUsed = compilerOptionsUsed;
         this.infos = infos;
     }
     async saveToFile(rootPath) {
         const filepath = path.join(rootPath, ProjectArtifact.artifactFileName);
         const artifact = {
+            fullNodeVersion: this.fullNodeVersion,
             compilerOptionsUsed: this.compilerOptionsUsed,
             infos: Object.fromEntries(new Map([...this.infos].sort()))
         };
         const content = JSON.stringify(artifact, null, 2);
         return fs_2.promises.writeFile(filepath, content);
     }
-    needToReCompile(compilerOptions, sourceInfos) {
+    needToReCompile(compilerOptions, sourceInfos, fullNodeVersion) {
         ProjectArtifact.checkCompilerOptionsParameter(compilerOptions);
+        if (this.fullNodeVersion !== fullNodeVersion) {
+            return true;
+        }
         const optionsMatched = Object.entries(compilerOptions).every(([key, inputOption]) => {
             const usedOption = this.compilerOptionsUsed[`${key}`];
             return usedOption === inputOption;
@@ -169,16 +174,23 @@ class ProjectArtifact {
         if (!fs_1.default.existsSync(filepath)) {
             return undefined;
         }
-        const content = await fs_2.promises.readFile(filepath);
-        const json = JSON.parse(content.toString());
-        const compilerOptionsUsed = json.compilerOptionsUsed;
-        const files = new Map(Object.entries(json.infos));
-        return new ProjectArtifact(compilerOptionsUsed, files);
+        try {
+            const content = await fs_2.promises.readFile(filepath);
+            const json = JSON.parse(content.toString());
+            const fullNodeVersion = json.fullNodeVersion;
+            const compilerOptionsUsed = json.compilerOptionsUsed;
+            const files = new Map(Object.entries(json.infos));
+            return new ProjectArtifact(fullNodeVersion, compilerOptionsUsed, files);
+        }
+        catch (error) {
+            console.log(`Failed to load project artifact, error: ${error}`);
+            return undefined;
+        }
     }
 }
 ProjectArtifact.artifactFileName = '.project.json';
 class Project {
-    static buildProjectArtifact(sourceInfos, contracts, scripts, compilerOptions) {
+    static buildProjectArtifact(fullNodeVersion, sourceInfos, contracts, scripts, compilerOptions) {
         const files = new Map();
         contracts.forEach((c) => {
             files.set(c.artifact.name, {
@@ -208,7 +220,7 @@ class Project {
                 warnings: []
             });
         });
-        return new ProjectArtifact(compilerOptions, files);
+        return new ProjectArtifact(fullNodeVersion, compilerOptions, files);
     }
     constructor(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, errorOnWarnings, projectArtifact) {
         this.contractsRootDir = contractsRootDir;
@@ -272,7 +284,7 @@ class Project {
         }
         return contract.artifact;
     }
-    static async compile(provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
+    static async compile(fullNodeVersion, provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
         const sourceStr = sourceInfos.map((f) => f.sourceCode).join('\n');
         const result = await provider.contracts.postContractsCompileProject({
             code: sourceStr,
@@ -290,7 +302,7 @@ class Project {
             const script = Script.fromCompileResult(scriptResult);
             scripts.set(script.name, new Compiled(sourceInfo, script, scriptResult.warnings));
         });
-        const projectArtifact = Project.buildProjectArtifact(sourceInfos, contracts, scripts, compilerOptions);
+        const projectArtifact = Project.buildProjectArtifact(fullNodeVersion, sourceInfos, contracts, scripts, compilerOptions);
         const project = new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, errorOnWarnings, projectArtifact);
         await project.saveArtifactsToFile(projectRootDir);
         return project;
@@ -319,7 +331,7 @@ class Project {
         }
         catch (error) {
             console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`);
-            return Project.compile(provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
+            return Project.compile(projectArtifact.fullNodeVersion, provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
         }
     }
     static getImportSourcePath(projectRootDir, importPath) {
@@ -404,14 +416,16 @@ class Project {
         }
         return sourceInfos.sort((a, b) => a.type - b.type);
     }
-    static async build(compilerOptionsPartial = {}, projectRootDir = '.', 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, defaultFullNodeVersion = undefined) {
         const provider = (0, global_1.getCurrentNodeProvider)();
+        const fullNodeVersion = defaultFullNodeVersion ?? (await provider.infos.getInfosNode()).buildInfo.releaseVersion;
         const sourceFiles = await Project.loadSourceFiles(projectRootDir, contractsRootDir);
         const { errorOnWarnings, ...nodeCompilerOptions } = { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial };
         const projectArtifact = await ProjectArtifact.from(projectRootDir);
-        if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {
+        if (projectArtifact === undefined ||
+            projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles, fullNodeVersion)) {
             console.log(`Compiling contracts in folder "${contractsRootDir}"`);
-            Project.currentProject = await Project.compile(provider, sourceFiles, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
+            Project.currentProject = await Project.compile(fullNodeVersion, provider, sourceFiles, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
         }
         else {
             console.log(`Contracts are compiled already. Loading them from folder "${artifactsRootDir}"`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "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": "2.1.1",
+    "alephium_version": "2.1.2",
     "explorer_backend_version": "1.13.4"
   },
   "type": "commonjs",

package/src/api/api-alephium.ts

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

package/src/contract/contract.ts

@@ -183,6 +183,7 @@ type CodeInfo = {
 class ProjectArtifact {
   static readonly artifactFileName = '.project.json'
 
+  fullNodeVersion: string
   compilerOptionsUsed: node.CompilerOptions
   infos: Map<string, CodeInfo>
 
@@ -197,8 +198,9 @@ class ProjectArtifact {
     }
   }
 
-  constructor(compilerOptionsUsed: node.CompilerOptions, infos: Map<string, CodeInfo>) {
+  constructor(fullNodeVersion: string, compilerOptionsUsed: node.CompilerOptions, infos: Map<string, CodeInfo>) {
     ProjectArtifact.checkCompilerOptionsParameter(compilerOptionsUsed)
+    this.fullNodeVersion = fullNodeVersion
     this.compilerOptionsUsed = compilerOptionsUsed
     this.infos = infos
   }
@@ -206,6 +208,7 @@ class ProjectArtifact {
   async saveToFile(rootPath: string): Promise<void> {
     const filepath = path.join(rootPath, ProjectArtifact.artifactFileName)
     const artifact = {
+      fullNodeVersion: this.fullNodeVersion,
       compilerOptionsUsed: this.compilerOptionsUsed,
       infos: Object.fromEntries(new Map([...this.infos].sort()))
     }
@@ -213,8 +216,11 @@ class ProjectArtifact {
     return fsPromises.writeFile(filepath, content)
   }
 
-  needToReCompile(compilerOptions: node.CompilerOptions, sourceInfos: SourceInfo[]): boolean {
+  needToReCompile(compilerOptions: node.CompilerOptions, sourceInfos: SourceInfo[], fullNodeVersion: string): boolean {
     ProjectArtifact.checkCompilerOptionsParameter(compilerOptions)
+    if (this.fullNodeVersion !== fullNodeVersion) {
+      return true
+    }
 
     const optionsMatched = Object.entries(compilerOptions).every(([key, inputOption]) => {
       const usedOption = this.compilerOptionsUsed[`${key}`]
@@ -242,11 +248,17 @@ class ProjectArtifact {
     if (!fs.existsSync(filepath)) {
       return undefined
     }
-    const content = await fsPromises.readFile(filepath)
-    const json = JSON.parse(content.toString())
-    const compilerOptionsUsed = json.compilerOptionsUsed as node.CompilerOptions
-    const files = new Map(Object.entries<CodeInfo>(json.infos))
-    return new ProjectArtifact(compilerOptionsUsed, files)
+    try {
+      const content = await fsPromises.readFile(filepath)
+      const json = JSON.parse(content.toString())
+      const fullNodeVersion = json.fullNodeVersion as string
+      const compilerOptionsUsed = json.compilerOptionsUsed as node.CompilerOptions
+      const files = new Map(Object.entries<CodeInfo>(json.infos))
+      return new ProjectArtifact(fullNodeVersion, compilerOptionsUsed, files)
+    } catch (error) {
+      console.log(`Failed to load project artifact, error: ${error}`)
+      return undefined
+    }
   }
 }
 
@@ -277,6 +289,7 @@ export class Project {
   ]
 
   static buildProjectArtifact(
+    fullNodeVersion: string,
     sourceInfos: SourceInfo[],
     contracts: Map<string, Compiled<Contract>>,
     scripts: Map<string, Compiled<Script>>,
@@ -311,7 +324,7 @@ export class Project {
         warnings: []
       })
     })
-    return new ProjectArtifact(compilerOptions, files)
+    return new ProjectArtifact(fullNodeVersion, compilerOptions, files)
   }
 
   private constructor(
@@ -396,6 +409,7 @@ export class Project {
   }
 
   private static async compile(
+    fullNodeVersion: string,
     provider: NodeProvider,
     sourceInfos: SourceInfo[],
     projectRootDir: string,
@@ -421,7 +435,13 @@ export class Project {
       const script = Script.fromCompileResult(scriptResult)
       scripts.set(script.name, new Compiled(sourceInfo, script, scriptResult.warnings))
     })
-    const projectArtifact = Project.buildProjectArtifact(sourceInfos, contracts, scripts, compilerOptions)
+    const projectArtifact = Project.buildProjectArtifact(
+      fullNodeVersion,
+      sourceInfos,
+      contracts,
+      scripts,
+      compilerOptions
+    )
     const project = new Project(
       contractsRootDir,
       artifactsRootDir,
@@ -476,6 +496,7 @@ export class Project {
     } catch (error) {
       console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`)
       return Project.compile(
+        projectArtifact.fullNodeVersion,
         provider,
         sourceInfos,
         projectRootDir,
@@ -604,15 +625,21 @@ export class Project {
     compilerOptionsPartial: Partial<CompilerOptions> = {},
     projectRootDir = '.',
     contractsRootDir = Project.DEFAULT_CONTRACTS_DIR,
-    artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR
+    artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR,
+    defaultFullNodeVersion: string | undefined = undefined
   ): Promise<void> {
     const provider = getCurrentNodeProvider()
+    const fullNodeVersion = defaultFullNodeVersion ?? (await provider.infos.getInfosNode()).buildInfo.releaseVersion
     const sourceFiles = await Project.loadSourceFiles(projectRootDir, contractsRootDir)
     const { errorOnWarnings, ...nodeCompilerOptions } = { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial }
     const projectArtifact = await ProjectArtifact.from(projectRootDir)
-    if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {
+    if (
+      projectArtifact === undefined ||
+      projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles, fullNodeVersion)
+    ) {
       console.log(`Compiling contracts in folder "${contractsRootDir}"`)
       Project.currentProject = await Project.compile(
+        fullNodeVersion,
         provider,
         sourceFiles,
         projectRootDir,

package/std/fungible_token_unimplemented.ral

@@ -0,0 +1,18 @@
+@std(enabled = false)
+Abstract Contract FungibleTokenUnimplemented() implements IFungibleToken {
+  pub fn getSymbol() -> ByteVec {
+    panic!()
+  }
+
+  pub fn getName() -> ByteVec {
+    panic!()
+  }
+
+  pub fn getDecimals() -> U256 {
+    panic!()
+  }
+
+  pub fn getTotalSupply() -> U256 {
+    panic!()
+  }
+}