@alephium/web3 0.2.0-rc.1 → 0.2.0-rc.10

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'))) {
@@ -86,7 +86,8 @@ function prepareShared(packageRoot, projectRoot) {
 }
 function prepareBase(packageRoot, projectRoot) {
     prepareShared(packageRoot, projectRoot);
-    copy('contracts', ['greeter.ral', 'greeter_interface.ral', 'greeter_main.ral']);
+    copy('contracts', ['greeter_main.ral']);
+    copy('contracts/greeter', ['greeter.ral', 'greeter_interface.ral']);
     fs_extra_1.default.copySync(path_1.default.join(packageRoot, 'templates/base'), projectRoot);
 }
 function prepareReact(packageRoot, projectRoot, projectName) {

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

@@ -305,17 +305,33 @@ export interface ChangeActiveAddress {
     address: string;
 }
 export interface CompileContractResult {
+    name: string;
     bytecode: string;
     /** @format 32-byte-hash */
     codeHash: string;
     fields: FieldsSig;
     functions: FunctionSig[];
     events: EventSig[];
+    warnings: string[];
+}
+export interface CompileProjectResult {
+    contracts: CompileContractResult[];
+    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 */
@@ -332,6 +348,7 @@ export interface Confirmed {
 }
 export interface Contract {
     code: string;
+    compilerOptions?: CompilerOptions;
 }
 export interface ContractEvent {
     /** @format block-hash */
@@ -409,7 +426,6 @@ export interface Destination {
 export declare type DiscoveryAction = Reachable | Unreachable;
 export interface EventSig {
     name: string;
-    signature: string;
     fieldNames: string[];
     fieldTypes: string[];
 }
@@ -417,9 +433,9 @@ export interface FetchResponse {
     blocks: BlockEntry[][];
 }
 export interface FieldsSig {
-    signature: string;
     names: string[];
     types: string[];
+    isMutable: boolean[];
 }
 export interface FixedAssetOutput {
     /** @format int32 */
@@ -438,9 +454,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 +541,10 @@ export interface Penalty {
     value: number;
     type: string;
 }
+export interface Project {
+    code: string;
+    compilerOptions?: CompilerOptions;
+}
 export interface Reachable {
     peers: string[];
     type: string;
@@ -542,6 +565,7 @@ export interface RevealMnemonicResult {
 }
 export interface Script {
     code: string;
+    compilerOptions?: CompilerOptions;
 }
 export interface SelfClique {
     /** @format clique-id */
@@ -1013,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
          *
@@ -1146,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: {
         /**
@@ -1334,6 +1358,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
          *
@@ -1485,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-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/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.d.ts

@@ -1,7 +1,7 @@
 import { Api as NodeApi } from './api-alephium';
 import { Api as ExplorerApi } from './api-explorer';
-export declare class NodeProvider extends NodeApi<null> {
-    constructor(baseUrl: string);
+export declare class NodeProvider extends NodeApi<string> {
+    constructor(baseUrl: string, apiKey?: string);
 }
 export declare class ExplorerProvider extends ExplorerApi<null> {
     constructor(baseUrl: string);

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];
@@ -40,8 +44,19 @@ exports.explorer = exports.node = exports.ExplorerProvider = exports.NodeProvide
 const api_alephium_1 = require("./api-alephium");
 const api_explorer_1 = require("./api-explorer");
 class NodeProvider extends api_alephium_1.Api {
-    constructor(baseUrl) {
-        super({ baseUrl: baseUrl });
+    constructor(baseUrl, apiKey) {
+        // eslint-disable-next-line security/detect-possible-timing-attacks
+        if (apiKey === undefined) {
+            super({ baseUrl: baseUrl });
+        }
+        else {
+            super({
+                baseUrl: baseUrl,
+                baseApiParams: { secure: true },
+                securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
+            });
+            this.setSecurityData(apiKey);
+        }
     }
 }
 exports.NodeProvider = NodeProvider;

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

@@ -1,79 +1,128 @@
-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;
+declare type EventSig = node.EventSig;
+declare type FunctionSig = node.FunctionSig;
+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(path: string): Contract;
+    static script(path: 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 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 +156,7 @@ export interface ContractState {
     initialStateHash?: string;
     codeHash: string;
     fields: Fields;
-    fieldsSig: node.FieldsSig;
+    fieldsSig: FieldsSig;
     asset: Asset;
 }
 export interface TestContractParams {