@alephium/web3 0.2.0-rc.0 → 0.2.0-rc.11

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

@@ -1,79 +1,130 @@
-import { NodeProvider } from '../api';
-import { node } from '../api';
+import { NamedVals, node, NodeProvider, Number256, Token, Val } from '../api';
 import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer';
+export declare type FieldsSig = node.FieldsSig;
+export declare type EventSig = node.EventSig;
+export declare type FunctionSig = node.FunctionSig;
+export declare type Fields = NamedVals;
+export declare type Arguments = NamedVals;
+declare enum SourceType {
+    Contract = 0,
+    Script = 1,
+    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;
+    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, sourceCodeHash: string, contractPath: string);
+    static from(type: SourceType, sourceCode: string, contractPath: string): Promise<SourceFile>;
+}
+declare class Compiled<T extends Artifact> {
+    sourceFile: SourceFile;
+    artifact: T;
+    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;
+    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>[];
+    static buildProjectArtifact(sourceFiles: SourceFile[], contracts: Compiled<Contract>[], scripts: Compiled<Script>[], compilerOptions: node.CompilerOptions): ProjectArtifact;
+    private constructor();
+    private getContractPath;
+    static checkCompilerWarnings(warnings: string[], errorOnWarnings: boolean): void;
+    static contract(name: string): Contract;
+    static script(name: string): Script;
+    private saveArtifactsToFile;
+    contractByCodeHash(codeHash: string): Contract;
+    private static compile;
+    private static loadArtifacts;
+    private static loadSourceFile;
+    private static loadSourceFiles;
+    static build(compilerOptionsPartial?: Partial<CompilerOptions>, contractsRootPath?: string, artifactsRootPath?: string): Promise<void>;
+}
+export declare abstract class Artifact {
+    readonly name: string;
+    readonly functions: FunctionSig[];
+    constructor(name: string, 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(name: string, bytecode: string, codeHash: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[]);
     static fromJson(artifact: any): Contract;
+    static fromCompileResult(result: node.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(name: string, bytecodeTemplate: string, fieldsSig: FieldsSig, functions: FunctionSig[]);
+    static fromCompileResult(result: node.CompileScriptResult): Script;
     static fromJson(artifact: any): Script;
     static fromArtifactFile(path: string): Promise<Script>;
     toString(): string;
@@ -81,21 +132,10 @@ export declare class Script extends Common {
     transactionForDeployment(signer: SignerWithNodeProvider, params: Omit<BuildExecuteScriptTx, 'signerAddress'>): Promise<BuildScriptTxResult>;
     buildByteCodeToDeploy(initialFields: Fields): string;
 }
-export declare type Number256 = number | bigint | string;
-export declare type Val = Number256 | boolean | string | Val[];
-export declare type NamedVals = Record<string, Val>;
-export declare type Fields = NamedVals;
-export declare type Arguments = NamedVals;
-export declare function extractArray(tpe: string, v: Val): node.Val;
-export declare function toApiVal(v: Val, tpe: string): node.Val;
 export interface Asset {
     alphAmount: Number256;
     tokens?: Token[];
 }
-export interface Token {
-    id: string;
-    amount: Number256;
-}
 export interface InputAsset {
     address: string;
     asset: Asset;
@@ -107,7 +147,7 @@ export interface ContractState {
     initialStateHash?: string;
     codeHash: string;
     fields: Fields;
-    fieldsSig: node.FieldsSig;
+    fieldsSig: FieldsSig;
     asset: Asset;
 }
 export interface TestContractParams {
@@ -152,7 +192,7 @@ export interface ContractOutput {
     type: string;
     address: string;
     alphAmount: Number256;
-    tokens: Token[];
+    tokens?: Token[];
 }
 export interface DeployContractTransaction {
     fromGroup: number;