@alephium/web3 0.35.1 → 0.36.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.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.DestroyContractEventAddress = exports.CreateContractEventAddress = exports.ExecutableScript = exports.ContractFactory = exports.randomTxId = exports.toApiVals = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.ProjectArtifact = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = exports.StdIdFieldName = void 0;
+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.DestroyContractEventAddress = exports.CreateContractEventAddress = 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");
@@ -65,6 +65,7 @@ var SourceKind;
     SourceKind[SourceKind["Script"] = 1] = "Script";
     SourceKind[SourceKind["AbstractContract"] = 2] = "AbstractContract";
     SourceKind[SourceKind["Interface"] = 3] = "Interface";
+    SourceKind[SourceKind["Struct"] = 4] = "Struct";
 })(SourceKind || (SourceKind = {}));
 exports.DEFAULT_NODE_COMPILER_OPTIONS = {
     ignoreUnusedConstantsWarnings: false,
@@ -238,6 +239,32 @@ function removeOldArtifacts(dir) {
         fs_1.default.rmdirSync(dir);
     }
 }
+class Struct {
+    constructor(name, fieldNames, fieldTypes, isMutable) {
+        this.name = name;
+        this.fieldNames = fieldNames;
+        this.fieldTypes = fieldTypes;
+        this.isMutable = isMutable;
+    }
+    static fromJson(json) {
+        if (json.name === null || json.fieldNames === null || json.fieldTypes === null || json.isMutable === null) {
+            throw Error('The JSON for struct is incomplete');
+        }
+        return new Struct(json.name, json.fieldNames, json.fieldTypes, json.isMutable);
+    }
+    static fromStructSig(sig) {
+        return new Struct(sig.name, sig.fieldNames, sig.fieldTypes, sig.isMutable);
+    }
+    toJson() {
+        return {
+            name: this.name,
+            fieldNames: this.fieldNames,
+            fieldTypes: this.fieldTypes,
+            isMutable: this.isMutable
+        };
+    }
+}
+exports.Struct = Struct;
 class Project {
     static buildProjectArtifact(fullNodeVersion, sourceInfos, contracts, scripts, compilerOptions) {
         const files = new Map();
@@ -271,12 +298,13 @@ class Project {
         });
         return new ProjectArtifact(fullNodeVersion, compilerOptions, files);
     }
-    constructor(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, errorOnWarnings, projectArtifact) {
+    constructor(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, structs, errorOnWarnings, projectArtifact) {
         this.contractsRootDir = contractsRootDir;
         this.artifactsRootDir = artifactsRootDir;
         this.sourceInfos = sourceInfos;
         this.contracts = contracts;
         this.scripts = scripts;
+        this.structs = structs;
         this.projectArtifact = projectArtifact;
         if (errorOnWarnings) {
             Project.checkCompilerWarnings([
@@ -312,6 +340,24 @@ class Project {
         }
         return script.artifact;
     }
+    static async loadStructs(artifactsRootDir) {
+        const filePath = path.join(artifactsRootDir, 'structs.ral.json');
+        if (!fs_1.default.existsSync(filePath))
+            return [];
+        const content = await fs_2.promises.readFile(filePath);
+        const json = JSON.parse(content.toString());
+        if (!Array.isArray(json)) {
+            throw Error(`Invalid structs JSON: ${content}`);
+        }
+        return Array.from(json).map((item) => Struct.fromJson(item));
+    }
+    async saveStructsToFile() {
+        if (this.structs.length === 0)
+            return;
+        const structs = this.structs.map((s) => s.toJson());
+        const filePath = path.join(this.artifactsRootDir, 'structs.ral.json');
+        return fs_2.promises.writeFile(filePath, JSON.stringify(structs, null, 2));
+    }
     async saveArtifactsToFile(projectRootDir) {
         const artifactsRootDir = this.artifactsRootDir;
         const saveToFile = async function (compiled) {
@@ -324,6 +370,7 @@ class Project {
         };
         this.contracts.forEach((contract) => saveToFile(contract));
         this.scripts.forEach((script) => saveToFile(script));
+        this.saveStructsToFile();
         await this.projectArtifact.saveToFile(projectRootDir);
     }
     contractByCodeHash(codeHash) {
@@ -368,13 +415,14 @@ class Project {
         const result = await Project.getCompileResult(provider, compilerOptions, removeDuplicates);
         const contracts = new Map();
         const scripts = new Map();
+        const structs = result.structs === undefined ? [] : result.structs.map((item) => Struct.fromStructSig(item));
         result.contracts.forEach((contractResult) => {
             const sourceInfo = sourceInfos.find((sourceInfo) => sourceInfo.type === SourceKind.Contract && sourceInfo.name === contractResult.name);
             if (sourceInfo === undefined) {
                 // this should never happen
                 throw new Error(`SourceInfo does not exist for contract ${contractResult.name}`);
             }
-            const contract = Contract.fromCompileResult(contractResult);
+            const contract = Contract.fromCompileResult(contractResult, structs);
             contracts.set(contract.name, new Compiled(sourceInfo, contract, contractResult.warnings));
         });
         result.scripts.forEach((scriptResult) => {
@@ -383,11 +431,11 @@ class Project {
                 // this should never happen
                 throw new Error(`SourceInfo does not exist for script ${scriptResult.name}`);
             }
-            const script = Script.fromCompileResult(scriptResult);
+            const script = Script.fromCompileResult(scriptResult, structs);
             scripts.set(script.name, new Compiled(sourceInfo, script, scriptResult.warnings));
         });
         const projectArtifact = Project.buildProjectArtifact(fullNodeVersion, sourceInfos, contracts, scripts, compilerOptions);
-        const project = new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, errorOnWarnings, projectArtifact);
+        const project = new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, structs, errorOnWarnings, projectArtifact);
         await project.saveArtifactsToFile(projectRootDir);
         return project;
     }
@@ -395,6 +443,7 @@ class Project {
         try {
             const contracts = new Map();
             const scripts = new Map();
+            const structs = await Project.loadStructs(artifactsRootDir);
             for (const sourceInfo of sourceInfos) {
                 const info = projectArtifact.infos.get(sourceInfo.name);
                 if (typeof info === 'undefined') {
@@ -403,15 +452,15 @@ class Project {
                 const warnings = info.warnings;
                 const artifactDir = sourceInfo.getArtifactPath(artifactsRootDir);
                 if (sourceInfo.type === SourceKind.Contract) {
-                    const artifact = await Contract.fromArtifactFile(artifactDir, info.bytecodeDebugPatch, info.codeHashDebug);
+                    const artifact = await Contract.fromArtifactFile(artifactDir, info.bytecodeDebugPatch, info.codeHashDebug, structs);
                     contracts.set(artifact.name, new Compiled(sourceInfo, artifact, warnings));
                 }
                 else if (sourceInfo.type === SourceKind.Script) {
-                    const artifact = await Script.fromArtifactFile(artifactDir, info.bytecodeDebugPatch);
+                    const artifact = await Script.fromArtifactFile(artifactDir, info.bytecodeDebugPatch, structs);
                     scripts.set(artifact.name, new Compiled(sourceInfo, artifact, warnings));
                 }
             }
-            return new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, errorOnWarnings, projectArtifact);
+            return new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, structs, errorOnWarnings, projectArtifact);
         }
         catch (error) {
             console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`);
@@ -526,11 +575,13 @@ Project.abstractContractMatcher = new TypedMatcher('^Abstract Contract ([A-Z][a-
 Project.contractMatcher = new TypedMatcher('^Contract ([A-Z][a-zA-Z0-9]*)', SourceKind.Contract);
 Project.interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*)', SourceKind.Interface);
 Project.scriptMatcher = new TypedMatcher('^TxScript ([A-Z][a-zA-Z0-9]*)', SourceKind.Script);
+Project.structMatcher = new TypedMatcher('struct ([A-Z][a-zA-Z0-9]*)', SourceKind.Struct);
 Project.matchers = [
     Project.abstractContractMatcher,
     Project.contractMatcher,
     Project.interfaceMatcher,
-    Project.scriptMatcher
+    Project.scriptMatcher,
+    Project.structMatcher
 ];
 Project.DEFAULT_CONTRACTS_DIR = 'contracts';
 Project.DEFAULT_ARTIFACTS_DIR = 'artifacts';
@@ -559,7 +610,7 @@ class Artifact {
 }
 exports.Artifact = Artifact;
 class Contract extends Artifact {
-    constructor(version, name, bytecode, bytecodeDebugPatch, codeHash, codeHashDebug, fieldsSig, eventsSig, functions, constants, enums, stdInterfaceId) {
+    constructor(version, name, bytecode, bytecodeDebugPatch, codeHash, codeHashDebug, fieldsSig, eventsSig, functions, constants, enums, structs, stdInterfaceId) {
         super(version, name, functions);
         this.bytecode = bytecode;
         this.bytecodeDebugPatch = bytecodeDebugPatch;
@@ -568,12 +619,13 @@ class Contract extends Artifact {
         this.eventsSig = eventsSig;
         this.constants = constants;
         this.enums = enums;
+        this.structs = structs;
         this.stdInterfaceId = stdInterfaceId;
         this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch);
         this.codeHashDebug = codeHashDebug;
     }
     // TODO: safely parse json
-    static fromJson(artifact, bytecodeDebugPatch = '', codeHashDebug = '') {
+    static fromJson(artifact, bytecodeDebugPatch = '', codeHashDebug = '', structs = []) {
         if (artifact.version == null ||
             artifact.name == null ||
             artifact.bytecode == null ||
@@ -585,17 +637,17 @@ class Contract extends Artifact {
             artifact.functions == null) {
             throw Error('The artifact JSON for contract is incomplete');
         }
-        const contract = new Contract(artifact.version, artifact.name, artifact.bytecode, bytecodeDebugPatch, artifact.codeHash, codeHashDebug ? codeHashDebug : artifact.codeHash, artifact.fieldsSig, artifact.eventsSig, artifact.functions, artifact.constants, artifact.enums, artifact.stdInterfaceId === null ? undefined : artifact.stdInterfaceId);
+        const contract = new Contract(artifact.version, artifact.name, artifact.bytecode, bytecodeDebugPatch, artifact.codeHash, codeHashDebug ? codeHashDebug : artifact.codeHash, artifact.fieldsSig, artifact.eventsSig, artifact.functions, artifact.constants, artifact.enums, structs, artifact.stdInterfaceId === null ? undefined : artifact.stdInterfaceId);
         return contract;
     }
-    static fromCompileResult(result) {
-        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, result.stdInterfaceId);
+    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.stdInterfaceId);
     }
     // support both 'code.ral' and 'code.ral.json'
-    static async fromArtifactFile(path, bytecodeDebugPatch, codeHashDebug) {
+    static async fromArtifactFile(path, bytecodeDebugPatch, codeHashDebug, structs = []) {
         const content = await fs_2.promises.readFile(path);
         const artifact = JSON.parse(content.toString());
-        return Contract.fromJson(artifact, bytecodeDebugPatch, codeHashDebug);
+        return Contract.fromJson(artifact, bytecodeDebugPatch, codeHashDebug, structs);
     }
     toString() {
         const object = {
@@ -622,10 +674,7 @@ class Contract extends Artifact {
                 types: this.fieldsSig.types.slice(0, -1),
                 isMutable: this.fieldsSig.isMutable.slice(0, -1)
             };
-        return fields.names.reduce((acc, key, index) => {
-            acc[`${key}`] = (0, api_1.getDefaultValue)(fields.types[`${index}`]);
-            return acc;
-        }, {});
+        return getDefaultValue(fields, this.structs);
     }
     toState(fields, asset, address) {
         const addressDef = typeof address !== 'undefined' ? address : Contract.randomAddress();
@@ -657,7 +706,7 @@ class Contract extends Artifact {
             return [];
         }
         else {
-            return toApiFields(fields, this.fieldsSig);
+            return toApiFields(fields, this.fieldsSig, this.structs);
         }
     }
     toApiArgs(funcName, args) {
@@ -666,7 +715,7 @@ class Contract extends Artifact {
             if (func == null) {
                 throw new Error(`Invalid function name: ${funcName}`);
             }
-            return toApiArgs(args, func);
+            return toApiArgs(args, func, this.structs);
         }
         else {
             return [];
@@ -676,11 +725,14 @@ class Contract extends Artifact {
         return this.functions.findIndex((func) => func.name === funcName);
     }
     toApiContractStates(states) {
-        return typeof states != 'undefined' ? states.map((state) => toApiContractState(state)) : undefined;
+        return typeof states != 'undefined' ? states.map((state) => toApiContractState(state, this.structs)) : undefined;
     }
     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);
+        const allFields = params.initialFields === undefined
+            ? []
+            : ralph.flattenFields(params.initialFields, this.fieldsSig.names, this.fieldsSig.types, this.fieldsSig.isMutable, this.structs);
+        const immFields = allFields.filter((f) => !f.isMutable).map((f) => (0, api_1.toApiVal)(f.value, f.type));
+        const mutFields = allFields.filter((f) => f.isMutable).map((f) => (0, api_1.toApiVal)(f.value, f.type));
         return {
             group: params.group,
             blockHash: params.blockHash,
@@ -705,7 +757,7 @@ class Contract extends Artifact {
             bytecode: state.bytecode,
             initialStateHash: state.initialStateHash,
             codeHash: state.codeHash,
-            fields: fromApiFields(state.immFields, state.mutFields, this.fieldsSig),
+            fields: fromApiFields(state.immFields, state.mutFields, this.fieldsSig, this.structs),
             fieldsSig: this.fieldsSig,
             asset: fromApiAsset(state.asset)
         };
@@ -747,7 +799,7 @@ class Contract extends Artifact {
     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 rawReturn = fromApiArray(result.returns, returnTypes, this.structs);
         const returns = rawReturn.length === 0 ? null : rawReturn.length === 1 ? rawReturn[0] : rawReturn;
         const addressToCodeHash = new Map();
         addressToCodeHash.set(result.address, result.codeHash);
@@ -783,7 +835,7 @@ class Contract extends Artifact {
     }
     buildByteCodeToDeploy(initialFields, isDevnet) {
         try {
-            return ralph.buildContractByteCode(isDevnet ? this.bytecodeDebug : this.bytecode, initialFields, this.fieldsSig);
+            return ralph.buildContractByteCode(isDevnet ? this.bytecodeDebug : this.bytecode, initialFields, this.fieldsSig, this.structs);
         }
         catch (error) {
             throw new Error(`Failed to build bytecode for contract ${this.name}, error: ${error}`);
@@ -803,7 +855,7 @@ class Contract extends Artifact {
     }
     toApiCallContract(params, groupIndex, contractAddress, methodIndex) {
         const functionSig = this.functions[`${methodIndex}`];
-        const args = toApiVals(params.args ?? {}, functionSig.paramNames, functionSig.paramTypes);
+        const args = toApiArgs(params.args ?? {}, functionSig, this.structs);
         return {
             ...params,
             group: groupIndex,
@@ -815,7 +867,7 @@ class Contract extends Artifact {
     fromApiCallContractResult(result, txId, methodIndex, getContractByCodeHash) {
         const returnTypes = this.functions[`${methodIndex}`].returnTypes;
         const callResult = tryGetCallResult(result);
-        const rawReturn = (0, api_1.fromApiArray)(callResult.returns, returnTypes);
+        const rawReturn = fromApiArray(callResult.returns, returnTypes, this.structs);
         const returns = rawReturn.length === 0 ? null : rawReturn.length === 1 ? rawReturn[0] : rawReturn;
         const addressToCodeHash = new Map();
         callResult.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash));
@@ -844,17 +896,18 @@ Contract.ContractDestroyedEvent = {
     fieldTypes: ['Address']
 };
 class Script extends Artifact {
-    constructor(version, name, bytecodeTemplate, bytecodeDebugPatch, fieldsSig, functions) {
+    constructor(version, name, bytecodeTemplate, bytecodeDebugPatch, fieldsSig, functions, structs) {
         super(version, name, functions);
         this.bytecodeTemplate = bytecodeTemplate;
         this.bytecodeDebugPatch = bytecodeDebugPatch;
         this.fieldsSig = fieldsSig;
+        this.structs = structs;
     }
-    static fromCompileResult(result) {
-        return new Script(result.version, result.name, result.bytecodeTemplate, result.bytecodeDebugPatch, result.fields, result.functions);
+    static fromCompileResult(result, structs = []) {
+        return new Script(result.version, result.name, result.bytecodeTemplate, result.bytecodeDebugPatch, result.fields, result.functions, structs);
     }
     // TODO: safely parse json
-    static fromJson(artifact, bytecodeDebugPatch = '') {
+    static fromJson(artifact, bytecodeDebugPatch = '', structs = []) {
         if (artifact.version == null ||
             artifact.name == null ||
             artifact.bytecodeTemplate == null ||
@@ -862,12 +915,12 @@ class Script extends Artifact {
             artifact.functions == null) {
             throw Error('The artifact JSON for script is incomplete');
         }
-        return new Script(artifact.version, artifact.name, artifact.bytecodeTemplate, bytecodeDebugPatch, artifact.fieldsSig, artifact.functions);
+        return new Script(artifact.version, artifact.name, artifact.bytecodeTemplate, bytecodeDebugPatch, artifact.fieldsSig, artifact.functions, structs);
     }
-    static async fromArtifactFile(path, bytecodeDebugPatch) {
+    static async fromArtifactFile(path, bytecodeDebugPatch, structs = []) {
         const content = await fs_2.promises.readFile(path);
         const artifact = JSON.parse(content.toString());
-        return this.fromJson(artifact, bytecodeDebugPatch);
+        return this.fromJson(artifact, bytecodeDebugPatch, structs);
     }
     toString() {
         const object = {
@@ -894,7 +947,7 @@ class Script extends Artifact {
     }
     buildByteCodeToDeploy(initialFields) {
         try {
-            return ralph.buildScriptByteCode(this.bytecodeTemplate, initialFields, this.fieldsSig);
+            return ralph.buildScriptByteCode(this.bytecodeTemplate, initialFields, this.fieldsSig, this.structs);
         }
         catch (error) {
             throw new Error(`Failed to build bytecode for script ${this.name}, error: ${error}`);
@@ -902,26 +955,69 @@ class Script extends Artifact {
     }
 }
 exports.Script = Script;
-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 fromApiFields(immFields, mutFields, fieldsSig, structs) {
+    let [immIndex, mutIndex] = [0, 0];
+    const func = (type, isMutable) => {
+        const nodeVal = isMutable ? mutFields[mutIndex++] : immFields[immIndex++];
+        return (0, api_1.fromApiPrimitiveVal)(nodeVal, type);
+    };
+    return fieldsSig.names.reduce((acc, name, index) => {
+        const fieldType = fieldsSig.types[`${index}`];
+        const isMutable = fieldsSig.isMutable[`${index}`];
+        acc[`${name}`] = buildVal(isMutable, fieldType, structs, func);
+        return acc;
+    }, {});
+}
+exports.fromApiFields = fromApiFields;
+function buildVal(isMutable, type, structs, func) {
+    if (type.startsWith('[')) {
+        const [baseType, size] = (0, api_1.decodeArrayType)(type);
+        return Array.from(Array(size).keys()).map(() => buildVal(isMutable, baseType, structs, func));
+    }
+    const struct = structs.find((s) => s.name === type);
+    if (struct !== undefined) {
+        return struct.fieldNames.reduce((acc, name, index) => {
+            const fieldType = struct.fieldTypes[`${index}`];
+            const isFieldMutable = isMutable && struct.isMutable[`${index}`];
+            acc[`${name}`] = buildVal(isFieldMutable, fieldType, structs, func);
+            return acc;
+        }, {});
+    }
+    const primitiveType = api_1.PrimitiveTypes.includes(type) ? type : 'ByteVec'; // contract type
+    return func(primitiveType, isMutable);
+}
+function getDefaultValue(fieldsSig, structs) {
+    return fieldsSig.names.reduce((acc, name, index) => {
+        const type = fieldsSig.types[`${index}`];
+        acc[`${name}`] = buildVal(false, type, structs, api_1.getDefaultPrimitiveValue);
+        return acc;
+    }, {});
+}
+exports.getDefaultValue = getDefaultValue;
+function fromApiVal(iter, type, structs, systemEvent = false) {
+    const func = (primitiveType) => {
+        const currentValue = iter.next();
+        if (currentValue.done)
+            throw Error('Not enough vals');
+        return (0, api_1.fromApiPrimitiveVal)(currentValue.value, primitiveType, systemEvent);
+    };
+    return buildVal(false, type, structs, func);
+}
+function fromApiArray(values, types, structs) {
+    const iter = values.values();
+    return types.map((type) => fromApiVal(iter, type, structs));
 }
+exports.fromApiArray = fromApiArray;
 function fromApiEventFields(vals, eventSig, systemEvent = false) {
-    return (0, api_1.fromApiVals)(vals, eventSig.fieldNames, eventSig.fieldTypes, systemEvent);
+    const iter = vals.values();
+    return eventSig.fieldNames.reduce((acc, name, index) => {
+        const type = eventSig.fieldTypes[`${index}`];
+        // currently event does not support struct type
+        acc[`${name}`] = fromApiVal(iter, type, [], systemEvent);
+        return acc;
+    }, {});
 }
+exports.fromApiEventFields = fromApiEventFields;
 function toApiAsset(asset) {
     return {
         attoAlphAmount: (0, api_1.toApiNumber256)(asset.alphAmount),
@@ -934,48 +1030,32 @@ function fromApiAsset(asset) {
         tokens: (0, api_1.fromApiTokens)(asset.tokens)
     };
 }
-function getVal(vals, name) {
-    if (name in vals) {
-        return vals[`${name}`];
-    }
-    else {
-        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) {
+function toApiContractState(state, structs) {
     const stateFields = state.fields ?? {};
+    const fieldsSig = state.fieldsSig;
+    const allFields = ralph.flattenFields(stateFields, fieldsSig.names, fieldsSig.types, fieldsSig.isMutable, structs);
+    const immFields = allFields.filter((f) => !f.isMutable).map((f) => (0, api_1.toApiVal)(f.value, f.type));
+    const mutFields = allFields.filter((f) => f.isMutable).map((f) => (0, api_1.toApiVal)(f.value, f.type));
     return {
         address: state.address,
         bytecode: state.bytecode,
         codeHash: state.codeHash,
         initialStateHash: state.initialStateHash,
-        immFields: extractFields(stateFields, state.fieldsSig, false),
-        mutFields: extractFields(stateFields, state.fieldsSig, true),
+        immFields,
+        mutFields,
         asset: toApiAsset(state.asset)
     };
 }
-function toApiFields(fields, fieldsSig) {
-    return toApiVals(fields, fieldsSig.names, fieldsSig.types);
+function toApiFields(fields, fieldsSig, structs) {
+    return ralph
+        .flattenFields(fields, fieldsSig.names, fieldsSig.types, fieldsSig.isMutable, structs)
+        .map((f) => (0, api_1.toApiVal)(f.value, f.type));
 }
-function toApiArgs(args, funcSig) {
-    return toApiVals(args, funcSig.paramNames, funcSig.paramTypes);
-}
-function toApiVals(fields, names, types) {
-    return names.map((name, index) => {
-        const val = getVal(fields, name);
-        const tpe = types[`${index}`];
-        return (0, api_1.toApiVal)(val, tpe);
-    });
+function toApiArgs(args, funcSig, structs) {
+    return ralph
+        .flattenFields(args, funcSig.paramNames, funcSig.paramTypes, funcSig.paramIsMutable, structs)
+        .map((f) => (0, api_1.toApiVal)(f.value, f.type));
 }
-exports.toApiVals = toApiVals;
 function toApiInputAsset(inputAsset) {
     return { address: inputAsset.address, asset: toApiAsset(inputAsset.asset) };
 }
@@ -1175,9 +1255,7 @@ function decodeEvent(contract, instance, event, targetEventIndex) {
         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);
+    const fields = fromApiEventFields(event.fields, eventSig);
     return {
         contractAddress: instance.address,
         blockHash: event.blockHash,

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

@@ -1,5 +1,5 @@
 import { Val } from '../api';
-import { Fields, FieldsSig } from './contract';
+import { Fields, FieldsSig, Struct } from './contract';
 export declare function encodeBool(bool: boolean): Uint8Array;
 export declare function encodeI256(i256: bigint): Uint8Array;
 export declare function encodeU256(u256: bigint): Uint8Array;
@@ -19,12 +19,13 @@ export declare function encodeVmByteVec(bytes: string): Uint8Array;
 export declare function encodeVmAddress(address: string): Uint8Array;
 export declare function encodeScriptFieldAsString(tpe: string, value: Val): string;
 export declare function encodeScriptField(tpe: string, value: Val): Uint8Array;
-export declare function falttenFields(fields: Fields, fieldsSig: FieldsSig): {
+export declare function flattenFields(fields: Fields, names: string[], types: string[], isMutable: boolean[], structs: Struct[]): {
     name: string;
     type: string;
     value: Val;
+    isMutable: boolean;
 }[];
-export declare function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fieldsSig: FieldsSig): string;
-export declare function buildContractByteCode(bytecode: string, fields: Fields, fieldsSig: FieldsSig): string;
-export declare function encodeContractField(tpe: string, value: Val): Uint8Array[];
+export declare function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fieldsSig: FieldsSig, structs: Struct[]): string;
+export declare function buildContractByteCode(bytecode: string, fields: Fields, fieldsSig: FieldsSig, structs: Struct[]): string;
+export declare function encodeContractField(tpe: string, value: Val): Uint8Array;
 export declare function buildDebugBytecode(bytecode: string, bytecodePatch: string): string;