@alephium/web3 0.36.1 → 0.38.0

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.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.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;
 const buffer_1 = require("buffer/");
 const fs_1 = __importDefault(require("fs"));
 const fs_2 = require("fs");
@@ -57,6 +57,7 @@ const constants_1 = require("../constants");
 const blake = __importStar(require("blakejs"));
 const error_1 = require("../utils/error");
 const debug_1 = require("../debug");
+const codec_1 = require("../codec");
 const crypto = new utils_1.WebCrypto();
 exports.StdIdFieldName = '__stdInterfaceId';
 var SourceKind;
@@ -610,7 +611,7 @@ class Artifact {
 }
 exports.Artifact = Artifact;
 class Contract extends Artifact {
-    constructor(version, name, bytecode, bytecodeDebugPatch, codeHash, codeHashDebug, fieldsSig, eventsSig, functions, constants, enums, structs, stdInterfaceId) {
+    constructor(version, name, bytecode, bytecodeDebugPatch, codeHash, codeHashDebug, fieldsSig, eventsSig, functions, constants, enums, structs, mapsSig, stdInterfaceId) {
         super(version, name, functions);
         this.bytecode = bytecode;
         this.bytecodeDebugPatch = bytecodeDebugPatch;
@@ -620,6 +621,7 @@ class Contract extends Artifact {
         this.constants = constants;
         this.enums = enums;
         this.structs = structs;
+        this.mapsSig = mapsSig;
         this.stdInterfaceId = stdInterfaceId;
         this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch);
         this.codeHashDebug = codeHashDebug;
@@ -637,11 +639,11 @@ 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, structs, 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.mapsSig === null ? undefined : artifact.mapsSig, artifact.stdInterfaceId === null ? undefined : artifact.stdInterfaceId);
         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.stdInterfaceId);
+        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);
     }
     // support both 'code.ral' and 'code.ral.json'
     static async fromArtifactFile(path, bytecodeDebugPatch, codeHashDebug, structs = []) {
@@ -661,6 +663,9 @@ class Contract extends Artifact {
             constants: this.constants,
             enums: this.enums
         };
+        if (this.mapsSig !== undefined) {
+            object.mapsSig = this.mapsSig;
+        }
         if (this.stdInterfaceId !== undefined) {
             object.stdInterfaceId = this.stdInterfaceId;
         }
@@ -1129,13 +1134,14 @@ class ExecutableScript {
     }
 }
 exports.ExecutableScript = ExecutableScript;
-function specialContractAddress(n) {
+function specialContractAddress(eventIndex, groupIndex) {
     const bytes = new Uint8Array(32).fill(0);
-    bytes[31] = n;
+    bytes[30] = eventIndex;
+    bytes[31] = groupIndex;
     return (0, utils_1.addressFromContractId)((0, utils_1.binToHex)(bytes));
 }
-exports.CreateContractEventAddress = specialContractAddress(-1);
-exports.DestroyContractEventAddress = specialContractAddress(-2);
+exports.CreateContractEventAddresses = Array.from(Array(constants_1.TOTAL_NUMBER_OF_GROUPS).keys()).map((groupIndex) => specialContractAddress(Contract.ContractCreatedEventIndex, groupIndex));
+exports.DestroyContractEventAddresses = Array.from(Array(constants_1.TOTAL_NUMBER_OF_GROUPS).keys()).map((groupIndex) => specialContractAddress(Contract.ContractDestroyedEventIndex, groupIndex));
 function decodeSystemEvent(event, eventSig, eventIndex) {
     if (event.eventIndex !== eventIndex) {
         throw new Error(`Invalid event index: ${event.eventIndex}, expected: ${eventIndex}`);
@@ -1199,21 +1205,189 @@ function addStdIdToFields(contract, fields) {
         : { ...fields, __stdInterfaceId: stdInterfaceIdPrefix + contract.stdInterfaceId };
 }
 exports.addStdIdToFields = addStdIdToFields;
-async function testMethod(contract, methodName, params) {
+function calcWrapperContractId(parentContractId, mapIndex, key, keyType, group) {
+    const prefix = ralph.encodeMapPrefix(mapIndex);
+    const encodedKey = ralph.primitiveToByteVec(key, keyType);
+    const path = (0, utils_1.binToHex)(prefix) + (0, utils_1.binToHex)(encodedKey);
+    return (0, utils_1.subContractId)(parentContractId, path, group);
+}
+function genCodeForType(type, structs) {
+    const { immFields, mutFields } = ralph.calcFieldSize(type, true, structs);
+    const loadImmFieldByIndex = {
+        isPublic: true,
+        assetModifier: 0,
+        argsLength: 1,
+        localsLength: 1,
+        returnLength: 1,
+        instrs: [(0, codec_1.LoadLocal)(0), codec_1.LoadImmFieldByIndex]
+    };
+    const loadMutFieldByIndex = {
+        ...loadImmFieldByIndex,
+        instrs: [(0, codec_1.LoadLocal)(0), codec_1.LoadMutFieldByIndex]
+    };
+    const parentContractIdIndex = immFields;
+    const storeMutFieldByIndex = {
+        ...loadImmFieldByIndex,
+        argsLength: 2,
+        localsLength: 2,
+        returnLength: 0,
+        instrs: [
+            codec_1.CallerContractId,
+            (0, codec_1.LoadImmField)(parentContractIdIndex),
+            codec_1.ByteVecEq,
+            codec_1.Assert,
+            (0, codec_1.LoadLocal)(0),
+            (0, codec_1.LoadLocal)(1),
+            codec_1.StoreMutFieldByIndex
+        ]
+    };
+    const destroy = {
+        isPublic: true,
+        assetModifier: 2,
+        argsLength: 1,
+        localsLength: 1,
+        returnLength: 0,
+        instrs: [codec_1.CallerContractId, (0, codec_1.LoadImmField)(parentContractIdIndex), codec_1.ByteVecEq, codec_1.Assert, (0, codec_1.LoadLocal)(0), codec_1.DestroySelf]
+    };
+    const c = {
+        fieldLength: immFields + mutFields + 1,
+        methods: [loadImmFieldByIndex, loadMutFieldByIndex, storeMutFieldByIndex, destroy]
+    };
+    const bytecode = codec_1.contract.contractCodec.encode(codec_1.contract.toHalfDecoded(c));
+    const codeHash = blake.blake2b(bytecode, undefined, 32);
+    return { bytecode: (0, utils_1.binToHex)(bytecode), codeHash: (0, utils_1.binToHex)(codeHash) };
+}
+function getContractFieldsSig(mapValueType) {
+    return {
+        names: ['value', 'parentContractId'],
+        types: [mapValueType, 'ByteVec'],
+        isMutable: [true, false]
+    };
+}
+function mapToExistingContracts(contract, parentContractId, group, map, mapIndex, type) {
+    const [keyType, valueType] = ralph.parseMapType(type);
+    const generatedContract = genCodeForType(valueType, contract.structs);
+    return Array.from(map.entries()).map(([key, value]) => {
+        const fields = { value, parentContractId };
+        const contractId = calcWrapperContractId(parentContractId, mapIndex, key, keyType, group);
+        return {
+            ...generatedContract,
+            address: (0, utils_1.addressFromContractId)(contractId),
+            contractId: contractId,
+            fieldsSig: getContractFieldsSig(valueType),
+            fields,
+            asset: { alphAmount: constants_1.ONE_ALPH }
+        };
+    });
+}
+function mapsToExistingContracts(contract, parentContractId, group, initialMaps) {
+    const mapsSig = contract.mapsSig;
+    if (mapsSig === undefined)
+        return [];
+    const contractStates = [];
+    Object.keys(initialMaps).forEach((name) => {
+        const index = mapsSig.names.findIndex((n) => n === name);
+        if (index === -1)
+            throw new Error(`Map var ${name} does not exist in contract ${contract.name}`);
+        const mapType = mapsSig.types[`${index}`];
+        const states = mapToExistingContracts(contract, parentContractId, group, initialMaps[`${name}`], index, mapType);
+        contractStates.push(...states);
+    });
+    return contractStates;
+}
+async function testMethod(factory, methodName, params) {
     const txId = params?.txId ?? randomTxId();
-    const initialFields = params.initialFields === undefined ? {} : params.initialFields;
-    const apiParams = contract.contract.toApiTestContractParams(methodName, {
+    const contract = factory.contract;
+    const address = params.address ?? (0, utils_1.addressFromContractId)((0, utils_1.binToHex)(crypto.getRandomValues(new Uint8Array(32))));
+    const contractId = (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(address));
+    const group = params.group ?? 0;
+    const initialMaps = params.initialMaps ?? {};
+    const contractStates = mapsToExistingContracts(contract, contractId, group, initialMaps);
+    const apiParams = contract.toApiTestContractParams(methodName, {
         ...params,
+        address,
         txId: txId,
-        initialFields: addStdIdToFields(contract.contract, initialFields),
-        testArgs: params.testArgs === undefined ? {} : params.testArgs
+        initialFields: addStdIdToFields(contract, params.initialFields ?? {}),
+        testArgs: params.testArgs === undefined ? {} : params.testArgs,
+        existingContracts: (params.existingContracts ?? []).concat(contractStates)
     });
     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;
+    const maps = existingContractsToMaps(contract, address, group, apiResult, initialMaps);
+    const testResult = contract.fromApiTestContractResult(methodName, apiResult, txId);
+    contract.printDebugMessages(methodName, testResult.debugMessages);
+    return {
+        ...testResult,
+        maps
+    };
 }
 exports.testMethod = testMethod;
+function buildMapInfo(contract, fields) {
+    const mapsSig = contract.mapsSig;
+    if (mapsSig === undefined)
+        return [];
+    return mapsSig.names.map((name, index) => {
+        const mapType = mapsSig.types[`${index}`];
+        const value = (fields[`${name}`] ?? new Map());
+        const [keyType, valueType] = ralph.parseMapType(mapType);
+        return { name, value, keyType, valueType, index };
+    });
+}
+function extractFromEventLog(contract, result, allMaps, address, group) {
+    const parentContractId = (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(address));
+    const newInserted = [];
+    result.debugMessages.forEach((message) => {
+        if (message.contractAddress !== address)
+            return;
+        const decoded = ralph.tryDecodeMapDebugLog(message.message);
+        if (decoded === undefined)
+            return;
+        const map = allMaps[`${decoded.mapIndex}`];
+        const decodedKey = ralph.decodePrimitive(decoded.encodedKey, map.keyType);
+        const contractId = (0, utils_1.subContractId)(parentContractId, decoded.path, group);
+        if (!decoded.isInsert) {
+            map.value.delete(decodedKey);
+            return;
+        }
+        const state = result.contracts.find((s) => s.address === (0, utils_1.addressFromContractId)(contractId));
+        if (state === undefined) {
+            throw new Error(`Cannot find contract state for map value, map field: ${map.name}, value type: ${map.valueType}`);
+        }
+        newInserted.push(state.address);
+        const fieldsSig = getContractFieldsSig(map.valueType);
+        const fields = fromApiFields(state.immFields, state.mutFields, fieldsSig, contract.structs);
+        map.value.set(decodedKey, fields['value']);
+    });
+    return newInserted;
+}
+function updateMaps(contract, result, allMaps, address, group) {
+    const parentContractId = (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(address));
+    const updated = [];
+    allMaps.forEach((map) => {
+        Array.from(map.value.keys()).forEach((key) => {
+            const contractId = calcWrapperContractId(parentContractId, map.index, key, map.keyType, group);
+            const updatedState = result.contracts.find((s) => s.address === (0, utils_1.addressFromContractId)(contractId));
+            if (updatedState === undefined)
+                return;
+            updated.push(updatedState.address);
+            const fieldsSig = getContractFieldsSig(map.valueType);
+            const fields = fromApiFields(updatedState.immFields, updatedState.mutFields, fieldsSig, contract.structs);
+            map.value.set(key, fields['value']);
+        });
+    });
+    return updated;
+}
+function existingContractsToMaps(contract, address, group, result, maps) {
+    const allMaps = buildMapInfo(contract, maps);
+    const updated = updateMaps(contract, result, allMaps, address, group);
+    const newInserted = extractFromEventLog(contract, result, allMaps, address, group);
+    const mapEntries = updated.concat(newInserted);
+    const remainContracts = result.contracts.filter((c) => mapEntries.find((addr) => c.address === addr) === undefined);
+    result.contracts = remainContracts;
+    return allMaps.reduce((acc, map) => {
+        acc[`${map.name}`] = map.value;
+        return acc;
+    }, {});
+}
 class ContractInstance {
     constructor(address) {
         this.address = address;
@@ -1231,20 +1405,29 @@ async function fetchContractState(contract, instance) {
     };
 }
 exports.fetchContractState = fetchContractState;
-function subscribeContractCreatedEvent(options, fromCount) {
-    return subscribeEventsFromContract(options, exports.CreateContractEventAddress, Contract.ContractCreatedEventIndex, (event) => {
+function checkGroupIndex(groupIndex) {
+    if (groupIndex < 0 || groupIndex >= constants_1.TOTAL_NUMBER_OF_GROUPS) {
+        throw new Error(`Invalid group index ${groupIndex}, expected a value within the range [0, ${constants_1.TOTAL_NUMBER_OF_GROUPS})`);
+    }
+}
+function subscribeContractCreatedEvent(options, fromGroup, fromCount) {
+    checkGroupIndex(fromGroup);
+    const contractAddress = exports.CreateContractEventAddresses[`${fromGroup}`];
+    return subscribeEventsFromContract(options, contractAddress, Contract.ContractCreatedEventIndex, (event) => {
         return {
             ...decodeContractCreatedEvent(event),
-            contractAddress: exports.CreateContractEventAddress
+            contractAddress: contractAddress
         };
     }, fromCount);
 }
 exports.subscribeContractCreatedEvent = subscribeContractCreatedEvent;
-function subscribeContractDestroyedEvent(options, fromCount) {
-    return subscribeEventsFromContract(options, exports.DestroyContractEventAddress, Contract.ContractDestroyedEventIndex, (event) => {
+function subscribeContractDestroyedEvent(options, fromGroup, fromCount) {
+    checkGroupIndex(fromGroup);
+    const contractAddress = exports.DestroyContractEventAddresses[`${fromGroup}`];
+    return subscribeEventsFromContract(options, contractAddress, Contract.ContractDestroyedEventIndex, (event) => {
         return {
             ...decodeContractDestroyedEvent(event),
-            contractAddress: exports.DestroyContractEventAddress
+            contractAddress: contractAddress
         };
     }, fromCount);
 }

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

@@ -1,6 +1,7 @@
 import { Val } from '../api';
 import { Fields, FieldsSig, Struct } from './contract';
 export declare function encodeBool(bool: boolean): Uint8Array;
+export declare function decodeBool(bytes: Uint8Array): boolean;
 export declare function encodeI256(i256: bigint): Uint8Array;
 export declare function encodeU256(u256: bigint): Uint8Array;
 export declare function encodeByteVec(bytes: string): Uint8Array;
@@ -19,6 +20,21 @@ 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 splitFields(fieldsSig: FieldsSig): [FieldsSig, FieldsSig];
+export declare function parseMapType(type: string): [string, string];
+export declare function encodeMapPrefix(mapIndex: number): Uint8Array;
+export declare function calcFieldSize(type: string, isMutable: boolean, structs: Struct[]): {
+    immFields: number;
+    mutFields: number;
+};
+export declare function tryDecodeMapDebugLog(message: string): {
+    path: string;
+    mapIndex: number;
+    encodedKey: Uint8Array;
+    isInsert: boolean;
+} | undefined;
+export declare function decodePrimitive(value: Uint8Array, type: string): Val;
+export declare function primitiveToByteVec(value: Val, type: string): Uint8Array;
 export declare function flattenFields(fields: Fields, names: string[], types: string[], isMutable: boolean[], structs: Struct[]): {
     name: string;
     type: string;

package/dist/src/contract/ralph.js

@@ -18,10 +18,11 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildDebugBytecode = exports.encodeContractField = exports.buildContractByteCode = exports.buildScriptByteCode = exports.flattenFields = exports.encodeScriptField = exports.encodeScriptFieldAsString = exports.encodeVmAddress = exports.encodeVmByteVec = exports.encodeVmU256 = exports.encodeVmI256 = exports.encodeVmBool = exports.VmValType = exports.encodeAddress = exports.encodeByteVec = exports.encodeU256 = exports.encodeI256 = exports.encodeBool = void 0;
+exports.buildDebugBytecode = exports.encodeContractField = exports.buildContractByteCode = exports.buildScriptByteCode = exports.flattenFields = exports.primitiveToByteVec = exports.decodePrimitive = exports.tryDecodeMapDebugLog = exports.calcFieldSize = exports.encodeMapPrefix = exports.parseMapType = exports.splitFields = exports.encodeScriptField = exports.encodeScriptFieldAsString = exports.encodeVmAddress = exports.encodeVmByteVec = exports.encodeVmU256 = exports.encodeVmI256 = exports.encodeVmBool = exports.VmValType = exports.encodeAddress = exports.encodeByteVec = exports.encodeU256 = exports.encodeI256 = exports.decodeBool = exports.encodeBool = void 0;
 const buffer_1 = require("buffer/");
 const api_1 = require("../api");
 const utils_1 = require("../utils");
+const codec_1 = require("../codec");
 const bigIntZero = BigInt(0);
 class UnSigned {
 }
@@ -50,6 +51,13 @@ function encodeBool(bool) {
     return bool ? Uint8Array.from([1]) : Uint8Array.from([0]);
 }
 exports.encodeBool = encodeBool;
+function decodeBool(bytes) {
+    if (bytes.length !== 1) {
+        throw new Error(`Expected one byte for encoded bool, got ${bytes.length}`);
+    }
+    return bytes[0] === 1 ? true : false;
+}
+exports.decodeBool = decodeBool;
 function encodeI256(i256) {
     if (i256 >= bigIntZero) {
         return encodeI256Positive(i256);
@@ -250,6 +258,124 @@ function encodeScriptField(tpe, value) {
     throw invalidScriptField(tpe, value);
 }
 exports.encodeScriptField = encodeScriptField;
+function splitFields(fieldsSig) {
+    return fieldsSig.types.reduce(([mapFields, fieldsExceptMaps], type, index) => {
+        const fieldSig = type.startsWith('Map[') ? mapFields : fieldsExceptMaps;
+        fieldSig.names.push(fieldsSig.names[`${index}`]);
+        fieldSig.types.push(type);
+        fieldSig.isMutable.push(fieldsSig.isMutable[`${index}`]);
+        return [mapFields, fieldsExceptMaps];
+    }, [
+        { names: [], types: [], isMutable: [] },
+        { names: [], types: [], isMutable: [] }
+    ]);
+}
+exports.splitFields = splitFields;
+function parseMapType(type) {
+    if (!type.startsWith('Map[')) {
+        throw new Error(`Expected map type, got ${type}`);
+    }
+    const keyStartIndex = type.indexOf('[');
+    const keyEndIndex = type.indexOf(',');
+    return [type.slice(keyStartIndex + 1, keyEndIndex), type.slice(keyEndIndex + 1, type.length - 1)];
+}
+exports.parseMapType = parseMapType;
+function encodeMapPrefix(mapIndex) {
+    const str = `__map__${mapIndex}__`;
+    const bytes = new Uint8Array(str.length);
+    for (let i = 0; i < str.length; i += 1) {
+        bytes[i] = str.charCodeAt(i);
+    }
+    return bytes;
+}
+exports.encodeMapPrefix = encodeMapPrefix;
+function fromAscii(str) {
+    let result = '';
+    for (let i = 0; i < str.length; i += 2) {
+        const ascii = parseInt(str.slice(i, i + 2), 16);
+        result += String.fromCharCode(ascii);
+    }
+    return result;
+}
+function calcFieldSize(type, isMutable, structs) {
+    const struct = structs.find((s) => s.name === type);
+    if (struct !== undefined) {
+        return struct.fieldTypes.reduce((acc, fieldType, index) => {
+            const isFieldMutable = isMutable && struct.isMutable[`${index}`];
+            const subFieldSize = calcFieldSize(fieldType, isFieldMutable, structs);
+            return {
+                immFields: acc.immFields + subFieldSize.immFields,
+                mutFields: acc.mutFields + subFieldSize.mutFields
+            };
+        }, { immFields: 0, mutFields: 0 });
+    }
+    if (type.startsWith('[')) {
+        const [baseType, size] = (0, api_1.decodeArrayType)(type);
+        const base = calcFieldSize(baseType, isMutable, structs);
+        return { immFields: base.immFields * size, mutFields: base.mutFields * size };
+    }
+    return isMutable ? { immFields: 0, mutFields: 1 } : { immFields: 1, mutFields: 0 };
+}
+exports.calcFieldSize = calcFieldSize;
+function tryDecodeMapDebugLog(message) {
+    const prefix = '5f5f6d61705f5f'; // __map__
+    const parts = message.split(',');
+    if (!message.startsWith(prefix) || parts.length !== 2)
+        return undefined;
+    if (parts[1] !== 'true' && parts[1] !== 'false')
+        return undefined;
+    if (!(0, utils_1.isHexString)(parts[0]))
+        return undefined;
+    const remain = parts[0].slice(prefix.length);
+    const suffixIndex = remain.indexOf('5f5f'); // __
+    if (suffixIndex === -1)
+        return undefined;
+    const encodedMapIndex = remain.slice(0, suffixIndex);
+    const mapIndex = parseInt(fromAscii(encodedMapIndex));
+    const encodedKey = (0, utils_1.hexToBinUnsafe)(remain.slice(suffixIndex + 4));
+    const isInsert = parts[1] === 'true' ? true : false;
+    return { path: parts[0], mapIndex, encodedKey, isInsert };
+}
+exports.tryDecodeMapDebugLog = tryDecodeMapDebugLog;
+function decodePrimitive(value, type) {
+    switch (type) {
+        case 'Bool':
+            return decodeBool(value);
+        case 'I256':
+            return codec_1.compactSignedIntCodec.decodeI256(buffer_1.Buffer.from(value));
+        case 'U256':
+            return codec_1.compactUnsignedIntCodec.decodeU256(buffer_1.Buffer.from(value));
+        case 'ByteVec':
+            return (0, utils_1.binToHex)(value);
+        case 'Address':
+            return utils_1.bs58.encode(value);
+        default:
+            throw Error(`Expected primitive type, got ${type}`);
+    }
+}
+exports.decodePrimitive = decodePrimitive;
+function primitiveToByteVec(value, type) {
+    switch (type) {
+        case 'Bool':
+            const byte = (0, api_1.toApiBoolean)(value) ? 1 : 0;
+            return new Uint8Array([byte]);
+        case 'I256':
+            const i256 = (0, api_1.toApiNumber256)(value);
+            return encodeI256(BigInt(i256));
+        case 'U256':
+            const u256 = (0, api_1.toApiNumber256)(value);
+            return encodeU256(BigInt(u256));
+        case 'ByteVec':
+            const hexStr = (0, api_1.toApiByteVec)(value);
+            return encodeByteVec(hexStr);
+        case 'Address':
+            const address = (0, api_1.toApiAddress)(value);
+            return encodeAddress(address);
+        default:
+            throw Error(`Expected primitive type, got ${type}`);
+    }
+}
+exports.primitiveToByteVec = primitiveToByteVec;
 function flattenFields(fields, names, types, isMutable, structs) {
     return names.flatMap((name, index) => {
         if (!(name in fields)) {

package/dist/src/index.d.ts

@@ -6,5 +6,6 @@ export * from './transaction';
 export * from './token';
 export * from './constants';
 export * as web3 from './global';
+export * as codec from './codec';
 export * as utils from './utils';
 export * from './debug';

package/dist/src/index.js

@@ -43,7 +43,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.utils = exports.web3 = void 0;
+exports.utils = exports.codec = exports.web3 = void 0;
 BigInt.prototype['toJSON'] = function () {
     return this.toString();
 };
@@ -55,5 +55,6 @@ __exportStar(require("./transaction"), exports);
 __exportStar(require("./token"), exports);
 __exportStar(require("./constants"), exports);
 exports.web3 = __importStar(require("./global"));
+exports.codec = __importStar(require("./codec"));
 exports.utils = __importStar(require("./utils"));
 __exportStar(require("./debug"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.36.1",
+  "version": "0.38.0",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -27,7 +27,7 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "2.10.0",
+    "alephium_version": "2.11.0",
     "explorer_backend_version": "1.17.0"
   },
   "type": "commonjs",
@@ -43,7 +43,8 @@
     "elliptic": "6.5.4",
     "eventemitter3": "^4.0.7",
     "path-browserify": "^1.0.1",
-    "stream-browserify": "^3.0.0"
+    "stream-browserify": "^3.0.0",
+    "binary-parser": "2.2.1"
   },
   "devDependencies": {
     "@babel/eslint-parser": "^7.21.3",
@@ -89,7 +90,7 @@
     "build": "rm -rf dist/* && npx tsc --build . && webpack",
     "test": "jest -i --config ./jest-config.json",
     "update-schemas": "npm run update-schema:alephium && npm run update-schema:explorer",
-    "update-schema:alephium": "npx swagger-typescript-api --disable-throw-on-error -t ./configs -o ./src/api -n api-alephium.ts -p https://raw.githubusercontent.com/alephium/alephium/v${npm_package_config_alephium_version}/api/src/main/resources/openapi.json",
+    "update-schema:alephium": "npx swagger-typescript-api --disable-throw-on-error -t ./configs -o ./src/api -n api-alephium.ts -p https://raw.githubusercontent.com/alephium/alephium/rhone-upgrade/api/src/main/resources/openapi.json",
     "update-schema:explorer": "npx swagger-typescript-api --disable-throw-on-error -t ./configs -o ./src/api -n api-explorer.ts -p https://raw.githubusercontent.com/alephium/explorer-backend/v${npm_package_config_explorer_backend_version}/app/src/main/resources/explorer-backend-openapi.json",
     "check-versions": "node scripts/check-versions.js ${npm_package_config_alephium_version} ${npm_package_config_explorer_backend_version}"
   }

package/src/api/api-alephium.ts

@@ -424,6 +424,7 @@ export interface CompileContractResult {
   enums: Enum[]
   events: EventSig[]
   warnings: string[]
+  maps?: MapsSig
   stdInterfaceId?: string
 }
 
@@ -658,6 +659,11 @@ export interface InternalServerError {
   detail: string
 }
 
+export interface MapsSig {
+  names: string[]
+  types: string[]
+}
+
 export interface MemPooled {
   type: string
 }
@@ -1300,7 +1306,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 2.10.0
+ * @version 2.11.0
  * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

package/src/api/types.ts

@@ -22,7 +22,7 @@ import { assertType, bs58, Eq, isBase58, isHexString } from '../utils'
 import * as node from './api-alephium'
 
 export type Number256 = bigint | string
-export type Val = Number256 | boolean | string | Val[] | ValObject
+export type Val = Number256 | boolean | string | Val[] | ValObject | Map<Val, Val>
 // eslint-disable-next-line
 export interface ValObject extends Record<string, Val> {} // bypassing typescript recursive type limitations
 export type NamedVals = Record<string, Val>

package/src/codec/array-codec.ts

@@ -0,0 +1,63 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+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/>.
+*/
+import { Buffer } from 'buffer/'
+import { Parser } from 'binary-parser'
+import { compactSignedIntCodec, compactUnsignedIntCodec, DecodedCompactInt } from './compact-int-codec'
+import { Codec } from './codec'
+
+export interface DecodedArray<T> {
+  length: DecodedCompactInt
+  value: T[]
+}
+
+export class ArrayCodec<T> implements Codec<T[]> {
+  constructor(private childCodec: Codec<T>, public parser = ArrayCodec.arrayParser(childCodec.parser)) {}
+
+  encode(input: T[]): Buffer {
+    const result = [...compactSignedIntCodec.encodeI256(BigInt(input.length))]
+    for (const element of input) {
+      result.push(...this.childCodec.encode(element))
+    }
+    return Buffer.from(result)
+  }
+
+  decode(input: Buffer): T[] {
+    const result = this.parser.parse(input)
+    return result.value.map((v) => this.childCodec.decode(v.value))
+  }
+
+  static arrayParser(parser: Parser) {
+    return new Parser()
+      .nest('length', {
+        type: compactSignedIntCodec.parser
+      })
+      .array('value', {
+        length: function (ctx) {
+          return compactSignedIntCodec.toI32(this['length']! as any as DecodedCompactInt)
+        },
+        type: parser
+      })
+  }
+
+  fromArray(inputs: T[]): DecodedArray<T> {
+    return {
+      length: compactUnsignedIntCodec.fromU32(inputs.length),
+      value: inputs
+    }
+  }
+}