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

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

@@ -311,11 +311,17 @@ export interface CompileContractResult {
     fields: FieldsSig;
     functions: FunctionSig[];
     events: EventSig[];
+    warnings: string[];
+}
+export interface CompileProjectResult {
+    contracts: CompileContractResult[];
+    scripts: CompileScriptResult[];
 }
 export interface CompileScriptResult {
     bytecodeTemplate: string;
     fields: FieldsSig;
     functions: FunctionSig[];
+    warnings: string[];
 }
 export interface Confirmed {
     /** @format block-hash */
@@ -409,7 +415,6 @@ export interface Destination {
 export declare type DiscoveryAction = Reachable | Unreachable;
 export interface EventSig {
     name: string;
-    signature: string;
     fieldNames: string[];
     fieldTypes: string[];
 }
@@ -417,9 +422,9 @@ export interface FetchResponse {
     blocks: BlockEntry[][];
 }
 export interface FieldsSig {
-    signature: string;
     names: string[];
     types: string[];
+    isMutable: boolean[];
 }
 export interface FixedAssetOutput {
     /** @format int32 */
@@ -438,9 +443,12 @@ export interface FixedAssetOutput {
 }
 export interface FunctionSig {
     name: string;
-    signature: string;
-    argNames: string[];
-    argTypes: string[];
+    usePreapprovedAssets: boolean;
+    useAssetsInContract: boolean;
+    isPublic: boolean;
+    paramNames: string[];
+    paramTypes: string[];
+    paramIsMutable: boolean[];
     returnTypes: string[];
 }
 export interface Group {
@@ -522,6 +530,9 @@ export interface Penalty {
     value: number;
     type: string;
 }
+export interface Project {
+    code: string;
+}
 export interface Reachable {
     peers: string[];
     type: string;
@@ -1334,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,79 +1,106 @@
 import { NodeProvider } from '../api';
 import { node } from '../api';
 import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer';
+import { CompileContractResult, CompileScriptResult } from '../api/api-alephium';
+declare type FieldsSig = node.FieldsSig;
+declare type EventSig = node.EventSig;
+declare type FunctionSig = node.FunctionSig;
+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 {
-    readonly dirs: string[];
-    readonly dirPath: string;
-    readonly contractPath: string;
-    readonly artifactPath: string;
-    constructor(dirs: string[], fileName: string);
-}
-export declare abstract class Common {
-    readonly sourceCodeSha256: string;
-    readonly functions: node.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: node.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) => Promise<T>): Promise<T>;
-    protected _saveToFile(sourceFile: SourceFile): Promise<void>;
+    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[];
+    constructor(functions: FunctionSig[]);
     abstract buildByteCodeToDeploy(initialFields?: Fields): string;
+    publicFunctions(): string[];
+    usingPreapprovedAssetsFunctions(): string[];
+    usingAssetsInContractFunctions(): string[];
 }
-export declare class Contract extends Common {
+export declare class Contract extends Artifact {
     readonly bytecode: string;
     readonly codeHash: string;
-    readonly fieldsSig: node.FieldsSig;
-    readonly eventsSig: node.EventSig[];
-    constructor(sourceCodeSha256: string, bytecode: string, codeHash: string, fieldsSig: node.FieldsSig, eventsSig: node.EventSig[], functions: node.FunctionSig[]);
-    static checkCodeType(fileName: string, contractStr: string): void;
-    private static loadContractStr;
-    static fromSource(provider: NodeProvider, path: string): Promise<Contract>;
-    private static compile;
+    readonly fieldsSig: FieldsSig;
+    readonly eventsSig: EventSig[];
+    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<node.FieldsSig>;
     fromApiContractState(state: node.ContractState): Promise<ContractState>;
-    static ContractCreatedEvent: node.EventSig;
-    static ContractDestroyedEvent: node.EventSig;
+    static ContractCreatedEvent: EventSig;
+    static ContractDestroyedEvent: EventSig;
     static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined): Promise<ContractEventByTxId>;
     fromTestContractResult(methodIndex: number, result: node.TestContractResult): Promise<TestContractResult>;
     paramsForDeployment(params: BuildDeployContractTx): Promise<SignDeployContractTxParams>;
     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: node.FieldsSig;
-    constructor(sourceCodeSha256: string, bytecodeTemplate: string, fieldsSig: node.FieldsSig, functions: node.FunctionSig[]);
-    static checkCodeType(fileName: string, contractStr: string): void;
-    private static loadContractStr;
-    static fromSource(provider: NodeProvider, path: string): Promise<Script>;
-    private static compile;
+    readonly fieldsSig: FieldsSig;
+    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;
@@ -107,7 +134,7 @@ export interface ContractState {
     initialStateHash?: string;
     codeHash: string;
     fields: Fields;
-    fieldsSig: node.FieldsSig;
+    fieldsSig: FieldsSig;
     asset: Asset;
 }
 export interface TestContractParams {