@alephium/web3 0.37.0 → 0.38.1

package/dist/src/codec/unlock-script-codec.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unlockScriptCodec = exports.UnlockScriptCodec = exports.P2SHCodec = void 0;
+/*
+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/>.
+*/
+const buffer_1 = require("buffer/");
+const binary_parser_1 = require("binary-parser");
+const array_codec_1 = require("./array-codec");
+const compact_int_codec_1 = require("./compact-int-codec");
+const script_codec_1 = require("./script-codec");
+const bytestring_codec_1 = require("./bytestring-codec");
+const lockup_script_codec_1 = require("./lockup-script-codec");
+class P2PKHCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start().buffer('publicKey', { length: 33 });
+    }
+    encode(input) {
+        return input.publicKey;
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+}
+const p2pkhCodec = new P2PKHCodec();
+class P2MPKHCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start().nest('publicKeys', {
+            type: array_codec_1.ArrayCodec.arrayParser(binary_parser_1.Parser.start()
+                .nest('publicKey', { type: p2pkhCodec.parser })
+                .nest('index', { type: compact_int_codec_1.compactUnsignedIntCodec.parser }))
+        });
+    }
+    encode(input) {
+        return buffer_1.Buffer.concat([
+            buffer_1.Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(input.publicKeys.length)),
+            ...input.publicKeys.value.map((v) => {
+                return buffer_1.Buffer.concat([v.publicKey.publicKey, buffer_1.Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(v.index))]);
+            })
+        ]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+}
+const p2mpkhCodec = new P2MPKHCodec();
+class ValCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start()
+            .int8('type')
+            .choice('val', {
+            tag: 'type',
+            choices: {
+                0x00: new binary_parser_1.Parser().uint8('value'),
+                0x01: compact_int_codec_1.compactSignedIntCodec.parser,
+                0x02: compact_int_codec_1.compactUnsignedIntCodec.parser,
+                0x03: bytestring_codec_1.byteStringCodec.parser,
+                0x04: lockup_script_codec_1.lockupScriptCodec.parser // Address
+            }
+        });
+    }
+    encode(input) {
+        const valType = input.type;
+        if (valType === 0x00) {
+            // Boolean
+            return buffer_1.Buffer.from([valType, input.val]);
+        }
+        else if (valType === 0x01) {
+            // I256
+            return buffer_1.Buffer.from([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
+        }
+        else if (valType === 0x02) {
+            // U256
+            return buffer_1.Buffer.from([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
+        }
+        else if (valType === 0x03) {
+            // ByteVec
+            return buffer_1.Buffer.from([valType, ...bytestring_codec_1.byteStringCodec.encode(input.val)]);
+        }
+        else if (valType === 0x04) {
+            // Address
+            return buffer_1.Buffer.from([valType, ...lockup_script_codec_1.lockupScriptCodec.encode(input.val)]);
+        }
+        else {
+            throw new Error(`ValCodec: unsupported val type: ${valType}`);
+        }
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+}
+const valCodec = new ValCodec();
+const valsCodec = new array_codec_1.ArrayCodec(valCodec);
+class P2SHCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start()
+            .nest('script', {
+            type: script_codec_1.scriptCodec.parser
+        })
+            .nest('params', {
+            type: valsCodec.parser
+        });
+    }
+    encode(input) {
+        return buffer_1.Buffer.concat([script_codec_1.scriptCodec.encode(input.script), valsCodec.encode(input.params.value)]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+}
+exports.P2SHCodec = P2SHCodec;
+const p2shCodec = new P2SHCodec();
+class UnlockScriptCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start()
+            .uint8('scriptType')
+            .choice('script', {
+            tag: 'scriptType',
+            choices: {
+                0: p2pkhCodec.parser,
+                1: p2mpkhCodec.parser,
+                2: p2shCodec.parser,
+                3: binary_parser_1.Parser.start() // TODO: SameAsPrevious, FIXME
+            }
+        });
+    }
+    encode(input) {
+        const scriptType = input.scriptType;
+        const inputUnLockScript = input.script;
+        const inputUnLockScriptType = buffer_1.Buffer.from([scriptType]);
+        if (scriptType === 0) {
+            // P2PKH
+            return buffer_1.Buffer.concat([inputUnLockScriptType, p2pkhCodec.encode(inputUnLockScript)]);
+        }
+        else if (scriptType === 1) {
+            // P2MPKH
+            return buffer_1.Buffer.concat([inputUnLockScriptType, p2mpkhCodec.encode(inputUnLockScript)]);
+        }
+        else if (scriptType === 2) {
+            // P2SH
+            return buffer_1.Buffer.concat([inputUnLockScriptType, p2shCodec.encode(input.script)]);
+        }
+        else if (scriptType === 3) {
+            // SameAsPrevious
+            return inputUnLockScriptType;
+        }
+        else {
+            throw new Error(`TODO: encode unlock script: ${scriptType}`);
+        }
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+}
+exports.UnlockScriptCodec = UnlockScriptCodec;
+exports.unlockScriptCodec = new UnlockScriptCodec();

package/dist/src/codec/unsigned-tx-codec.d.ts

@@ -0,0 +1,30 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { UnsignedTx as ApiUnsignedTx } from '../api/api-alephium';
+import { Script } from './script-codec';
+import { Option } from './option-codec';
+import { DecodedCompactInt } from './compact-int-codec';
+import { Input } from './input-codec';
+import { AssetOutput } from './asset-output-codec';
+import { DecodedArray } from './array-codec';
+import { Codec } from './codec';
+export interface UnsignedTx {
+    version: number;
+    networkId: number;
+    statefulScript: Option<Script>;
+    gasAmount: DecodedCompactInt;
+    gasPrice: DecodedCompactInt;
+    inputs: DecodedArray<Input>;
+    fixedOutputs: DecodedArray<AssetOutput>;
+}
+export declare class UnsignedTxCodec implements Codec<UnsignedTx> {
+    parser: Parser;
+    encode(decodedUnsignedTx: UnsignedTx): Buffer;
+    decode(input: Buffer): UnsignedTx;
+    encodeApiUnsignedTx(input: ApiUnsignedTx): Buffer;
+    decodeApiUnsignedTx(input: Buffer): ApiUnsignedTx;
+    static txId(unsignedTx: UnsignedTx): string;
+    static toApiUnsignedTx(unsigned: UnsignedTx): ApiUnsignedTx;
+    static fromApiUnsignedTx(unsignedTx: ApiUnsignedTx): UnsignedTx;
+}
+export declare const unsignedTxCodec: UnsignedTxCodec;

package/dist/src/codec/unsigned-tx-codec.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsignedTxCodec = exports.UnsignedTxCodec = void 0;
+/*
+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/>.
+*/
+const buffer_1 = require("buffer/");
+const binary_parser_1 = require("binary-parser");
+const utils_1 = require("../utils");
+const script_codec_1 = require("./script-codec");
+const compact_int_codec_1 = require("./compact-int-codec");
+const input_codec_1 = require("./input-codec");
+const asset_output_codec_1 = require("./asset-output-codec");
+const hash_1 = require("./hash");
+class UnsignedTxCodec {
+    constructor() {
+        this.parser = new binary_parser_1.Parser()
+            .uint8('version')
+            .uint8('networkId')
+            .nest('statefulScript', {
+            type: script_codec_1.statefulScriptCodecOpt.parser
+        })
+            .nest('gasAmount', {
+            type: compact_int_codec_1.compactSignedIntCodec.parser
+        })
+            .nest('gasPrice', {
+            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+        })
+            .nest('inputs', {
+            type: input_codec_1.inputsCodec.parser
+        })
+            .nest('fixedOutputs', {
+            type: asset_output_codec_1.assetOutputsCodec.parser
+        });
+    }
+    encode(decodedUnsignedTx) {
+        return buffer_1.Buffer.concat([
+            buffer_1.Buffer.from([decodedUnsignedTx.version, decodedUnsignedTx.networkId]),
+            script_codec_1.statefulScriptCodecOpt.encode(decodedUnsignedTx.statefulScript),
+            compact_int_codec_1.compactSignedIntCodec.encode(decodedUnsignedTx.gasAmount),
+            compact_int_codec_1.compactUnsignedIntCodec.encode(decodedUnsignedTx.gasPrice),
+            input_codec_1.inputsCodec.encode(decodedUnsignedTx.inputs.value),
+            asset_output_codec_1.assetOutputsCodec.encode(decodedUnsignedTx.fixedOutputs.value)
+        ]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+    encodeApiUnsignedTx(input) {
+        const decoded = UnsignedTxCodec.fromApiUnsignedTx(input);
+        return this.encode(decoded);
+    }
+    decodeApiUnsignedTx(input) {
+        const decoded = this.parser.parse(input);
+        return UnsignedTxCodec.toApiUnsignedTx(decoded);
+    }
+    static txId(unsignedTx) {
+        return (0, utils_1.binToHex)((0, hash_1.blakeHash)(exports.unsignedTxCodec.encode(unsignedTx)));
+    }
+    static toApiUnsignedTx(unsigned) {
+        const txId = UnsignedTxCodec.txId(unsigned);
+        const txIdBytes = (0, utils_1.hexToBinUnsafe)(txId);
+        const version = unsigned.version;
+        const networkId = unsigned.networkId;
+        const gasAmount = compact_int_codec_1.compactSignedIntCodec.toI32(unsigned.gasAmount);
+        const gasPrice = compact_int_codec_1.compactUnsignedIntCodec.toU256(unsigned.gasPrice).toString();
+        const inputs = input_codec_1.InputCodec.toAssetInputs(unsigned.inputs.value);
+        const fixedOutputs = asset_output_codec_1.AssetOutputCodec.toFixedAssetOutputs(txIdBytes, unsigned.fixedOutputs.value);
+        let scriptOpt = undefined;
+        if (unsigned.statefulScript.option === 1) {
+            scriptOpt = script_codec_1.scriptCodec.encode(unsigned.statefulScript.value).toString('hex');
+        }
+        return { txId, version, networkId, gasAmount, scriptOpt, gasPrice, inputs, fixedOutputs };
+    }
+    static fromApiUnsignedTx(unsignedTx) {
+        const version = unsignedTx.version;
+        const networkId = unsignedTx.networkId;
+        const gasAmount = compact_int_codec_1.compactSignedIntCodec.fromI32(unsignedTx.gasAmount);
+        const gasPrice = compact_int_codec_1.compactUnsignedIntCodec.fromU256(BigInt(unsignedTx.gasPrice));
+        const inputsValue = input_codec_1.InputCodec.fromAssetInputs(unsignedTx.inputs);
+        const inputs = input_codec_1.inputsCodec.fromArray(inputsValue);
+        const fixedOutputsValue = asset_output_codec_1.AssetOutputCodec.fromFixedAssetOutputs(unsignedTx.fixedOutputs);
+        const fixedOutputs = asset_output_codec_1.assetOutputsCodec.fromArray(fixedOutputsValue);
+        const statefulScript = script_codec_1.statefulScriptCodecOpt.fromBuffer(unsignedTx.scriptOpt ? buffer_1.Buffer.from(unsignedTx.scriptOpt, 'hex') : undefined);
+        return { version, networkId, gasAmount, gasPrice, inputs, fixedOutputs, statefulScript };
+    }
+}
+exports.UnsignedTxCodec = UnsignedTxCodec;
+exports.unsignedTxCodec = new UnsignedTxCodec();

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

@@ -3,6 +3,7 @@ import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScri
 import { Optional } from '../utils';
 import { EventSubscribeOptions, EventSubscription } from './events';
 export type FieldsSig = node.FieldsSig;
+export type MapsSig = node.MapsSig;
 export type EventSig = node.EventSig;
 export type FunctionSig = node.FunctionSig;
 export type Fields = NamedVals;
@@ -130,10 +131,11 @@ export declare class Contract extends Artifact {
     readonly constants: Constant[];
     readonly enums: Enum[];
     readonly structs: Struct[];
+    readonly mapsSig?: MapsSig;
     readonly stdInterfaceId?: HexString;
     readonly bytecodeDebug: string;
     readonly codeHashDebug: string;
-    constructor(version: string, name: string, bytecode: string, bytecodeDebugPatch: string, codeHash: string, codeHashDebug: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[], constants: Constant[], enums: Enum[], structs: Struct[], stdInterfaceId?: HexString);
+    constructor(version: string, name: string, bytecode: string, bytecodeDebugPatch: string, codeHash: string, codeHashDebug: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[], constants: Constant[], enums: Enum[], structs: Struct[], mapsSig?: MapsSig, stdInterfaceId?: HexString);
     static fromJson(artifact: any, bytecodeDebugPatch?: string, codeHashDebug?: string, structs?: Struct[]): Contract;
     static fromCompileResult(result: node.CompileContractResult, structs?: Struct[]): Contract;
     static fromArtifactFile(path: string, bytecodeDebugPatch: string, codeHashDebug: string, structs?: Struct[]): Promise<Contract>;
@@ -196,7 +198,8 @@ export interface ContractState<T extends Fields = Fields> {
     fieldsSig: FieldsSig;
     asset: Asset;
 }
-export interface TestContractParams<F extends Fields = Fields, A extends Arguments = Arguments> {
+export type TestContractParamsWithoutMaps<F extends Fields = Fields, A extends Arguments = Arguments> = Omit<TestContractParams<F, A>, 'initialMaps'>;
+export interface TestContractParams<F extends Fields = Fields, A extends Arguments = Arguments, M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>> {
     group?: number;
     address?: string;
     callerAddress?: string;
@@ -204,6 +207,7 @@ export interface TestContractParams<F extends Fields = Fields, A extends Argumen
     blockTimeStamp?: number;
     txId?: string;
     initialFields: F;
+    initialMaps?: M;
     initialAsset?: Asset;
     testArgs: A;
     existingContracts?: ContractState[];
@@ -218,11 +222,13 @@ export interface ContractEvent<T extends Fields = Fields> {
     fields: T;
 }
 export type DebugMessage = node.DebugMessage;
-export interface TestContractResult<R> {
+export type TestContractResultWithoutMaps<R> = Omit<TestContractResult<R>, 'maps'>;
+export interface TestContractResult<R, M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>> {
     contractId: string;
     contractAddress: string;
     returns: R;
     gasUsed: number;
+    maps?: M;
     contracts: ContractState[];
     txOutputs: Output[];
     events: ContractEvent[];
@@ -315,7 +321,7 @@ export declare function subscribeEventsFromContract<T extends Fields, M extends
 export declare function addStdIdToFields<F extends Fields>(contract: Contract, fields: F): F | (F & {
     __stdInterfaceId: HexString;
 });
-export declare function testMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, methodName: string, params: Optional<TestContractParams<F, A>, 'testArgs' | 'initialFields'>): Promise<TestContractResult<R>>;
+export declare function testMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R, M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>>(factory: ContractFactory<I, F>, methodName: string, params: Optional<TestContractParams<F, A, M>, 'testArgs' | 'initialFields'>): Promise<TestContractResult<R, M>>;
 export declare abstract class ContractInstance {
     readonly address: Address;
     readonly contractId: string;

package/dist/src/contract/contract.js

@@ -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;
         }
@@ -1200,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;

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;