@alephium/web3 0.2.0-rc.5 → 0.2.0-rc.8

package/dist/scripts/create-project.js

@@ -73,7 +73,7 @@ function prepareShared(packageRoot, projectRoot) {
     console.log(`  to ${projectRoot}`);
     console.log('...');
     fs_extra_1.default.copySync(path_1.default.join(packageRoot, 'templates/shared'), projectRoot);
-    copy('', ['.editorconfig', '.eslintignore', '.gitattributes', 'LICENSE']);
+    copy('', ['.editorconfig', '.eslintignore', '.gitattributes']);
     copy('dev', ['user.conf']);
     copy('scripts', ['start-devnet.js', 'stop-devnet.js']);
     if (fs_extra_1.default.existsSync(path_1.default.join(packageRoot, 'gitignore'))) {

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

@@ -305,6 +305,7 @@ export interface ChangeActiveAddress {
     address: string;
 }
 export interface CompileContractResult {
+    name: string;
     bytecode: string;
     /** @format 32-byte-hash */
     codeHash: string;
@@ -318,11 +319,20 @@ export interface CompileProjectResult {
     scripts: CompileScriptResult[];
 }
 export interface CompileScriptResult {
+    name: string;
     bytecodeTemplate: string;
     fields: FieldsSig;
     functions: FunctionSig[];
     warnings: string[];
 }
+export interface CompilerOptions {
+    ignoreUnusedConstantsWarnings?: boolean;
+    ignoreUnusedVariablesWarnings?: boolean;
+    ignoreUnusedFieldsWarnings?: boolean;
+    ignoreUnusedPrivateFunctionsWarnings?: boolean;
+    ignoreReadonlyCheckWarnings?: boolean;
+    ignoreExternalCallCheckWarnings?: boolean;
+}
 export interface Confirmed {
     /** @format block-hash */
     blockHash: string;
@@ -338,6 +348,7 @@ export interface Confirmed {
 }
 export interface Contract {
     code: string;
+    compilerOptions?: CompilerOptions;
 }
 export interface ContractEvent {
     /** @format block-hash */
@@ -532,6 +543,7 @@ export interface Penalty {
 }
 export interface Project {
     code: string;
+    compilerOptions?: CompilerOptions;
 }
 export interface Reachable {
     peers: string[];
@@ -553,6 +565,7 @@ export interface RevealMnemonicResult {
 }
 export interface Script {
     code: string;
+    compilerOptions?: CompilerOptions;
 }
 export interface SelfClique {
     /** @format clique-id */
@@ -1024,8 +1037,8 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request POST:/wallets/{wallet_name}/derive-next-address
          */
         postWalletsWalletNameDeriveNextAddress: (walletName: string, query?: {
-            group?: number | undefined;
-        } | undefined, params?: RequestParams) => Promise<AddressInfo>;
+            group?: number;
+        }, params?: RequestParams) => Promise<AddressInfo>;
         /**
          * @description Your wallet need to have been created with the miner flag set to true
          *
@@ -1157,8 +1170,8 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/infos/current-hashrate
          */
         getInfosCurrentHashrate: (query?: {
-            timespan?: number | undefined;
-        } | undefined, params?: RequestParams) => Promise<string>;
+            timespan?: number;
+        }, params?: RequestParams) => Promise<string>;
     };
     blockflow: {
         /**
@@ -1505,8 +1518,8 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/events/tx-id/{txId}
          */
         getEventsTxIdTxid: (txId: string, query?: {
-            group?: number | undefined;
-        } | undefined, params?: RequestParams) => Promise<ContractEventsByTxId>;
+            group?: number;
+        }, params?: RequestParams) => Promise<ContractEventsByTxId>;
     };
 }
 export {};

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

@@ -269,10 +269,10 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/blocks
          */
         getBlocks: (query?: {
-            page?: number | undefined;
-            limit?: number | undefined;
-            reverse?: boolean | undefined;
-        } | undefined, params?: RequestParams) => Promise<ListBlocks>;
+            page?: number;
+            limit?: number;
+            reverse?: boolean;
+        }, params?: RequestParams) => Promise<ListBlocks>;
         /**
          * @description Get a block with hash
          *
@@ -289,10 +289,10 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/blocks/{block-hash}/transactions
          */
         getBlocksBlockHashTransactions: (blockHash: string, query?: {
-            page?: number | undefined;
-            limit?: number | undefined;
-            reverse?: boolean | undefined;
-        } | undefined, params?: RequestParams) => Promise<Transaction[]>;
+            page?: number;
+            limit?: number;
+            reverse?: boolean;
+        }, params?: RequestParams) => Promise<Transaction[]>;
     };
     transactions: {
         /**
@@ -321,10 +321,10 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/addresses/{address}/transactions
          */
         getAddressesAddressTransactions: (address: string, query?: {
-            page?: number | undefined;
-            limit?: number | undefined;
-            reverse?: boolean | undefined;
-        } | undefined, params?: RequestParams) => Promise<Transaction[]>;
+            page?: number;
+            limit?: number;
+            reverse?: boolean;
+        }, params?: RequestParams) => Promise<Transaction[]>;
         /**
          * @description Get total transactions of a given address
          *
@@ -367,10 +367,10 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/infos/supply
          */
         getInfosSupply: (query?: {
-            page?: number | undefined;
-            limit?: number | undefined;
-            reverse?: boolean | undefined;
-        } | undefined, params?: RequestParams) => Promise<TokenSupply[]>;
+            page?: number;
+            limit?: number;
+            reverse?: boolean;
+        }, params?: RequestParams) => Promise<TokenSupply[]>;
         /**
          * @description Get the ALPH total supply
          *

package/dist/src/api/index.js

@@ -18,7 +18,11 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

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

@@ -1,5 +1,4 @@
-import { NodeProvider } from '../api';
-import { node } from '../api';
+import { node, NodeProvider } from '../api';
 import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer';
 import { CompileContractResult, CompileScriptResult } from '../api/api-alephium';
 declare type FieldsSig = node.FieldsSig;
@@ -11,6 +10,11 @@ declare enum SourceType {
     AbstractContract = 2,
     Interface = 3
 }
+export declare type CompilerOptions = node.CompilerOptions & {
+    errorOnWarnings: boolean;
+};
+export declare const DEFAULT_NODE_COMPILER_OPTIONS: node.CompilerOptions;
+export declare const DEFAULT_COMPILER_OPTIONS: CompilerOptions;
 declare class TypedMatcher<T extends SourceType> {
     matcher: RegExp;
     type: T;
@@ -23,7 +27,8 @@ declare class SourceFile {
     sourceCode: string;
     sourceCodeHash: string;
     getArtifactPath(artifactsRootPath: string): string;
-    constructor(type: SourceType, sourceCode: string, contractPath: string);
+    constructor(type: SourceType, sourceCode: string, sourceCodeHash: string, contractPath: string);
+    static from(type: SourceType, sourceCode: string, contractPath: string): Promise<SourceFile>;
 }
 declare class Compiled<T extends Artifact> {
     sourceFile: SourceFile;
@@ -31,10 +36,27 @@ declare class Compiled<T extends Artifact> {
     warnings: string[];
     constructor(sourceFile: SourceFile, artifact: T, warnings: string[]);
 }
+declare class ProjectArtifact {
+    static readonly artifactFileName = ".project.json";
+    compilerOptionsUsed: node.CompilerOptions;
+    infos: Map<string, {
+        sourceCodeHash: string;
+        warnings: string[];
+    }>;
+    static checkCompilerOptionsParameter(compilerOptions: node.CompilerOptions): void;
+    constructor(compilerOptionsUsed: node.CompilerOptions, infos: Map<string, {
+        sourceCodeHash: string;
+        warnings: string[];
+    }>);
+    saveToFile(rootPath: string): Promise<void>;
+    needToReCompile(compilerOptions: node.CompilerOptions, files: SourceFile[]): boolean;
+    static from(rootPath: string): Promise<ProjectArtifact | undefined>;
+}
 export declare class Project {
     sourceFiles: SourceFile[];
     contracts: Compiled<Contract>[];
     scripts: Compiled<Script>[];
+    projectArtifact: ProjectArtifact;
     readonly contractsRootPath: string;
     readonly artifactsRootPath: string;
     readonly nodeProvider: NodeProvider;
@@ -44,19 +66,19 @@ export declare class Project {
     static readonly interfaceMatcher: TypedMatcher<SourceType.Interface>;
     static readonly scriptMatcher: TypedMatcher<SourceType.Script>;
     static readonly matchers: TypedMatcher<SourceType>[];
+    static buildProjectArtifact(sourceFiles: SourceFile[], contracts: Compiled<Contract>[], scripts: Compiled<Script>[], compilerOptions: node.CompilerOptions): ProjectArtifact;
     private constructor();
     private getContractPath;
-    private static checkCompilerWarnings;
-    static contract(path: string, errorOnWarnings?: boolean, ignoreUnusedConstantsWarnings?: boolean): Contract;
-    static script(path: string, errorOnWarnings?: boolean, ignoreUnusedConstantsWarnings?: boolean): Script;
+    static checkCompilerWarnings(warnings: string[], errorOnWarnings: boolean): void;
+    static contract(path: string): Contract;
+    static script(path: string): Script;
     private saveArtifactsToFile;
     contractByCodeHash(codeHash: string): Contract;
-    private saveProjectArtifactToFile;
     private static compile;
     private static loadArtifacts;
     private static loadSourceFile;
     private static loadSourceFiles;
-    static build(provider: NodeProvider, contractsRootPath?: string, artifactsRootPath?: string): Promise<void>;
+    static build(compilerOptionsPartial?: Partial<CompilerOptions>, contractsRootPath?: string, artifactsRootPath?: string): Promise<void>;
 }
 export declare abstract class Artifact {
     readonly functions: FunctionSig[];

package/dist/src/contract/contract.js

@@ -18,7 +18,11 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -39,14 +43,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toApiVal = exports.extractArray = exports.Script = exports.Contract = exports.Artifact = exports.Project = void 0;
+exports.toApiVal = exports.extractArray = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = void 0;
 const buffer_1 = require("buffer/");
-const cryptojs = __importStar(require("crypto-js"));
-const crypto = __importStar(require("crypto"));
+const crypto_1 = require("crypto");
 const fs_1 = __importDefault(require("fs"));
 const fs_2 = require("fs");
 const ralph = __importStar(require("./ralph"));
 const utils_1 = require("../utils");
+const global_1 = require("../global");
 var SourceType;
 (function (SourceType) {
     SourceType[SourceType["Contract"] = 0] = "Contract";
@@ -54,6 +58,15 @@ var SourceType;
     SourceType[SourceType["AbstractContract"] = 2] = "AbstractContract";
     SourceType[SourceType["Interface"] = 3] = "Interface";
 })(SourceType || (SourceType = {}));
+exports.DEFAULT_NODE_COMPILER_OPTIONS = {
+    ignoreUnusedConstantsWarnings: false,
+    ignoreUnusedVariablesWarnings: false,
+    ignoreUnusedFieldsWarnings: false,
+    ignoreUnusedPrivateFunctionsWarnings: false,
+    ignoreReadonlyCheckWarnings: false,
+    ignoreExternalCallCheckWarnings: false
+};
+exports.DEFAULT_COMPILER_OPTIONS = { errorOnWarnings: true, ...exports.DEFAULT_NODE_COMPILER_OPTIONS };
 class TypedMatcher {
     constructor(pattern, type) {
         this.matcher = new RegExp(pattern, 'mg');
@@ -65,15 +78,19 @@ class TypedMatcher {
     }
 }
 class SourceFile {
-    constructor(type, sourceCode, contractPath) {
+    constructor(type, sourceCode, sourceCodeHash, contractPath) {
         this.type = type;
         this.sourceCode = sourceCode;
-        this.sourceCodeHash = cryptojs.SHA256(sourceCode).toString();
+        this.sourceCodeHash = sourceCodeHash;
         this.contractPath = contractPath;
     }
     getArtifactPath(artifactsRootPath) {
         return artifactsRootPath + this.contractPath.slice(this.contractPath.indexOf('/')) + '.json';
     }
+    static async from(type, sourceCode, contractPath) {
+        const sourceCodeHash = await crypto_1.webcrypto.subtle.digest('SHA-256', buffer_1.Buffer.from(sourceCode));
+        return new SourceFile(type, sourceCode, buffer_1.Buffer.from(sourceCodeHash).toString('hex'), contractPath);
+    }
 }
 class Compiled {
     constructor(sourceFile, artifact, warnings) {
@@ -83,15 +100,35 @@ class Compiled {
     }
 }
 class ProjectArtifact {
-    constructor(infos) {
+    constructor(compilerOptionsUsed, infos) {
+        ProjectArtifact.checkCompilerOptionsParameter(compilerOptionsUsed);
+        this.compilerOptionsUsed = compilerOptionsUsed;
         this.infos = infos;
     }
+    static checkCompilerOptionsParameter(compilerOptions) {
+        if (Object.keys(compilerOptions).length != Object.keys(exports.DEFAULT_NODE_COMPILER_OPTIONS).length) {
+            throw Error(`Not all compiler options are set: ${compilerOptions}`);
+        }
+        const combined = { ...compilerOptions, ...exports.DEFAULT_NODE_COMPILER_OPTIONS };
+        if (Object.keys(combined).length !== Object.keys(exports.DEFAULT_NODE_COMPILER_OPTIONS).length) {
+            throw Error(`There are unknown compiler options: ${compilerOptions}`);
+        }
+    }
     async saveToFile(rootPath) {
         const filepath = rootPath + '/' + ProjectArtifact.artifactFileName;
-        const content = JSON.stringify(Object.fromEntries(this.infos), null, 2);
+        const artifact = { compilerOptionsUsed: this.compilerOptionsUsed, infos: Object.fromEntries(this.infos) };
+        const content = JSON.stringify(artifact, null, 2);
         return fs_2.promises.writeFile(filepath, content);
     }
-    sourceHasChanged(files) {
+    needToReCompile(compilerOptions, files) {
+        ProjectArtifact.checkCompilerOptionsParameter(compilerOptions);
+        const optionsMatched = Object.entries(compilerOptions).every(([key, inputOption]) => {
+            const usedOption = this.compilerOptionsUsed[`${key}`];
+            return usedOption === inputOption;
+        });
+        if (!optionsMatched) {
+            return true;
+        }
         if (files.length !== this.infos.size) {
             return true;
         }
@@ -109,19 +146,48 @@ class ProjectArtifact {
             return undefined;
         }
         const content = await fs_2.promises.readFile(filepath);
-        const files = new Map(Object.entries(JSON.parse(content.toString())));
-        return new ProjectArtifact(files);
+        const json = JSON.parse(content.toString());
+        const compilerOptionsUsed = json.compilerOptionsUsed;
+        const files = new Map(Object.entries(json.infos));
+        return new ProjectArtifact(compilerOptionsUsed, files);
     }
 }
 ProjectArtifact.artifactFileName = '.project.json';
 class Project {
-    constructor(provider, contractsRootPath, artifactsRootPath, sourceFiles, contracts, scripts) {
+    constructor(provider, contractsRootPath, artifactsRootPath, sourceFiles, contracts, scripts, errorOnWarnings, projectArtifact) {
         this.nodeProvider = provider;
         this.contractsRootPath = contractsRootPath;
         this.artifactsRootPath = artifactsRootPath;
         this.sourceFiles = sourceFiles;
         this.contracts = contracts;
         this.scripts = scripts;
+        this.projectArtifact = projectArtifact;
+        if (errorOnWarnings) {
+            Project.checkCompilerWarnings([...contracts.map((c) => c.warnings).flat(), ...scripts.map((s) => s.warnings).flat()], errorOnWarnings);
+        }
+    }
+    static buildProjectArtifact(sourceFiles, contracts, scripts, compilerOptions) {
+        const files = new Map();
+        contracts.forEach((c) => {
+            files.set(c.sourceFile.contractPath, {
+                sourceCodeHash: c.sourceFile.sourceCodeHash,
+                warnings: c.warnings
+            });
+        });
+        scripts.forEach((s) => {
+            files.set(s.sourceFile.contractPath, {
+                sourceCodeHash: s.sourceFile.sourceCodeHash,
+                warnings: s.warnings
+            });
+        });
+        const compiledSize = contracts.length + scripts.length;
+        sourceFiles.slice(compiledSize).forEach((c) => {
+            files.set(c.contractPath, {
+                sourceCodeHash: c.sourceCodeHash,
+                warnings: []
+            });
+        });
+        return new ProjectArtifact(compilerOptions, files);
     }
     getContractPath(path) {
         return path.startsWith(`./${this.contractsRootPath}`)
@@ -130,12 +196,11 @@ class Project {
                 ? path
                 : this.contractsRootPath + '/' + path;
     }
-    static checkCompilerWarnings(warnings, errorOnWarnings, ignoreUnusedConstantsWarnings) {
-        const remains = ignoreUnusedConstantsWarnings ? warnings.filter((s) => !s.includes('unused constants')) : warnings;
-        if (remains.length !== 0) {
+    static checkCompilerWarnings(warnings, errorOnWarnings) {
+        if (warnings.length !== 0) {
             const prefixPerWarning = '  - ';
-            const warningString = prefixPerWarning + remains.join('\n' + prefixPerWarning);
-            const output = 'Compilation warnings:\n' + warningString + '\n';
+            const warningString = prefixPerWarning + warnings.join('\n' + prefixPerWarning);
+            const output = `Compilation warnings:\n` + warningString + '\n';
             if (errorOnWarnings) {
                 throw new Error(output);
             }
@@ -144,22 +209,20 @@ class Project {
             }
         }
     }
-    static contract(path, errorOnWarnings = true, ignoreUnusedConstantsWarnings = true) {
+    static contract(path) {
         const contractPath = Project.currentProject.getContractPath(path);
         const contract = Project.currentProject.contracts.find((c) => c.sourceFile.contractPath === contractPath);
         if (typeof contract === 'undefined') {
             throw new Error(`Contract ${contractPath} does not exist`);
         }
-        Project.checkCompilerWarnings(contract.warnings, errorOnWarnings, ignoreUnusedConstantsWarnings);
         return contract.artifact;
     }
-    static script(path, errorOnWarnings = true, ignoreUnusedConstantsWarnings = true) {
+    static script(path) {
         const contractPath = Project.currentProject.getContractPath(path);
         const script = Project.currentProject.scripts.find((c) => c.sourceFile.contractPath === contractPath);
         if (typeof script === 'undefined') {
             throw new Error(`Script ${contractPath} does not exist`);
         }
-        Project.checkCompilerWarnings(script.warnings, errorOnWarnings, ignoreUnusedConstantsWarnings);
         return script.artifact;
     }
     async saveArtifactsToFile() {
@@ -178,6 +241,7 @@ class Project {
         for (const script of this.scripts) {
             await saveToFile(script);
         }
+        await this.projectArtifact.saveToFile(this.artifactsRootPath);
     }
     contractByCodeHash(codeHash) {
         const contract = this.contracts.find((c) => c.artifact.codeHash === codeHash);
@@ -186,34 +250,11 @@ class Project {
         }
         return contract.artifact;
     }
-    async saveProjectArtifactToFile() {
-        const files = new Map();
-        this.contracts.forEach((c) => {
-            files.set(c.sourceFile.contractPath, {
-                sourceCodeHash: c.sourceFile.sourceCodeHash,
-                warnings: c.warnings
-            });
-        });
-        this.scripts.forEach((s) => {
-            files.set(s.sourceFile.contractPath, {
-                sourceCodeHash: s.sourceFile.sourceCodeHash,
-                warnings: s.warnings
-            });
-        });
-        const compiledSize = this.contracts.length + this.scripts.length;
-        this.sourceFiles.slice(compiledSize).forEach((c) => {
-            files.set(c.contractPath, {
-                sourceCodeHash: c.sourceCodeHash,
-                warnings: []
-            });
-        });
-        const projectArtifact = new ProjectArtifact(files);
-        await projectArtifact.saveToFile(this.artifactsRootPath);
-    }
-    static async compile(provider, files, contractsRootPath, artifactsRootPath) {
+    static async compile(provider, files, contractsRootPath, artifactsRootPath, errorOnWarnings, compilerOptions) {
         const sourceStr = files.map((f) => f.sourceCode).join('\n');
         const result = await provider.contracts.postContractsCompileProject({
-            code: sourceStr
+            code: sourceStr,
+            compilerOptions: compilerOptions
         });
         const contracts = [];
         const scripts = [];
@@ -227,12 +268,12 @@ class Project {
             const script = Script.fromCompileResult(scriptResult);
             scripts.push(new Compiled(sourceFile, script, scriptResult.warnings));
         });
-        const project = new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts);
+        const projectArtifact = Project.buildProjectArtifact(files, contracts, scripts, compilerOptions);
+        const project = new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts, errorOnWarnings, projectArtifact);
         await project.saveArtifactsToFile();
-        await project.saveProjectArtifactToFile();
         return project;
     }
-    static async loadArtifacts(provider, files, projectArtifact, contractsRootPath, artifactsRootPath) {
+    static async loadArtifacts(provider, files, projectArtifact, contractsRootPath, artifactsRootPath, errorOnWarnings, compilerOptions) {
         try {
             const contracts = [];
             const scripts = [];
@@ -252,11 +293,11 @@ class Project {
                     scripts.push(new Compiled(file, artifact, warnings));
                 }
             }
-            return new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts);
+            return new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts, errorOnWarnings, projectArtifact);
         }
         catch (error) {
             console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`);
-            return Project.compile(provider, files, contractsRootPath, artifactsRootPath);
+            return Project.compile(provider, files, contractsRootPath, artifactsRootPath, errorOnWarnings, compilerOptions);
         }
     }
     static async loadSourceFile(dirPath, filename) {
@@ -276,7 +317,7 @@ class Project {
         }
         const matcherIndex = results.indexOf(1);
         const type = this.matchers[`${matcherIndex}`].type;
-        return new SourceFile(type, sourceStr, contractPath);
+        return SourceFile.from(type, sourceStr, contractPath);
     }
     static async loadSourceFiles(contractsRootPath) {
         const loadDir = async function (dirPath, results) {
@@ -300,14 +341,18 @@ class Project {
         }
         return sourceFiles.sort((a, b) => a.type - b.type);
     }
-    static async build(provider, contractsRootPath = 'contracts', artifactsRootPath = 'artifacts') {
+    static async build(compilerOptionsPartial = {}, contractsRootPath = 'contracts', artifactsRootPath = 'artifacts') {
+        const provider = (0, global_1.getCurrentNodeProvider)();
         const sourceFiles = await Project.loadSourceFiles(contractsRootPath);
+        const { errorOnWarnings, ...nodeCompilerOptions } = { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial };
         const projectArtifact = await ProjectArtifact.from(artifactsRootPath);
-        if (typeof projectArtifact === 'undefined' || projectArtifact.sourceHasChanged(sourceFiles)) {
-            Project.currentProject = await Project.compile(provider, sourceFiles, contractsRootPath, artifactsRootPath);
+        if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {
+            console.log(`Compile contracts in folder "${contractsRootPath}"`);
+            Project.currentProject = await Project.compile(provider, sourceFiles, contractsRootPath, artifactsRootPath, errorOnWarnings, nodeCompilerOptions);
         }
         else {
-            Project.currentProject = await Project.loadArtifacts(provider, sourceFiles, projectArtifact, contractsRootPath, artifactsRootPath);
+            console.log(`Load compiled contracts from folder "${artifactsRootPath}"`);
+            Project.currentProject = await Project.loadArtifacts(provider, sourceFiles, projectArtifact, contractsRootPath, artifactsRootPath, errorOnWarnings, nodeCompilerOptions);
         }
     }
 }
@@ -394,8 +439,10 @@ class Contract extends Artifact {
             asset: asset
         };
     }
+    // no need to be cryptographically strong random
     static randomAddress() {
-        const bytes = crypto.randomBytes(33);
+        const bytes = new Uint8Array(33);
+        crypto_1.webcrypto.getRandomValues(bytes);
         bytes[0] = 3;
         return utils_1.bs58.encode(bytes);
     }

package/dist/src/contract/index.js

@@ -18,7 +18,11 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/dist/src/global.d.ts

@@ -0,0 +1,3 @@
+import { NodeProvider } from './api';
+export declare function setCurrentNodeProvider(provider: NodeProvider | string): void;
+export declare function getCurrentNodeProvider(): NodeProvider;

package/{src/utils/djb2.test.ts → dist/src/global.js}

@@ -1,3 +1,4 @@
+"use strict";
 /*
 Copyright 2018 - 2022 The Alephium Authors
 This file is part of the alephium project.
@@ -15,21 +16,23 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-
-import { Buffer } from 'buffer/'
-import djb2 from './djb2'
-
-describe('djb2', function () {
-  it('djb2', async () => {
-    function check(str: string, expected: number) {
-      const bytes = Buffer.from(str, 'utf8')
-      expect(djb2(bytes)).toEqual(expected)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentNodeProvider = exports.setCurrentNodeProvider = void 0;
+const api_1 = require("./api");
+let _currentNodeProvider = undefined;
+function setCurrentNodeProvider(provider) {
+    if (typeof provider == 'string') {
+        _currentNodeProvider = new api_1.NodeProvider(provider);
     }
-
-    check('', 5381)
-    check('a', 177670)
-    check('z', 177695)
-    check('foo', 193491849)
-    check('bar', 193487034)
-  })
-})
+    else {
+        _currentNodeProvider = provider;
+    }
+}
+exports.setCurrentNodeProvider = setCurrentNodeProvider;
+function getCurrentNodeProvider() {
+    if (typeof _currentNodeProvider === 'undefined') {
+        throw Error('No node provider is set.');
+    }
+    return _currentNodeProvider;
+}
+exports.getCurrentNodeProvider = getCurrentNodeProvider;

package/dist/src/index.d.ts

@@ -4,3 +4,5 @@ export * from './signer';
 export * from './utils';
 export * from './transaction';
 export * from './constants';
+export * from './global';
+export * as utils from './utils';