@alephium/web3 0.41.0 → 0.42.0

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

@@ -12,60 +12,11 @@ export type Arguments = NamedVals;
 export type Constant = node.Constant;
 export type Enum = node.Enum;
 export declare const StdIdFieldName = "__stdInterfaceId";
-declare enum SourceKind {
-    Contract = 0,
-    Script = 1,
-    AbstractContract = 2,
-    Interface = 3,
-    Struct = 4
-}
 export 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 SourceKind> {
-    matcher: RegExp;
-    type: T;
-    constructor(pattern: string, type: T);
-}
-declare class SourceInfo {
-    type: SourceKind;
-    name: string;
-    contractRelativePath: string;
-    sourceCode: string;
-    sourceCodeHash: string;
-    isExternal: boolean;
-    getArtifactPath(artifactsRootDir: string): string;
-    constructor(type: SourceKind, name: string, sourceCode: string, sourceCodeHash: string, contractRelativePath: string, isExternal: boolean);
-    static from(type: SourceKind, name: string, sourceCode: string, contractRelativePath: string, isExternal: boolean): Promise<SourceInfo>;
-}
-declare class Compiled<T extends Artifact> {
-    sourceInfo: SourceInfo;
-    artifact: T;
-    warnings: string[];
-    constructor(sourceInfo: SourceInfo, artifact: T, warnings: string[]);
-}
-type CodeInfo = {
-    sourceFile: string;
-    sourceCodeHash: string;
-    bytecodeDebugPatch: string;
-    codeHashDebug: string;
-    warnings: string[];
-};
-export declare class ProjectArtifact {
-    static readonly artifactFileName = ".project.json";
-    fullNodeVersion: string;
-    compilerOptionsUsed: node.CompilerOptions;
-    infos: Map<string, CodeInfo>;
-    static checkCompilerOptionsParameter(compilerOptions: node.CompilerOptions): void;
-    constructor(fullNodeVersion: string, compilerOptionsUsed: node.CompilerOptions, infos: Map<string, CodeInfo>);
-    static isCodeChanged(current: ProjectArtifact, previous: ProjectArtifact): boolean;
-    saveToFile(rootPath: string): Promise<void>;
-    getChangedSources(sourceInfos: SourceInfo[]): SourceInfo[];
-    needToReCompile(compilerOptions: node.CompilerOptions, fullNodeVersion: string): boolean;
-    static from(rootPath: string): Promise<ProjectArtifact | undefined>;
-}
 export declare class Struct {
     name: string;
     fieldNames: string[];
@@ -76,43 +27,6 @@ export declare class Struct {
     static fromStructSig(sig: node.StructSig): Struct;
     toJson(): any;
 }
-export declare class Project {
-    sourceInfos: SourceInfo[];
-    contracts: Map<string, Compiled<Contract>>;
-    scripts: Map<string, Compiled<Script>>;
-    structs: Struct[];
-    projectArtifact: ProjectArtifact;
-    readonly contractsRootDir: string;
-    readonly artifactsRootDir: string;
-    static currentProject: Project;
-    static readonly importRegex: RegExp;
-    static readonly abstractContractMatcher: TypedMatcher<SourceKind>;
-    static readonly contractMatcher: TypedMatcher<SourceKind.Contract>;
-    static readonly interfaceMatcher: TypedMatcher<SourceKind.Interface>;
-    static readonly scriptMatcher: TypedMatcher<SourceKind.Script>;
-    static readonly structMatcher: TypedMatcher<SourceKind.Struct>;
-    static readonly matchers: TypedMatcher<SourceKind>[];
-    static buildProjectArtifact(fullNodeVersion: string, sourceInfos: SourceInfo[], contracts: Map<string, Compiled<Contract>>, scripts: Map<string, Compiled<Script>>, compilerOptions: node.CompilerOptions): ProjectArtifact;
-    private constructor();
-    static checkCompilerWarnings(warnings: string[], errorOnWarnings: boolean): void;
-    static contract(name: string): Contract;
-    static script(name: string): Script;
-    private static loadStructs;
-    private saveStructsToFile;
-    private saveArtifactsToFile;
-    private saveProjectArtifact;
-    contractByCodeHash(codeHash: string): Contract;
-    private static getCompileResult;
-    private static compile;
-    private static loadArtifacts;
-    private static getImportSourcePath;
-    private static handleImports;
-    private static loadSourceFile;
-    private static loadSourceFiles;
-    static readonly DEFAULT_CONTRACTS_DIR = "contracts";
-    static readonly DEFAULT_ARTIFACTS_DIR = "artifacts";
-    static build(compilerOptionsPartial?: Partial<CompilerOptions>, projectRootDir?: string, contractsRootDir?: string, artifactsRootDir?: string, defaultFullNodeVersion?: string | undefined, skipSaveArtifacts?: boolean): Promise<void>;
-}
 export declare abstract class Artifact {
     readonly version: string;
     readonly name: string;
@@ -153,18 +67,18 @@ export declare class Contract extends Artifact {
     toApiContractStates(states?: ContractState[]): node.ContractState[] | undefined;
     toApiTestContractParams(funcName: string, params: TestContractParams): node.TestContract;
     fromApiContractState(state: node.ContractState): ContractState<Fields>;
-    static fromApiContractState(state: node.ContractState, getContractByCodeHash?: (codeHash: string) => Contract): ContractState;
+    static fromApiContractState(state: node.ContractState, getContractByCodeHash: (codeHash: string) => Contract): ContractState;
     static ContractCreatedEventIndex: number;
     static ContractCreatedEvent: EventSig;
     static ContractDestroyedEventIndex: number;
     static ContractDestroyedEvent: EventSig;
-    static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined, txId: string, getContractByCodeHash?: (codeHash: string) => Contract): ContractEvent;
-    fromApiTestContractResult(methodName: string, result: node.TestContractResult, txId: string): TestContractResult<unknown>;
+    static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined, txId: string, getContractByCodeHash: (codeHash: string) => Contract): ContractEvent;
+    fromApiTestContractResult(methodName: string, result: node.TestContractResult, txId: string, getContractByCodeHash: (codeHash: string) => Contract): TestContractResult<unknown>;
     txParamsForDeployment<P extends Fields>(signer: SignerProvider, params: DeployContractParams<P>): Promise<SignDeployContractTxParams>;
     buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean): string;
-    static fromApiEvents(events: node.ContractEventByTxId[], addressToCodeHash: Map<string, string>, txId: string, getContractByCodeHash?: (codeHash: string) => Contract): ContractEvent[];
+    static fromApiEvents(events: node.ContractEventByTxId[], addressToCodeHash: Map<string, string>, txId: string, getContractByCodeHash: (codeHash: string) => Contract): ContractEvent[];
     toApiCallContract<T extends Arguments>(params: CallContractParams<T>, groupIndex: number, contractAddress: string, methodIndex: number): node.CallContract;
-    fromApiCallContractResult(result: node.CallContractResult, txId: string, methodIndex: number, getContractByCodeHash?: (codeHash: string) => Contract): CallContractResult<unknown>;
+    fromApiCallContractResult(result: node.CallContractResult, txId: string, methodIndex: number, getContractByCodeHash: (codeHash: string) => Contract): CallContractResult<unknown>;
 }
 export declare class Script extends Artifact {
     readonly bytecodeTemplate: string;
@@ -324,7 +238,7 @@ export declare function subscribeEventsFromContract<T extends Fields, M extends
 export declare function addStdIdToFields<F extends Fields>(contract: Contract, fields: F): F | (F & {
     __stdInterfaceId: HexString;
 });
-export declare function testMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R, M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>>(factory: ContractFactory<I, F>, methodName: string, params: Optional<TestContractParams<F, A, M>, 'testArgs' | 'initialFields'>): Promise<TestContractResult<R, M>>;
+export declare function testMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R, M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>>(factory: ContractFactory<I, F>, methodName: string, params: Optional<TestContractParams<F, A, M>, 'testArgs' | 'initialFields'>, getContractByCodeHash: (codeHash: string) => Contract): Promise<TestContractResult<R, M>>;
 export declare class RalphMap<K extends Val, V extends Val> {
     private readonly parentContract;
     private readonly parentContractId;
@@ -352,9 +266,8 @@ export declare function subscribeContractDestroyedEvent(options: EventSubscribeO
 export declare function decodeEvent<F extends Fields, M extends ContractEvent<F>>(contract: Contract, instance: ContractInstance, event: node.ContractEvent, targetEventIndex: number): M;
 export declare function subscribeContractEvent<F extends Fields, M extends ContractEvent<F>>(contract: Contract, instance: ContractInstance, options: EventSubscribeOptions<M>, eventName: string, fromCount?: number): EventSubscription;
 export declare function subscribeContractEvents(contract: Contract, instance: ContractInstance, options: EventSubscribeOptions<ContractEvent<any>>, fromCount?: number): EventSubscription;
-export declare function callMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<CallContractParams<A>, 'args'>, getContractByCodeHash?: (codeHash: string) => Contract): Promise<CallContractResult<R>>;
-export declare function multicallMethods<I extends ContractInstance, F extends Fields>(contract: ContractFactory<I, F>, instance: ContractInstance, calls: Record<string, Optional<CallContractParams<any>, 'args'>>, getContractByCodeHash?: (codeHash: string) => Contract): Promise<Record<string, CallContractResult<any>>>;
+export declare function callMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<CallContractParams<A>, 'args'>, getContractByCodeHash: (codeHash: string) => Contract): Promise<CallContractResult<R>>;
+export declare function multicallMethods<I extends ContractInstance, F extends Fields>(contract: ContractFactory<I, F>, instance: ContractInstance, calls: Record<string, Optional<CallContractParams<any>, 'args'>>, getContractByCodeHash: (codeHash: string) => Contract): Promise<Record<string, CallContractResult<any>>>;
 export declare function getContractEventsCurrentCount(contractAddress: Address): Promise<number>;
 export declare const getContractIdFromUnsignedTx: (nodeProvider: NodeProvider, unsignedTx: string) => Promise<HexString>;
 export declare const getTokenIdFromUnsignedTx: (nodeProvider: NodeProvider, unsignedTx: string) => Promise<HexString>;
-export {};