@alephium/web3 0.40.0 → 0.42.0

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

@@ -2,68 +2,21 @@ import { NamedVals, node, NodeProvider, Number256, Token, Val } from '../api';
 import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignerProvider, Address } from '../signer';
 import { Optional, HexString } from '../utils';
 import { EventSubscribeOptions, EventSubscription } from './events';
+import { Method } from '../codec';
 export type FieldsSig = node.FieldsSig;
 export type MapsSig = node.MapsSig;
 export type EventSig = node.EventSig;
-export type FunctionSig = node.FunctionSig;
+export type FunctionSig = Omit<node.FunctionSig, 'isPublic' | 'usePreapprovedAssets' | 'useAssetsInContract'>;
 export type Fields = NamedVals;
 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>;
-    needToReCompile(compilerOptions: node.CompilerOptions, sourceInfos: SourceInfo[], fullNodeVersion: string): boolean;
-    static from(rootPath: string): Promise<ProjectArtifact | undefined>;
-}
 export declare class Struct {
     name: string;
     fieldNames: string[];
@@ -74,51 +27,12 @@ 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;
-    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): Promise<void>;
-}
 export declare abstract class Artifact {
     readonly version: string;
     readonly name: string;
     readonly functions: FunctionSig[];
     constructor(version: string, name: string, functions: FunctionSig[]);
     abstract buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean): string;
-    publicFunctions(): string[];
-    usingPreapprovedAssetsFunctions(): string[];
-    usingAssetsInContractFunctions(): string[];
     isDevnet(signer: SignerProvider): Promise<boolean>;
 }
 export declare class Contract extends Artifact {
@@ -134,7 +48,11 @@ export declare class Contract extends Artifact {
     readonly stdInterfaceId?: HexString;
     readonly bytecodeDebug: string;
     readonly codeHashDebug: string;
+    readonly decodedMethods: Method[];
     constructor(version: string, name: string, bytecode: string, bytecodeDebugPatch: string, codeHash: string, codeHashDebug: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[], constants: Constant[], enums: Enum[], structs: Struct[], mapsSig?: MapsSig, stdInterfaceId?: HexString);
+    publicFunctions(): FunctionSig[];
+    usingPreapprovedAssetsFunctions(): FunctionSig[];
+    usingAssetsInContractFunctions(): FunctionSig[];
     static fromJson(artifact: any, bytecodeDebugPatch?: string, codeHashDebug?: string, structs?: Struct[]): Contract;
     static fromCompileResult(result: node.CompileContractResult, structs?: Struct[]): Contract;
     static fromArtifactFile(path: string, bytecodeDebugPatch: string, codeHashDebug: string, structs?: Struct[]): Promise<Contract>;
@@ -149,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;
@@ -320,16 +238,22 @@ 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 parentInstance;
+    private readonly parentContractId;
     private readonly mapName;
-    constructor(parentContract: Contract, parentInstance: ContractInstance, mapName: string);
+    private readonly groupIndex;
+    constructor(parentContract: Contract, parentContractId: HexString, mapName: string);
     get(key: K): Promise<V | undefined>;
     contains(key: K): Promise<boolean>;
+    toJSON(): {
+        parentContractId: string;
+        mapName: string;
+        groupIndex: number;
+    };
 }
-export declare function getMapItem<R extends Val>(parentContract: Contract, parentInstance: ContractInstance, mapName: string, key: Val): Promise<R | undefined>;
+export declare function getMapItem<R extends Val>(parentContract: Contract, parentContractId: HexString, groupIndex: number, mapName: string, key: Val): Promise<R | undefined>;
 export declare abstract class ContractInstance {
     readonly address: Address;
     readonly contractId: string;
@@ -342,10 +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 declare function tryGetCallResult(result: node.CallContractResult): node.CallContractSucceeded;
-export {};