@alephium/web3 0.4.0 → 0.5.0-rc.1

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.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = void 0;
+exports.callMethod = exports.subscribeAllEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.testMethod = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.ContractFactory = exports.randomTxId = exports.toApiVals = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = void 0;
 const buffer_1 = require("buffer/");
 const crypto_1 = require("crypto");
 const fs_1 = __importDefault(require("fs"));
@@ -52,8 +52,9 @@ const api_1 = require("../api");
 const ralph = __importStar(require("./ralph"));
 const utils_1 = require("../utils");
 const global_1 = require("../global");
-const __1 = require("..");
 const path = __importStar(require("path"));
+const events_1 = require("./events");
+const constants_1 = require("../constants");
 var SourceKind;
 (function (SourceKind) {
     SourceKind[SourceKind["Contract"] = 0] = "Contract";
@@ -249,7 +250,7 @@ class Project {
         }
         return script.artifact;
     }
-    async saveArtifactsToFile() {
+    async saveArtifactsToFile(projectRootDir) {
         const artifactsRootDir = this.artifactsRootDir;
         const saveToFile = async function (compiled) {
             const artifactPath = compiled.sourceInfo.getArtifactPath(artifactsRootDir);
@@ -261,7 +262,7 @@ class Project {
         };
         this.contracts.forEach((contract) => saveToFile(contract));
         this.scripts.forEach((script) => saveToFile(script));
-        await this.projectArtifact.saveToFile(this.artifactsRootDir);
+        await this.projectArtifact.saveToFile(projectRootDir);
     }
     contractByCodeHash(codeHash) {
         const contract = [...this.contracts.values()].find((c) => c.artifact.codeHash === codeHash || c.artifact.codeHashDebug == codeHash);
@@ -270,7 +271,7 @@ class Project {
         }
         return contract.artifact;
     }
-    static async compile(provider, sourceInfos, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
+    static async compile(provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
         const sourceStr = sourceInfos.map((f) => f.sourceCode).join('\n');
         const result = await provider.contracts.postContractsCompileProject({
             code: sourceStr,
@@ -290,10 +291,10 @@ class Project {
         });
         const projectArtifact = Project.buildProjectArtifact(sourceInfos, contracts, scripts, compilerOptions);
         const project = new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, errorOnWarnings, projectArtifact);
-        await project.saveArtifactsToFile();
+        await project.saveArtifactsToFile(projectRootDir);
         return project;
     }
-    static async loadArtifacts(provider, sourceInfos, projectArtifact, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
+    static async loadArtifacts(provider, sourceInfos, projectArtifact, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
         try {
             const contracts = new Map();
             const scripts = new Map();
@@ -317,7 +318,7 @@ class Project {
         }
         catch (error) {
             console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`);
-            return Project.compile(provider, sourceInfos, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
+            return Project.compile(provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
         }
     }
     static getImportSourcePath(projectRootDir, importPath) {
@@ -406,14 +407,14 @@ class Project {
         const provider = (0, global_1.getCurrentNodeProvider)();
         const sourceFiles = await Project.loadSourceFiles(projectRootDir, contractsRootDir);
         const { errorOnWarnings, ...nodeCompilerOptions } = { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial };
-        const projectArtifact = await ProjectArtifact.from(artifactsRootDir);
+        const projectArtifact = await ProjectArtifact.from(projectRootDir);
         if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {
             console.log(`Compiling contracts in folder "${contractsRootDir}"`);
-            Project.currentProject = await Project.compile(provider, sourceFiles, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
+            Project.currentProject = await Project.compile(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, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
+            Project.currentProject = await Project.loadArtifacts(provider, sourceFiles, projectArtifact, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
         }
     }
 }
@@ -482,12 +483,6 @@ class Contract extends Artifact {
         const artifact = JSON.parse(content.toString());
         return Contract.fromJson(artifact, bytecodeDebugPatch, codeHashDebug);
     }
-    async fetchState(address, group) {
-        const state = await __1.web3.getCurrentNodeProvider().contracts.getContractsAddressState(address, {
-            group: group
-        });
-        return this.fromApiContractState(state);
-    }
     toString() {
         const object = {
             version: this.version,
@@ -519,34 +514,12 @@ class Contract extends Artifact {
         bytes[0] = 3;
         return utils_1.bs58.encode(bytes);
     }
-    _printDebugMessages(funcName, messages) {
+    printDebugMessages(funcName, messages) {
         if (messages.length != 0) {
             console.log(`Testing ${this.name}.${funcName}:`);
             messages.forEach((m) => console.log(`Debug - ${m.contractAddress} - ${m.message}`));
         }
     }
-    async _test(funcName, params, expectPublic, accessType, printDebugMessages) {
-        const apiParams = this.toTestContract(funcName, params);
-        const apiResult = await __1.web3.getCurrentNodeProvider().contracts.postContractsTestContract(apiParams);
-        const methodIndex = typeof params.testMethodIndex !== 'undefined' ? params.testMethodIndex : this.getMethodIndex(funcName);
-        const isPublic = this.functions[`${methodIndex}`].isPublic;
-        if (printDebugMessages) {
-            this._printDebugMessages(funcName, apiResult.debugMessages);
-        }
-        if (isPublic === expectPublic) {
-            const result = await this.fromTestContractResult(methodIndex, apiResult);
-            return result;
-        }
-        else {
-            throw new Error(`The test method ${funcName} is not ${accessType}`);
-        }
-    }
-    async testPublicMethod(funcName, params, printDebugMessages = true) {
-        return this._test(funcName, params, true, 'public', printDebugMessages);
-    }
-    async testPrivateMethod(funcName, params, printDebugMessages = true) {
-        return this._test(funcName, params, false, 'private', printDebugMessages);
-    }
     toApiFields(fields) {
         if (typeof fields === 'undefined') {
             return [];
@@ -573,12 +546,15 @@ class Contract extends Artifact {
     toApiContractStates(states) {
         return typeof states != 'undefined' ? states.map((state) => toApiContractState(state)) : undefined;
     }
-    toTestContract(funcName, params) {
+    toApiTestContractParams(funcName, params) {
+        const immFields = params.initialFields === undefined ? [] : extractFields(params.initialFields, this.fieldsSig, false);
+        const mutFields = params.initialFields === undefined ? [] : extractFields(params.initialFields, this.fieldsSig, true);
         return {
             group: params.group,
             address: params.address,
             bytecode: this.bytecodeDebug,
-            initialFields: this.toApiFields(params.initialFields),
+            initialImmFields: immFields,
+            initialMutFields: mutFields,
             initialAsset: typeof params.initialAsset !== 'undefined' ? toApiAsset(params.initialAsset) : undefined,
             methodIndex: this.getMethodIndex(funcName),
             args: this.toApiArgs(funcName, params.testArgs),
@@ -593,7 +569,7 @@ class Contract extends Artifact {
             bytecode: state.bytecode,
             initialStateHash: state.initialStateHash,
             codeHash: state.codeHash,
-            fields: fromApiFields(state.fields, this.fieldsSig),
+            fields: fromApiFields(state.immFields, state.mutFields, this.fieldsSig),
             fieldsSig: this.fieldsSig,
             asset: fromApiAsset(state.asset)
         };
@@ -602,12 +578,12 @@ class Contract extends Artifact {
         const contract = Project.currentProject.contractByCodeHash(state.codeHash);
         return contract.fromApiContractState(state);
     }
-    static fromApiEvent(event, codeHash) {
+    static fromApiEvent(event, codeHash, txId) {
         let eventSig;
-        if (event.eventIndex == -1) {
+        if (event.eventIndex == Contract.ContractCreatedEventIndex) {
             eventSig = this.ContractCreatedEvent;
         }
-        else if (event.eventIndex == -2) {
+        else if (event.eventIndex == Contract.ContractDestroyedEventIndex) {
             eventSig = this.ContractDestroyedEvent;
         }
         else {
@@ -615,63 +591,96 @@ class Contract extends Artifact {
             eventSig = contract.eventsSig[event.eventIndex];
         }
         return {
+            txId: txId,
             blockHash: event.blockHash,
             contractAddress: event.contractAddress,
             name: eventSig.name,
+            eventIndex: event.eventIndex,
             fields: fromApiEventFields(event.fields, eventSig)
         };
     }
-    fromTestContractResult(methodIndex, result) {
+    fromApiTestContractResult(methodName, result, txId) {
+        const methodIndex = this.functions.findIndex((sig) => sig.name === methodName);
+        const returnTypes = this.functions[`${methodIndex}`].returnTypes;
+        const rawReturn = (0, api_1.fromApiArray)(result.returns, returnTypes);
+        const returns = rawReturn.length === 0 ? null : rawReturn.length === 1 ? rawReturn[0] : rawReturn;
         const addressToCodeHash = new Map();
         addressToCodeHash.set(result.address, result.codeHash);
         result.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash));
         return {
             contractId: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(result.address)),
             contractAddress: result.address,
-            returns: (0, api_1.fromApiArray)(result.returns, this.functions[`${methodIndex}`].returnTypes),
+            returns: returns,
             gasUsed: result.gasUsed,
             contracts: result.contracts.map((contract) => Contract.fromApiContractState(contract)),
             txOutputs: result.txOutputs.map(fromApiOutput),
-            events: result.events.map((event) => {
-                const contractAddress = event.contractAddress;
-                const codeHash = addressToCodeHash.get(contractAddress);
-                if (typeof codeHash !== 'undefined' || event.eventIndex < 0) {
-                    return Contract.fromApiEvent(event, codeHash);
-                }
-                else {
-                    throw Error(`Cannot find codeHash for the contract address: ${contractAddress}`);
-                }
-            }),
+            events: Contract.fromApiEvents(result.events, addressToCodeHash, txId),
             debugMessages: result.debugMessages
         };
     }
     async txParamsForDeployment(signer, params) {
-        const bytecode = this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {});
+        const bytecode = this.buildByteCodeToDeploy(params.initialFields ?? {});
         const signerParams = {
             signerAddress: await signer.getSelectedAddress(),
             bytecode: bytecode,
-            initialAttoAlphAmount: params.initialAttoAlphAmount,
-            issueTokenAmount: params.issueTokenAmount,
-            initialTokenAmounts: params.initialTokenAmounts,
-            gasAmount: params.gasAmount,
-            gasPrice: params.gasPrice
+            initialAttoAlphAmount: params?.initialAttoAlphAmount,
+            issueTokenAmount: params?.issueTokenAmount,
+            initialTokenAmounts: params?.initialTokenAmounts,
+            gasAmount: params?.gasAmount,
+            gasPrice: params?.gasPrice
         };
         return signerParams;
     }
-    async deploy(signer, params) {
-        const signerParams = await this.txParamsForDeployment(signer, params);
-        return signer.signAndSubmitDeployContractTx(signerParams);
-    }
     buildByteCodeToDeploy(initialFields) {
         return ralph.buildContractByteCode(this.bytecode, initialFields, this.fieldsSig);
     }
+    static fromApiEvents(events, addressToCodeHash, txId) {
+        return events.map((event) => {
+            const contractAddress = event.contractAddress;
+            const codeHash = addressToCodeHash.get(contractAddress);
+            if (typeof codeHash !== 'undefined' || event.eventIndex < 0) {
+                return Contract.fromApiEvent(event, codeHash, txId);
+            }
+            else {
+                throw Error(`Cannot find codeHash for the contract address: ${contractAddress}`);
+            }
+        });
+    }
+    toApiCallContract(params, groupIndex, contractAddress, methodIndex) {
+        const functionSig = this.functions[`${methodIndex}`];
+        const args = toApiVals(params.args ?? {}, functionSig.paramNames, functionSig.paramTypes);
+        return {
+            ...params,
+            group: groupIndex,
+            address: contractAddress,
+            methodIndex: methodIndex,
+            args: args
+        };
+    }
+    fromApiCallContractResult(result, txId, methodIndex) {
+        const returnTypes = this.functions[`${methodIndex}`].returnTypes;
+        const rawReturn = (0, api_1.fromApiArray)(result.returns, returnTypes);
+        const returns = rawReturn.length === 0 ? null : rawReturn.length === 1 ? rawReturn[0] : rawReturn;
+        const addressToCodeHash = new Map();
+        result.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash));
+        return {
+            returns: returns,
+            gasUsed: result.gasUsed,
+            contracts: result.contracts.map((state) => Contract.fromApiContractState(state)),
+            txInputs: result.txInputs,
+            txOutputs: result.txOutputs.map((output) => fromApiOutput(output)),
+            events: Contract.fromApiEvents(result.events, addressToCodeHash, txId)
+        };
+    }
 }
 exports.Contract = Contract;
+Contract.ContractCreatedEventIndex = -1;
 Contract.ContractCreatedEvent = {
     name: 'ContractCreated',
     fieldNames: ['address'],
     fieldTypes: ['Address']
 };
+Contract.ContractDestroyedEventIndex = -2;
 Contract.ContractDestroyedEvent = {
     name: 'ContractDestroyed',
     fieldNames: ['address'],
@@ -716,7 +725,7 @@ class Script extends Artifact {
     async txParamsForExecution(signer, params) {
         const signerParams = {
             signerAddress: await signer.getSelectedAddress(),
-            bytecode: this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {}),
+            bytecode: this.buildByteCodeToDeploy(params.initialFields ?? {}),
             attoAlphAmount: params.attoAlphAmount,
             tokens: params.tokens,
             gasAmount: params.gasAmount,
@@ -724,16 +733,26 @@ class Script extends Artifact {
         };
         return signerParams;
     }
-    async execute(signer, params) {
-        const signerParams = await this.txParamsForExecution(signer, params);
-        return await signer.signAndSubmitExecuteScriptTx(signerParams);
-    }
     buildByteCodeToDeploy(initialFields) {
         return ralph.buildScriptByteCode(this.bytecodeTemplate, initialFields, this.fieldsSig);
     }
 }
 exports.Script = Script;
-function fromApiFields(vals, fieldsSig) {
+function fromApiFields(immFields, mutFields, fieldsSig) {
+    const vals = [];
+    let immIndex = 0;
+    let mutIndex = 0;
+    const isMutable = fieldsSig.types.flatMap((tpe, index) => Array((0, api_1.typeLength)(tpe)).fill(fieldsSig.isMutable[`${index}`]));
+    isMutable.forEach((mutable) => {
+        if (mutable) {
+            vals.push(mutFields[`${mutIndex}`]);
+            mutIndex += 1;
+        }
+        else {
+            vals.push(immFields[`${immIndex}`]);
+            immIndex += 1;
+        }
+    });
     return (0, api_1.fromApiVals)(vals, fieldsSig.names, fieldsSig.types);
 }
 function fromApiEventFields(vals, eventSig) {
@@ -759,13 +778,23 @@ function getVal(vals, name) {
         throw Error(`No Val exists for ${name}`);
     }
 }
+function extractFields(fields, fieldsSig, mutable) {
+    const fieldIndexes = fieldsSig.names
+        .map((_, index) => index)
+        .filter((index) => fieldsSig.isMutable[`${index}`] === mutable);
+    const fieldNames = fieldIndexes.map((index) => fieldsSig.names[`${index}`]);
+    const fieldTypes = fieldIndexes.map((index) => fieldsSig.types[`${index}`]);
+    return toApiVals(fields, fieldNames, fieldTypes);
+}
 function toApiContractState(state) {
+    const stateFields = state.fields ?? {};
     return {
         address: state.address,
         bytecode: state.bytecode,
         codeHash: state.codeHash,
         initialStateHash: state.initialStateHash,
-        fields: toApiFields(state.fields, state.fieldsSig),
+        immFields: extractFields(stateFields, state.fieldsSig, false),
+        mutFields: extractFields(stateFields, state.fieldsSig, true),
         asset: toApiAsset(state.asset)
     };
 }
@@ -782,6 +811,7 @@ function toApiVals(fields, names, types) {
         return (0, api_1.toApiVal)(val, tpe);
     });
 }
+exports.toApiVals = toApiVals;
 function toApiInputAsset(inputAsset) {
     return { address: inputAsset.address, asset: toApiAsset(inputAsset.asset) };
 }
@@ -813,5 +843,195 @@ function fromApiOutput(output) {
         throw new Error(`Unknown output type: ${output}`);
     }
 }
-(0, utils_1.assertType)();
-(0, utils_1.assertType)();
+function randomTxId() {
+    const bytes = new Uint8Array(32);
+    crypto_1.webcrypto.getRandomValues(bytes);
+    return (0, utils_1.binToHex)(bytes);
+}
+exports.randomTxId = randomTxId;
+utils_1.assertType;
+class ContractFactory {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async deploy(signer, deployParams) {
+        const signerParams = await this.contract.txParamsForDeployment(signer, deployParams);
+        const result = await signer.signAndSubmitDeployContractTx(signerParams);
+        return {
+            ...result,
+            instance: this.at(result.contractAddress)
+        };
+    }
+    // This is used for testing contract functions
+    stateForTest(initFields, asset, address) {
+        const newAsset = {
+            alphAmount: asset?.alphAmount ?? constants_1.ONE_ALPH,
+            tokens: asset?.tokens
+        };
+        return this.contract.toState(initFields, newAsset, address);
+    }
+}
+exports.ContractFactory = ContractFactory;
+function decodeFields(event, eventSig, eventIndex) {
+    if (event.eventIndex !== eventIndex) {
+        throw new Error(`Invalid event index: ${event.eventIndex}, expected: ${eventIndex}`);
+    }
+    return (0, api_1.fromApiVals)(event.fields, eventSig.fieldNames, eventSig.fieldTypes);
+}
+function decodeContractCreatedEvent(event) {
+    const fields = decodeFields(event, Contract.ContractCreatedEvent, Contract.ContractCreatedEventIndex);
+    return {
+        blockHash: event.blockHash,
+        txId: event.txId,
+        eventIndex: event.eventIndex,
+        name: Contract.ContractCreatedEvent.name,
+        fields: { address: fields['address'] }
+    };
+}
+exports.decodeContractCreatedEvent = decodeContractCreatedEvent;
+function decodeContractDestroyedEvent(event) {
+    const fields = decodeFields(event, Contract.ContractDestroyedEvent, Contract.ContractDestroyedEventIndex);
+    return {
+        blockHash: event.blockHash,
+        txId: event.txId,
+        eventIndex: event.eventIndex,
+        name: Contract.ContractDestroyedEvent.name,
+        fields: { address: fields['address'] }
+    };
+}
+exports.decodeContractDestroyedEvent = decodeContractDestroyedEvent;
+function subscribeEventsFromContract(options, address, eventIndex, decodeFunc, fromCount) {
+    const messageCallback = (event) => {
+        if (event.eventIndex !== eventIndex) {
+            return Promise.resolve();
+        }
+        return options.messageCallback(decodeFunc(event));
+    };
+    const errorCallback = (err, subscription) => {
+        return options.errorCallback(err, subscription);
+    };
+    const opt = {
+        pollingInterval: options.pollingInterval,
+        messageCallback: messageCallback,
+        errorCallback: errorCallback
+    };
+    return (0, events_1.subscribeToEvents)(opt, address, fromCount);
+}
+exports.subscribeEventsFromContract = subscribeEventsFromContract;
+async function testMethod(contract, methodName, params) {
+    const txId = params?.txId ?? randomTxId();
+    const apiParams = contract.contract.toApiTestContractParams(methodName, {
+        ...params,
+        txId: txId,
+        initialFields: params.initialFields === undefined ? {} : params.initialFields,
+        testArgs: params.testArgs === undefined ? {} : params.testArgs
+    });
+    const apiResult = await (0, global_1.getCurrentNodeProvider)().contracts.postContractsTestContract(apiParams);
+    const testResult = contract.contract.fromApiTestContractResult(methodName, apiResult, txId);
+    contract.contract.printDebugMessages(methodName, testResult.debugMessages);
+    return testResult;
+}
+exports.testMethod = testMethod;
+class ContractInstance {
+    constructor(address) {
+        this.address = address;
+        this.contractId = (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(address));
+        this.groupIndex = (0, utils_1.groupOfAddress)(address);
+    }
+}
+exports.ContractInstance = ContractInstance;
+async function fetchContractState(contract, instance) {
+    const contractState = await (0, global_1.getCurrentNodeProvider)().contracts.getContractsAddressState(instance.address, {
+        group: instance.groupIndex
+    });
+    const state = contract.contract.fromApiContractState(contractState);
+    return {
+        ...state,
+        fields: state.fields
+    };
+}
+exports.fetchContractState = fetchContractState;
+function subscribeContractCreatedEvent(instance, options, fromCount) {
+    return subscribeEventsFromContract(options, instance.address, Contract.ContractCreatedEventIndex, (event) => {
+        return {
+            ...decodeContractCreatedEvent(event),
+            contractAddress: instance.address
+        };
+    }, fromCount);
+}
+exports.subscribeContractCreatedEvent = subscribeContractCreatedEvent;
+function subscribeContractDestroyedEvent(instance, options, fromCount) {
+    return subscribeEventsFromContract(options, instance.address, Contract.ContractDestroyedEventIndex, (event) => {
+        return {
+            ...decodeContractDestroyedEvent(event),
+            contractAddress: instance.address
+        };
+    }, fromCount);
+}
+exports.subscribeContractDestroyedEvent = subscribeContractDestroyedEvent;
+function decodeEvent(contract, instance, event, targetEventIndex) {
+    if (event.eventIndex !== targetEventIndex &&
+        !(targetEventIndex >= 0 && targetEventIndex < contract.eventsSig.length)) {
+        throw new Error('Invalid event index: ' + event.eventIndex + ', expected: ' + targetEventIndex);
+    }
+    const eventSig = contract.eventsSig[`${targetEventIndex}`];
+    const fieldNames = eventSig.fieldNames;
+    const fieldTypes = eventSig.fieldTypes;
+    const fields = (0, api_1.fromApiVals)(event.fields, fieldNames, fieldTypes);
+    return {
+        contractAddress: instance.address,
+        blockHash: event.blockHash,
+        txId: event.txId,
+        eventIndex: event.eventIndex,
+        name: eventSig.name,
+        fields: fields
+    };
+}
+exports.decodeEvent = decodeEvent;
+function subscribeContractEvent(contract, instance, options, eventName, fromCount) {
+    const eventIndex = contract.eventsSig.findIndex((sig) => sig.name === eventName);
+    return subscribeEventsFromContract(options, instance.address, eventIndex, (event) => decodeEvent(contract, instance, event, eventIndex), fromCount);
+}
+exports.subscribeContractEvent = subscribeContractEvent;
+function subscribeAllEvents(contract, instance, options, fromCount) {
+    const messageCallback = (event) => {
+        switch (event.eventIndex) {
+            case Contract.ContractCreatedEventIndex: {
+                return options.messageCallback({
+                    ...decodeContractCreatedEvent(event),
+                    contractAddress: instance.address
+                });
+            }
+            case Contract.ContractDestroyedEventIndex: {
+                return options.messageCallback({
+                    ...decodeContractDestroyedEvent(event),
+                    contractAddress: instance.address
+                });
+            }
+            default:
+                return options.messageCallback({
+                    ...decodeEvent(contract, instance, event, event.eventIndex),
+                    contractAddress: instance.address
+                });
+        }
+    };
+    const errorCallback = (err, subscription) => {
+        return options.errorCallback(err, subscription);
+    };
+    const opt = {
+        pollingInterval: options.pollingInterval,
+        messageCallback: messageCallback,
+        errorCallback: errorCallback
+    };
+    return (0, events_1.subscribeToEvents)(opt, instance.address, fromCount);
+}
+exports.subscribeAllEvents = subscribeAllEvents;
+async function callMethod(contract, instance, methodName, params) {
+    const methodIndex = contract.contract.getMethodIndex(methodName);
+    const txId = params?.txId ?? randomTxId();
+    const callParams = contract.contract.toApiCallContract({ ...params, txId: txId, args: params.args === undefined ? {} : params.args }, instance.groupIndex, instance.address, methodIndex);
+    const result = await (0, global_1.getCurrentNodeProvider)().contracts.postContractsCallContract(callParams);
+    const callResult = contract.contract.fromApiCallContractResult(result, txId, methodIndex);
+    return callResult;
+}
+exports.callMethod = callMethod;

package/dist/src/contract/ralph.js

@@ -253,8 +253,12 @@ function buildScriptByteCode(bytecodeTemplate, fields, fieldsSig) {
     });
 }
 exports.buildScriptByteCode = buildScriptByteCode;
-function buildContractByteCode(bytecode, fields, fieldsSig) {
-    const fieldsEncoded = fieldsSig.names.flatMap((fieldName, fieldIndex) => {
+function encodeFields(fields, fieldsSig, mutable) {
+    const fieldIndexes = fieldsSig.isMutable
+        .map((_, index) => index)
+        .filter((index) => fieldsSig.isMutable[`${index}`] === mutable);
+    const fieldsEncoded = fieldIndexes.flatMap((fieldIndex) => {
+        const fieldName = fieldsSig.names[`${fieldIndex}`];
         const fieldType = fieldsSig.types[`${fieldIndex}`];
         if (fieldName in fields) {
             const fieldValue = fields[`${fieldName}`];
@@ -265,7 +269,12 @@ function buildContractByteCode(bytecode, fields, fieldsSig) {
         }
     });
     const fieldsLength = buffer_1.Buffer.from(encodeI256(BigInt(fieldsEncoded.length))).toString('hex');
-    return bytecode + fieldsLength + fieldsEncoded.map((f) => buffer_1.Buffer.from(f).toString('hex')).join('');
+    return fieldsLength + fieldsEncoded.map((f) => buffer_1.Buffer.from(f).toString('hex')).join('');
+}
+function buildContractByteCode(bytecode, fields, fieldsSig) {
+    const encodedImmFields = encodeFields(fields, fieldsSig, false);
+    const encodedMutFields = encodeFields(fields, fieldsSig, true);
+    return bytecode + encodedImmFields + encodedMutFields;
 }
 exports.buildContractByteCode = buildContractByteCode;
 var ApiValType;

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

@@ -62,7 +62,7 @@ class TransactionBuilder {
         };
         const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data);
         const contractId = __1.utils.binToHex(__1.utils.contractIdFromAddress(response.contractAddress));
-        return { ...response, contractId, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
+        return { ...response, groupIndex: response.fromGroup, contractId, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
     async buildExecuteScriptTx(params, publicKey) {
         TransactionBuilder.validatePublicKey(params, publicKey);
@@ -75,7 +75,7 @@ class TransactionBuilder {
             ...rest
         };
         const response = await this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data);
-        return { ...response, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
+        return { ...response, groupIndex: response.fromGroup, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
     async buildUnsignedTx(params) {
         const data = { unsignedTx: params.unsignedTx };

package/dist/src/signer/types.d.ts

@@ -43,8 +43,7 @@ export interface SignDeployContractTxParams {
     gasPrice?: Number256;
 }
 export interface SignDeployContractTxResult {
-    fromGroup: number;
-    toGroup: number;
+    groupIndex: number;
     unsignedTx: string;
     txId: string;
     signature: string;
@@ -62,8 +61,7 @@ export interface SignExecuteScriptTxParams {
     gasPrice?: Number256;
 }
 export interface SignExecuteScriptTxResult {
-    fromGroup: number;
-    toGroup: number;
+    groupIndex: number;
     unsignedTx: string;
     txId: string;
     signature: string;

package/dist/src/utils/utils.d.ts

@@ -29,4 +29,5 @@ export declare type Eq<X, Y> = _Eq<{
     [P in keyof Y]: Y[P];
 }>;
 export declare function assertType<T extends true>(): void;
+export declare type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
 export {};

package/dist/src/utils/utils.js

@@ -94,7 +94,9 @@ function groupOfAddress(address) {
         return groupOfP2shAddress(addressBody);
     }
     else {
-        throw new Error(`Invalid asset address type: ${addressType}`);
+        // Contract Address
+        const id = contractIdFromAddress(address);
+        return id[`${id.length - 1}`];
     }
 }
 exports.groupOfAddress = groupOfAddress;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.4.0",
+  "version": "0.5.0-rc.1",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -27,8 +27,8 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "1.6.4",
-    "explorer_backend_version": "1.12.0-rc2"
+    "alephium_version": "1.7.0",
+    "explorer_backend_version": "1.12.0"
   },
   "scripts": {
     "build": "rm -rf dist/* && npx tsc --build . && webpack",