@alephium/web3 0.39.3 → 0.41.0

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

@@ -2,10 +2,11 @@ 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;
@@ -61,7 +62,8 @@ export declare class ProjectArtifact {
     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;
+    getChangedSources(sourceInfos: SourceInfo[]): SourceInfo[];
+    needToReCompile(compilerOptions: node.CompilerOptions, fullNodeVersion: string): boolean;
     static from(rootPath: string): Promise<ProjectArtifact | undefined>;
 }
 export declare class Struct {
@@ -98,6 +100,7 @@ export declare class Project {
     private static loadStructs;
     private saveStructsToFile;
     private saveArtifactsToFile;
+    private saveProjectArtifact;
     contractByCodeHash(codeHash: string): Contract;
     private static getCompileResult;
     private static compile;
@@ -108,7 +111,7 @@ export declare class Project {
     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>;
+    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;
@@ -116,9 +119,6 @@ export declare abstract class Artifact {
     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 +134,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>;
@@ -321,6 +325,21 @@ export declare function addStdIdToFields<F extends Fields>(contract: Contract, 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 class RalphMap<K extends Val, V extends Val> {
+    private readonly parentContract;
+    private readonly parentContractId;
+    private readonly mapName;
+    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, parentContractId: HexString, groupIndex: number, mapName: string, key: Val): Promise<R | undefined>;
 export declare abstract class ContractInstance {
     readonly address: Address;
     readonly contractId: string;
@@ -338,5 +357,4 @@ export declare function multicallMethods<I extends ContractInstance, F extends F
 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 {};

package/dist/src/contract/contract.js

@@ -43,7 +43,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryGetCallResult = exports.getTokenIdFromUnsignedTx = exports.getContractIdFromUnsignedTx = exports.getContractEventsCurrentCount = exports.multicallMethods = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.testMethod = exports.addStdIdToFields = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.DestroyContractEventAddresses = exports.CreateContractEventAddresses = exports.ExecutableScript = exports.ContractFactory = exports.randomTxId = exports.fromApiEventFields = exports.fromApiArray = exports.getDefaultValue = exports.fromApiFields = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.Struct = exports.ProjectArtifact = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = exports.StdIdFieldName = void 0;
+exports.getTokenIdFromUnsignedTx = exports.getContractIdFromUnsignedTx = exports.getContractEventsCurrentCount = exports.multicallMethods = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.getMapItem = exports.RalphMap = exports.testMethod = exports.addStdIdToFields = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.DestroyContractEventAddresses = exports.CreateContractEventAddresses = exports.ExecutableScript = exports.ContractFactory = exports.randomTxId = exports.fromApiEventFields = exports.fromApiArray = exports.getDefaultValue = exports.fromApiFields = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.Struct = exports.ProjectArtifact = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = exports.StdIdFieldName = void 0;
 const buffer_1 = require("buffer/");
 const fs_1 = __importDefault(require("fs"));
 const fs_2 = require("fs");
@@ -180,7 +180,17 @@ class ProjectArtifact {
         const content = JSON.stringify(artifact, null, 2);
         return fs_2.promises.writeFile(filepath, content);
     }
-    needToReCompile(compilerOptions, sourceInfos, fullNodeVersion) {
+    getChangedSources(sourceInfos) {
+        const result = [];
+        for (const sourceInfo of sourceInfos) {
+            const info = this.infos.get(sourceInfo.name);
+            if (typeof info === 'undefined' || info.sourceCodeHash !== sourceInfo.sourceCodeHash) {
+                result.push(sourceInfo);
+            }
+        }
+        return result;
+    }
+    needToReCompile(compilerOptions, fullNodeVersion) {
         ProjectArtifact.checkCompilerOptionsParameter(compilerOptions);
         if (this.fullNodeVersion !== fullNodeVersion) {
             return true;
@@ -192,15 +202,6 @@ class ProjectArtifact {
         if (!optionsMatched) {
             return true;
         }
-        if (sourceInfos.length !== this.infos.size) {
-            return true;
-        }
-        for (const sourceInfo of sourceInfos) {
-            const info = this.infos.get(sourceInfo.name);
-            if (typeof info === 'undefined' || info.sourceCodeHash !== sourceInfo.sourceCodeHash) {
-                return true;
-            }
-        }
         return false;
     }
     static async from(rootPath) {
@@ -224,16 +225,21 @@ class ProjectArtifact {
 }
 exports.ProjectArtifact = ProjectArtifact;
 ProjectArtifact.artifactFileName = '.project.json';
-function removeOldArtifacts(dir) {
+function removeOldArtifacts(dir, sourceFiles) {
     const files = fs_1.default.readdirSync(dir);
     files.forEach((file) => {
         const filePath = path.join(dir, file);
         const stat = fs_1.default.statSync(filePath);
         if (stat.isDirectory()) {
-            removeOldArtifacts(filePath);
+            removeOldArtifacts(filePath, sourceFiles);
         }
         else if (filePath.endsWith('.ral.json') || filePath.endsWith('.ral')) {
-            fs_1.default.unlinkSync(filePath);
+            const filename = path.basename(filePath);
+            const artifactName = filename.slice(0, filename.indexOf('.'));
+            const sourceFile = sourceFiles.find((s) => s.name === artifactName && (s.type === SourceKind.Contract || s.type === SourceKind.Script));
+            if (sourceFile === undefined) {
+                fs_1.default.unlinkSync(filePath);
+            }
         }
     });
     if (fs_1.default.readdirSync(dir).length === 0) {
@@ -359,7 +365,7 @@ class Project {
         const filePath = path.join(this.artifactsRootDir, 'structs.ral.json');
         return fs_2.promises.writeFile(filePath, JSON.stringify(structs, null, 2));
     }
-    async saveArtifactsToFile(projectRootDir) {
+    async saveArtifactsToFile(projectRootDir, skipSaveArtifacts, changedSources) {
         const artifactsRootDir = this.artifactsRootDir;
         const saveToFile = async function (compiled) {
             const artifactPath = compiled.sourceInfo.getArtifactPath(artifactsRootDir);
@@ -369,9 +375,31 @@ class Project {
             }
             return fs_2.promises.writeFile(artifactPath, compiled.artifact.toString());
         };
-        this.contracts.forEach((contract) => saveToFile(contract));
-        this.scripts.forEach((script) => saveToFile(script));
-        this.saveStructsToFile();
+        for (const [_, contract] of this.contracts) {
+            if (!skipSaveArtifacts || changedSources.find((s) => s.name === contract.sourceInfo.name) !== undefined) {
+                await saveToFile(contract);
+            }
+        }
+        for (const [_, script] of this.scripts) {
+            await saveToFile(script);
+        }
+        await this.saveStructsToFile();
+        await this.saveProjectArtifact(projectRootDir, skipSaveArtifacts, changedSources);
+    }
+    async saveProjectArtifact(projectRootDir, skipSaveArtifacts, changedSources) {
+        if (skipSaveArtifacts) {
+            // we should not update the `codeHashDebug` if the `skipSaveArtifacts` is enabled
+            const prevProjectArtifact = await ProjectArtifact.from(projectRootDir);
+            if (prevProjectArtifact !== undefined) {
+                for (const [name, info] of this.projectArtifact.infos) {
+                    if (changedSources.find((s) => s.name === name) === undefined) {
+                        const prevInfo = prevProjectArtifact.infos.get(name);
+                        info.bytecodeDebugPatch = prevInfo?.bytecodeDebugPatch ?? info.bytecodeDebugPatch;
+                        info.codeHashDebug = prevInfo?.codeHashDebug ?? info.codeHashDebug;
+                    }
+                }
+            }
+        }
         await this.projectArtifact.saveToFile(projectRootDir);
     }
     contractByCodeHash(codeHash) {
@@ -406,7 +434,7 @@ class Project {
             throw new Error(newError);
         }
     }
-    static async compile(fullNodeVersion, provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
+    static async compile(fullNodeVersion, provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions, changedSources, skipSaveArtifacts = false) {
         const removeDuplicates = sourceInfos.reduce((acc, sourceInfo) => {
             if (acc.find((info) => info.sourceCodeHash === sourceInfo.sourceCodeHash) === undefined) {
                 acc.push(sourceInfo);
@@ -437,10 +465,14 @@ class Project {
         });
         const projectArtifact = Project.buildProjectArtifact(fullNodeVersion, sourceInfos, contracts, scripts, compilerOptions);
         const project = new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, structs, errorOnWarnings, projectArtifact);
-        await project.saveArtifactsToFile(projectRootDir);
+        await project.saveArtifactsToFile(projectRootDir, skipSaveArtifacts, changedSources);
         return project;
     }
-    static async loadArtifacts(provider, sourceInfos, projectArtifact, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
+    static async loadArtifacts(provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
+        const projectArtifact = await ProjectArtifact.from(projectRootDir);
+        if (projectArtifact === undefined) {
+            throw Error('Failed to load project artifact');
+        }
         try {
             const contracts = new Map();
             const scripts = new Map();
@@ -465,7 +497,7 @@ class Project {
         }
         catch (error) {
             console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`);
-            return Project.compile(projectArtifact.fullNodeVersion, provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
+            return Project.compile(projectArtifact.fullNodeVersion, provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions, sourceInfos);
         }
     }
     static getImportSourcePath(projectRootDir, importPath) {
@@ -550,24 +582,24 @@ class Project {
         }
         return sourceInfos.sort((a, b) => a.type - b.type);
     }
-    static async build(compilerOptionsPartial = {}, projectRootDir = '.', contractsRootDir = Project.DEFAULT_CONTRACTS_DIR, artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR, defaultFullNodeVersion = undefined) {
+    static async build(compilerOptionsPartial = {}, projectRootDir = '.', contractsRootDir = Project.DEFAULT_CONTRACTS_DIR, artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR, defaultFullNodeVersion = undefined, skipSaveArtifacts = false) {
         const provider = (0, global_1.getCurrentNodeProvider)();
         const fullNodeVersion = defaultFullNodeVersion ?? (await provider.infos.getInfosVersion()).version;
         const sourceFiles = await Project.loadSourceFiles(projectRootDir, contractsRootDir);
         const { errorOnWarnings, ...nodeCompilerOptions } = { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial };
         const projectArtifact = await ProjectArtifact.from(projectRootDir);
+        const changedSources = projectArtifact?.getChangedSources(sourceFiles) ?? sourceFiles;
         if (projectArtifact === undefined ||
-            projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles, fullNodeVersion)) {
+            projectArtifact.needToReCompile(nodeCompilerOptions, fullNodeVersion) ||
+            changedSources.length > 0) {
             if (fs_1.default.existsSync(artifactsRootDir)) {
-                removeOldArtifacts(artifactsRootDir);
+                removeOldArtifacts(artifactsRootDir, sourceFiles);
             }
             console.log(`Compiling contracts in folder "${contractsRootDir}"`);
-            Project.currentProject = await Project.compile(fullNodeVersion, provider, sourceFiles, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
-        }
-        else {
-            console.log(`Contracts are compiled already. Loading them from folder "${artifactsRootDir}"`);
-            Project.currentProject = await Project.loadArtifacts(provider, sourceFiles, projectArtifact, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
+            Project.currentProject = await Project.compile(fullNodeVersion, provider, sourceFiles, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions, changedSources, skipSaveArtifacts);
         }
+        // we need to reload those contracts that did not regenerate bytecode
+        Project.currentProject = await Project.loadArtifacts(provider, sourceFiles, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
     }
 }
 exports.Project = Project;
@@ -592,15 +624,6 @@ class Artifact {
         this.name = name;
         this.functions = functions;
     }
-    publicFunctions() {
-        return this.functions.filter((func) => func.isPublic).map((func) => func.name);
-    }
-    usingPreapprovedAssetsFunctions() {
-        return this.functions.filter((func) => func.usePreapprovedAssets).map((func) => func.name);
-    }
-    usingAssetsInContractFunctions() {
-        return this.functions.filter((func) => func.useAssetsInContract).map((func) => func.name);
-    }
     async isDevnet(signer) {
         if (!signer.nodeProvider) {
             return false;
@@ -610,6 +633,15 @@ class Artifact {
     }
 }
 exports.Artifact = Artifact;
+function fromFunctionSig(sig) {
+    return {
+        name: sig.name,
+        paramNames: sig.paramNames,
+        paramTypes: sig.paramTypes,
+        paramIsMutable: sig.paramIsMutable,
+        returnTypes: sig.returnTypes
+    };
+}
 class Contract extends Artifact {
     constructor(version, name, bytecode, bytecodeDebugPatch, codeHash, codeHashDebug, fieldsSig, eventsSig, functions, constants, enums, structs, mapsSig, stdInterfaceId) {
         super(version, name, functions);
@@ -625,6 +657,16 @@ class Contract extends Artifact {
         this.stdInterfaceId = stdInterfaceId;
         this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch);
         this.codeHashDebug = codeHashDebug;
+        this.decodedMethods = codec_1.contract.contractCodec.decodeContract(buffer_1.Buffer.from(bytecode, 'hex')).methods;
+    }
+    publicFunctions() {
+        return this.functions.filter((_, index) => this.decodedMethods[`${index}`].isPublic);
+    }
+    usingPreapprovedAssetsFunctions() {
+        return this.functions.filter((_, index) => this.decodedMethods[`${index}`].usePreapprovedAssets);
+    }
+    usingAssetsInContractFunctions() {
+        return this.functions.filter((_, index) => this.decodedMethods[`${index}`].useContractAssets);
     }
     // TODO: safely parse json
     static fromJson(artifact, bytecodeDebugPatch = '', codeHashDebug = '', structs = []) {
@@ -643,7 +685,7 @@ class Contract extends Artifact {
         return contract;
     }
     static fromCompileResult(result, structs = []) {
-        return new Contract(result.version, result.name, result.bytecode, result.bytecodeDebugPatch, result.codeHash, result.codeHashDebug, result.fields, result.events, result.functions, result.constants, result.enums, structs, result.maps, result.stdInterfaceId);
+        return new Contract(result.version, result.name, result.bytecode, result.bytecodeDebugPatch, result.codeHash, result.codeHashDebug, result.fields, result.events, result.functions.map(fromFunctionSig), result.constants, result.enums, structs, result.maps, result.stdInterfaceId);
     }
     // support both 'code.ral' and 'code.ral.json'
     static async fromArtifactFile(path, bytecodeDebugPatch, codeHashDebug, structs = []) {
@@ -871,7 +913,7 @@ class Contract extends Artifact {
     }
     fromApiCallContractResult(result, txId, methodIndex, getContractByCodeHash) {
         const returnTypes = this.functions[`${methodIndex}`].returnTypes;
-        const callResult = tryGetCallResult(result);
+        const callResult = (0, api_1.tryGetCallResult)(result);
         const rawReturn = fromApiArray(callResult.returns, returnTypes, this.structs);
         const returns = rawReturn.length === 0 ? null : rawReturn.length === 1 ? rawReturn[0] : rawReturn;
         const addressToCodeHash = new Map();
@@ -909,7 +951,7 @@ class Script extends Artifact {
         this.structs = structs;
     }
     static fromCompileResult(result, structs = []) {
-        return new Script(result.version, result.name, result.bytecodeTemplate, result.bytecodeDebugPatch, result.fields, result.functions, structs);
+        return new Script(result.version, result.name, result.bytecodeTemplate, result.bytecodeDebugPatch, result.fields, result.functions.map(fromFunctionSig), structs);
     }
     // TODO: safely parse json
     static fromJson(artifact, bytecodeDebugPatch = '', structs = []) {
@@ -1215,7 +1257,9 @@ function genCodeForType(type, structs) {
     const { immFields, mutFields } = ralph.calcFieldSize(type, true, structs);
     const loadImmFieldByIndex = {
         isPublic: true,
-        assetModifier: 0,
+        usePreapprovedAssets: false,
+        useContractAssets: false,
+        usePayToContractOnly: false,
         argsLength: 1,
         localsLength: 1,
         returnLength: 1,
@@ -1243,7 +1287,9 @@ function genCodeForType(type, structs) {
     };
     const destroy = {
         isPublic: true,
-        assetModifier: 2,
+        usePreapprovedAssets: false,
+        useContractAssets: true,
+        usePayToContractOnly: false,
         argsLength: 1,
         localsLength: 1,
         returnLength: 0,
@@ -1321,6 +1367,52 @@ async function testMethod(factory, methodName, params) {
     };
 }
 exports.testMethod = testMethod;
+class RalphMap {
+    constructor(parentContract, parentContractId, mapName) {
+        this.parentContract = parentContract;
+        this.parentContractId = parentContractId;
+        this.mapName = mapName;
+        this.groupIndex = (0, utils_1.groupOfAddress)((0, utils_1.addressFromContractId)(parentContractId));
+    }
+    async get(key) {
+        return getMapItem(this.parentContract, this.parentContractId, this.groupIndex, this.mapName, key);
+    }
+    async contains(key) {
+        return this.get(key).then((v) => v !== undefined);
+    }
+    toJSON() {
+        return {
+            parentContractId: this.parentContractId,
+            mapName: this.mapName,
+            groupIndex: this.groupIndex
+        };
+    }
+}
+exports.RalphMap = RalphMap;
+async function getMapItem(parentContract, parentContractId, groupIndex, mapName, key) {
+    const index = parentContract.mapsSig?.names.findIndex((name) => name === mapName);
+    const mapType = index === undefined ? undefined : parentContract.mapsSig?.types[`${index}`];
+    if (mapType === undefined) {
+        throw new Error(`Map ${mapName} does not exist in contract ${parentContract.name}`);
+    }
+    const [keyType, valueType] = ralph.parseMapType(mapType);
+    const mapItemContractId = calcWrapperContractId(parentContractId, index, key, keyType, groupIndex);
+    const mapItemAddress = (0, utils_1.addressFromContractId)(mapItemContractId);
+    try {
+        const state = await (0, global_1.getCurrentNodeProvider)().contracts.getContractsAddressState(mapItemAddress);
+        const fieldsSig = getContractFieldsSig(valueType);
+        const fields = fromApiFields(state.immFields, state.mutFields, fieldsSig, parentContract.structs);
+        return fields['value'];
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('KeyNotFound')) {
+            // the map item contract does not exist
+            return undefined;
+        }
+        throw error;
+    }
+}
+exports.getMapItem = getMapItem;
 function buildMapInfo(contract, fields) {
     const mapsSig = contract.mapsSig;
     if (mapsSig === undefined)
@@ -1524,10 +1616,3 @@ const getContractIdFromUnsignedTx = async (nodeProvider, unsignedTx) => {
 exports.getContractIdFromUnsignedTx = getContractIdFromUnsignedTx;
 // This function only works in the simple case where a single non-subcontract is created in the tx
 exports.getTokenIdFromUnsignedTx = exports.getContractIdFromUnsignedTx;
-function tryGetCallResult(result) {
-    if (result.type === 'CallContractFailed') {
-        throw new Error(`Failed to call contract, error: ${result.error}`);
-    }
-    return result;
-}
-exports.tryGetCallResult = tryGetCallResult;

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

@@ -1,14 +1,13 @@
 import { node } from '../api';
 import { Subscription, SubscribeOptions } from '../utils';
 export interface EventSubscribeOptions<Message> extends SubscribeOptions<Message> {
-    onEventCountChanged?: (eventCount: number) => Promise<void>;
+    onEventCountChanged?: (eventCount: number) => Promise<void> | void;
 }
 export declare class EventSubscription extends Subscription<node.ContractEvent> {
     readonly contractAddress: string;
     private fromCount;
     private onEventCountChanged?;
     constructor(options: EventSubscribeOptions<node.ContractEvent>, contractAddress: string, fromCount?: number);
-    startPolling(): void;
     currentEventCount(): number;
     polling(): Promise<void>;
 }

package/dist/src/contract/events.js

@@ -16,9 +16,32 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 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;
+    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];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.subscribeToEvents = exports.EventSubscription = void 0;
-const __1 = require("..");
+const web3 = __importStar(require("../global"));
 const utils_1 = require("../utils");
 class EventSubscription extends utils_1.Subscription {
     constructor(options, contractAddress, fromCount) {
@@ -26,27 +49,16 @@ class EventSubscription extends utils_1.Subscription {
         this.contractAddress = contractAddress;
         this.fromCount = typeof fromCount === 'undefined' ? 0 : fromCount;
         this.onEventCountChanged = options.onEventCountChanged;
-        this.startPolling();
-    }
-    startPolling() {
-        this.eventEmitter.on('tick', async () => {
-            await this.polling();
-        });
-        this.eventEmitter.emit('tick');
     }
     currentEventCount() {
         return this.fromCount;
     }
     async polling() {
         try {
-            const events = await __1.web3.getCurrentNodeProvider().events.getEventsContractContractaddress(this.contractAddress, {
+            const events = await web3.getCurrentNodeProvider().events.getEventsContractContractaddress(this.contractAddress, {
                 start: this.fromCount
             });
-            if (this.cancelled) {
-                return;
-            }
             if (this.fromCount === events.nextStart) {
-                this.task = setTimeout(() => this.eventEmitter.emit('tick'), this.pollingInterval);
                 return;
             }
             const promises = events.events.map((event) => this.messageCallback(event));
@@ -64,6 +76,8 @@ class EventSubscription extends utils_1.Subscription {
 }
 exports.EventSubscription = EventSubscription;
 function subscribeToEvents(options, contractAddress, fromCount) {
-    return new EventSubscription(options, contractAddress, fromCount);
+    const subscription = new EventSubscription(options, contractAddress, fromCount);
+    subscription.subscribe();
+    return subscription;
 }
 exports.subscribeToEvents = subscribeToEvents;

package/dist/src/index.d.ts

@@ -9,3 +9,4 @@ export * as web3 from './global';
 export * as codec from './codec';
 export * as utils from './utils';
 export * from './debug';
+export * from './block';

package/dist/src/index.js

@@ -58,3 +58,4 @@ exports.web3 = __importStar(require("./global"));
 exports.codec = __importStar(require("./codec"));
 exports.utils = __importStar(require("./utils"));
 __exportStar(require("./debug"), exports);
+__exportStar(require("./block"), exports);

package/dist/src/signer/tx-builder.js

@@ -18,9 +18,9 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionBuilder = void 0;
-const __1 = require("..");
-const api_1 = require("../api");
 const utils_1 = require("../utils");
+const api_1 = require("../api");
+const utils_2 = require("../utils");
 const signer_1 = require("./signer");
 class TransactionBuilder {
     static from(param0, param1, customFetch) {
@@ -32,7 +32,7 @@ class TransactionBuilder {
         })();
     }
     static validatePublicKey(params, publicKey, keyType) {
-        const address = (0, utils_1.addressFromPublicKey)(publicKey, keyType);
+        const address = (0, utils_2.addressFromPublicKey)(publicKey, keyType);
         if (address !== params.signerAddress) {
             throw new Error('Unmatched public key');
         }
@@ -63,7 +63,7 @@ class TransactionBuilder {
             ...rest
         };
         const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data);
-        const contractId = __1.utils.binToHex(__1.utils.contractIdFromAddress(response.contractAddress));
+        const contractId = (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(response.contractAddress));
         return { ...response, groupIndex: response.fromGroup, contractId, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
     async buildExecuteScriptTx(params, publicKey) {

package/dist/src/transaction/status.js

@@ -16,9 +16,32 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 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;
+    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];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.subscribeToTxStatus = exports.TxStatusSubscription = void 0;
-const __1 = require("..");
+const web3 = __importStar(require("../global"));
 const utils_1 = require("../utils");
 class TxStatusSubscription extends utils_1.Subscription {
     constructor(options, txId, fromGroup, toGroup, confirmations) {
@@ -27,11 +50,10 @@ class TxStatusSubscription extends utils_1.Subscription {
         this.fromGroup = fromGroup;
         this.toGroup = toGroup;
         this.confirmations = confirmations ?? 1;
-        this.startPolling();
     }
     async polling() {
         try {
-            const txStatus = await __1.web3.getCurrentNodeProvider().transactions.getTransactionsStatus({
+            const txStatus = await web3.getCurrentNodeProvider().transactions.getTransactionsStatus({
                 txId: this.txId,
                 fromGroup: this.fromGroup,
                 toGroup: this.toGroup
@@ -48,6 +70,8 @@ class TxStatusSubscription extends utils_1.Subscription {
 }
 exports.TxStatusSubscription = TxStatusSubscription;
 function subscribeToTxStatus(options, txId, fromGroup, toGroup, confirmations) {
-    return new TxStatusSubscription(options, txId, fromGroup, toGroup, confirmations);
+    const subscription = new TxStatusSubscription(options, txId, fromGroup, toGroup, confirmations);
+    subscription.subscribe();
+    return subscription;
 }
 exports.subscribeToTxStatus = subscribeToTxStatus;