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

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

@@ -313,6 +313,10 @@ export interface CompileContractResult {
     events: EventSig[];
     warnings: string[];
 }
+export interface CompileProjectResult {
+    contracts: CompileContractResult[];
+    scripts: CompileScriptResult[];
+}
 export interface CompileScriptResult {
     bytecodeTemplate: string;
     fields: FieldsSig;
@@ -526,6 +530,9 @@ export interface Penalty {
     value: number;
     type: string;
 }
+export interface Project {
+    code: string;
+}
 export interface Reachable {
     peers: string[];
     type: string;
@@ -1338,6 +1345,15 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request POST:/contracts/compile-contract
          */
         postContractsCompileContract: (data: Contract, params?: RequestParams) => Promise<CompileContractResult>;
+        /**
+         * No description
+         *
+         * @tags Contracts
+         * @name PostContractsCompileProject
+         * @summary Compile a project
+         * @request POST:/contracts/compile-project
+         */
+        postContractsCompileProject: (data: Project, params?: RequestParams) => Promise<CompileProjectResult>;
         /**
          * No description
          *

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

@@ -901,6 +901,22 @@ class Api extends HttpClient {
                 format: 'json',
                 ...params
             }).then(convertHttpResponse),
+            /**
+             * No description
+             *
+             * @tags Contracts
+             * @name PostContractsCompileProject
+             * @summary Compile a project
+             * @request POST:/contracts/compile-project
+             */
+            postContractsCompileProject: (data, params = {}) => this.request({
+                path: `/contracts/compile-project`,
+                method: 'POST',
+                body: data,
+                type: ContentType.Json,
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse),
             /**
              * No description
              *

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

@@ -1,71 +1,92 @@
 import { NodeProvider } from '../api';
 import { node } from '../api';
 import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer';
-declare class SourceFile {
-    readonly dirs: string[];
-    readonly dirPath: string;
-    readonly contractPath: string;
-    readonly artifactPath: string;
-    constructor(dirs: string[], fileName: string);
-}
+import { CompileContractResult, CompileScriptResult } from '../api/api-alephium';
 declare type FieldsSig = node.FieldsSig;
 declare type EventSig = node.EventSig;
 declare type FunctionSig = node.FunctionSig;
-export declare abstract class Common {
-    readonly sourceCodeSha256: string;
+declare enum SourceType {
+    Contract = 0,
+    Script = 1,
+    AbstractContract = 2,
+    Interface = 3
+}
+declare class TypedMatcher<T extends SourceType> {
+    matcher: RegExp;
+    type: T;
+    constructor(pattern: string, type: T);
+    match(str: string): number;
+}
+declare class SourceFile {
+    type: SourceType;
+    contractPath: string;
+    sourceCode: string;
+    sourceCodeHash: string;
+    getArtifactPath(artifactsRootPath: string): string;
+    constructor(type: SourceType, sourceCode: string, contractPath: string);
+}
+declare class Compiled<T extends Artifact> {
+    sourceFile: SourceFile;
+    artifact: T;
+    warnings: string[];
+    constructor(sourceFile: SourceFile, artifact: T, warnings: string[]);
+}
+export declare class Project {
+    sourceFiles: SourceFile[];
+    contracts: Compiled<Contract>[];
+    scripts: Compiled<Script>[];
+    readonly contractsRootPath: string;
+    readonly artifactsRootPath: string;
+    readonly nodeProvider: NodeProvider;
+    static currentProject: Project;
+    static readonly abstractContractMatcher: TypedMatcher<SourceType>;
+    static readonly contractMatcher: TypedMatcher<SourceType.Contract>;
+    static readonly interfaceMatcher: TypedMatcher<SourceType.Interface>;
+    static readonly scriptMatcher: TypedMatcher<SourceType.Script>;
+    static readonly matchers: TypedMatcher<SourceType>[];
+    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;
+    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>;
+}
+export declare abstract class Artifact {
     readonly functions: FunctionSig[];
-    static readonly importRegex: RegExp;
-    static readonly contractRegex: RegExp;
-    static readonly interfaceRegex: RegExp;
-    static readonly scriptRegex: RegExp;
-    private static _artifactCache;
-    static artifactCacheCapacity: number;
-    protected static _getArtifactFromCache(codeHash: string): Contract | Script | undefined;
-    protected static _putArtifactToCache(contract: Contract): void;
-    constructor(sourceCodeSha256: string, functions: FunctionSig[]);
-    protected static _artifactsFolder(): string;
-    static getSourceFile(path: string, _dirs: string[]): SourceFile;
-    protected static _handleImports(pathes: string[], contractStr: string, importsCache: string[]): Promise<string>;
-    protected static _loadContractStr(sourceFile: SourceFile, importsCache: string[], validate: (code: string) => void): Promise<string>;
-    static checkFileNameExtension(fileName: string): void;
-    protected static _from<T extends {
-        sourceCodeSha256: string;
-    }>(provider: NodeProvider, sourceFile: SourceFile, loadContractStr: (sourceFile: SourceFile, importsCache: string[]) => Promise<string>, compile: (provider: NodeProvider, sourceFile: SourceFile, contractStr: string, contractHash: string, errorOnWarnings: boolean, ignoreUnusedConstantsWarnings: boolean) => Promise<T>, errorOnWarnings: boolean, ignoreUnusedConstantsWarnings: boolean): Promise<T>;
-    protected _saveToFile(sourceFile: SourceFile): Promise<void>;
+    constructor(functions: FunctionSig[]);
     abstract buildByteCodeToDeploy(initialFields?: Fields): string;
     publicFunctions(): string[];
     usingPreapprovedAssetsFunctions(): string[];
     usingAssetsInContractFunctions(): string[];
-    protected static checkCompilerWarnings(compiled: {
-        warnings: string[];
-    }, errorOnWarnings: boolean, ignoreUnusedConstantsWarnings: boolean): void;
 }
-export declare class Contract extends Common {
+export declare class Contract extends Artifact {
     readonly bytecode: string;
     readonly codeHash: string;
     readonly fieldsSig: FieldsSig;
     readonly eventsSig: EventSig[];
-    constructor(sourceCodeSha256: string, bytecode: string, codeHash: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[]);
-    static checkCodeType(fileName: string, contractStr: string): void;
-    private static loadContractStr;
-    static fromSource(provider: NodeProvider, path: string, errorOnWarnings?: boolean, ignoreUnusedConstantsWarnings?: boolean): Promise<Contract>;
-    private static compile;
+    constructor(bytecode: string, codeHash: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[]);
     static fromJson(artifact: any): Contract;
+    static fromCompileResult(result: CompileContractResult): Contract;
     static fromArtifactFile(path: string): Promise<Contract>;
-    fetchState(provider: NodeProvider, address: string, group: number): Promise<ContractState>;
+    fetchState(address: string, group: number): Promise<ContractState>;
     toString(): string;
     toState(fields: Fields, asset: Asset, address?: string): ContractState;
     static randomAddress(): string;
     private _test;
-    testPublicMethod(provider: NodeProvider, funcName: string, params: TestContractParams): Promise<TestContractResult>;
-    testPrivateMethod(provider: NodeProvider, funcName: string, params: TestContractParams): Promise<TestContractResult>;
+    testPublicMethod(funcName: string, params: TestContractParams): Promise<TestContractResult>;
+    testPrivateMethod(funcName: string, params: TestContractParams): Promise<TestContractResult>;
     toApiFields(fields?: Fields): node.Val[];
     toApiArgs(funcName: string, args?: Arguments): node.Val[];
     getMethodIndex(funcName: string): number;
     toApiContractStates(states?: ContractState[]): node.ContractState[] | undefined;
     toTestContract(funcName: string, params: TestContractParams): node.TestContract;
-    static fromCodeHash(codeHash: string): Promise<Contract>;
-    static getFieldsSig(state: node.ContractState): Promise<FieldsSig>;
     fromApiContractState(state: node.ContractState): Promise<ContractState>;
     static ContractCreatedEvent: EventSig;
     static ContractDestroyedEvent: EventSig;
@@ -75,14 +96,11 @@ export declare class Contract extends Common {
     transactionForDeployment(signer: SignerWithNodeProvider, params: Omit<BuildDeployContractTx, 'signerAddress'>): Promise<DeployContractTransaction>;
     buildByteCodeToDeploy(initialFields: Fields): string;
 }
-export declare class Script extends Common {
+export declare class Script extends Artifact {
     readonly bytecodeTemplate: string;
     readonly fieldsSig: FieldsSig;
-    constructor(sourceCodeSha256: string, bytecodeTemplate: string, fieldsSig: FieldsSig, functions: FunctionSig[]);
-    static checkCodeType(fileName: string, contractStr: string): void;
-    private static loadContractStr;
-    static fromSource(provider: NodeProvider, path: string, errorOnWarnings?: boolean, ignoreUnusedConstantsWarnings?: boolean): Promise<Script>;
-    private static compile;
+    constructor(bytecodeTemplate: string, fieldsSig: FieldsSig, functions: FunctionSig[]);
+    static fromCompileResult(result: CompileScriptResult): Script;
     static fromJson(artifact: any): Script;
     static fromArtifactFile(path: string): Promise<Script>;
     toString(): string;