@alephium/web3 0.37.0 → 0.38.1

package/src/codec/unlock-script-codec.ts

@@ -0,0 +1,194 @@
+/*
+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 { ArrayCodec, DecodedArray } from './array-codec'
+import { compactUnsignedIntCodec, compactSignedIntCodec, DecodedCompactInt } from './compact-int-codec'
+import { Codec } from './codec'
+import { Script, scriptCodec } from './script-codec'
+import { ByteString, byteStringCodec } from './bytestring-codec'
+import { LockupScript, lockupScriptCodec } from './lockup-script-codec'
+
+export interface P2PKH {
+  publicKey: Buffer
+}
+
+class P2PKHCodec implements Codec<P2PKH> {
+  parser = Parser.start().buffer('publicKey', { length: 33 })
+
+  encode(input: P2PKH): Buffer {
+    return input.publicKey
+  }
+
+  decode(input: Buffer): P2PKH {
+    return this.parser.parse(input)
+  }
+}
+const p2pkhCodec = new P2PKHCodec()
+
+export interface P2MPKH {
+  publicKeys: DecodedArray<{
+    publicKey: P2PKH
+    index: DecodedCompactInt
+  }>
+}
+
+class P2MPKHCodec implements Codec<P2MPKH> {
+  parser = Parser.start().nest('publicKeys', {
+    type: ArrayCodec.arrayParser(
+      Parser.start()
+        .nest('publicKey', { type: p2pkhCodec.parser })
+        .nest('index', { type: compactUnsignedIntCodec.parser })
+    )
+  })
+
+  encode(input: P2MPKH): Buffer {
+    return Buffer.concat([
+      Buffer.from(compactUnsignedIntCodec.encode(input.publicKeys.length)),
+      ...input.publicKeys.value.map((v) => {
+        return Buffer.concat([v.publicKey.publicKey, Buffer.from(compactUnsignedIntCodec.encode(v.index))])
+      })
+    ])
+  }
+
+  decode(input: Buffer): any {
+    return this.parser.parse(input)
+  }
+}
+const p2mpkhCodec = new P2MPKHCodec()
+
+export interface Val {
+  type: number
+  val: number | DecodedCompactInt | ByteString | LockupScript
+}
+class ValCodec implements Codec<Val> {
+  parser = Parser.start()
+    .int8('type')
+    .choice('val', {
+      tag: 'type',
+      choices: {
+        0x00: new Parser().uint8('value'), // Boolean
+        0x01: compactSignedIntCodec.parser, // I256
+        0x02: compactUnsignedIntCodec.parser, // U256
+        0x03: byteStringCodec.parser, // ByteVec
+        0x04: lockupScriptCodec.parser // Address
+      }
+    })
+
+  encode(input: Val): Buffer {
+    const valType = input.type
+
+    if (valType === 0x00) {
+      // Boolean
+      return Buffer.from([valType, input.val as number])
+    } else if (valType === 0x01) {
+      // I256
+      return Buffer.from([valType, ...compactUnsignedIntCodec.encode(input.val as DecodedCompactInt)])
+    } else if (valType === 0x02) {
+      // U256
+      return Buffer.from([valType, ...compactUnsignedIntCodec.encode(input.val as DecodedCompactInt)])
+    } else if (valType === 0x03) {
+      // ByteVec
+      return Buffer.from([valType, ...byteStringCodec.encode(input.val as ByteString)])
+    } else if (valType === 0x04) {
+      // Address
+      return Buffer.from([valType, ...lockupScriptCodec.encode(input.val as LockupScript)])
+    } else {
+      throw new Error(`ValCodec: unsupported val type: ${valType}`)
+    }
+  }
+
+  decode(input: Buffer): Val {
+    return this.parser.parse(input)
+  }
+}
+
+const valCodec = new ValCodec()
+const valsCodec = new ArrayCodec(valCodec)
+
+export interface P2SH {
+  script: Script
+  params: DecodedArray<Val>
+}
+
+export class P2SHCodec implements Codec<P2SH> {
+  parser = Parser.start()
+    .nest('script', {
+      type: scriptCodec.parser
+    })
+    .nest('params', {
+      type: valsCodec.parser
+    })
+
+  encode(input: P2SH): Buffer {
+    return Buffer.concat([scriptCodec.encode(input.script), valsCodec.encode(input.params.value)])
+  }
+
+  decode(input: Buffer): P2SH {
+    return this.parser.parse(input)
+  }
+}
+
+const p2shCodec = new P2SHCodec()
+
+export interface UnlockScript {
+  scriptType: number
+  script: P2PKH | P2MPKH | P2SH
+}
+
+export class UnlockScriptCodec implements Codec<UnlockScript> {
+  parser = Parser.start()
+    .uint8('scriptType')
+    .choice('script', {
+      tag: 'scriptType',
+      choices: {
+        0: p2pkhCodec.parser,
+        1: p2mpkhCodec.parser,
+        2: p2shCodec.parser,
+        3: Parser.start() // TODO: SameAsPrevious, FIXME
+      }
+    })
+
+  encode(input: UnlockScript): Buffer {
+    const scriptType = input.scriptType
+    const inputUnLockScript = input.script
+    const inputUnLockScriptType = Buffer.from([scriptType])
+
+    if (scriptType === 0) {
+      // P2PKH
+      return Buffer.concat([inputUnLockScriptType, p2pkhCodec.encode(inputUnLockScript as P2PKH)])
+    } else if (scriptType === 1) {
+      // P2MPKH
+      return Buffer.concat([inputUnLockScriptType, p2mpkhCodec.encode(inputUnLockScript as P2MPKH)])
+    } else if (scriptType === 2) {
+      // P2SH
+      return Buffer.concat([inputUnLockScriptType, p2shCodec.encode(input.script as P2SH)])
+    } else if (scriptType === 3) {
+      // SameAsPrevious
+      return inputUnLockScriptType
+    } else {
+      throw new Error(`TODO: encode unlock script: ${scriptType}`)
+    }
+  }
+
+  decode(input: Buffer): UnlockScript {
+    return this.parser.parse(input)
+  }
+}
+
+export const unlockScriptCodec = new UnlockScriptCodec()

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

@@ -0,0 +1,124 @@
+/*
+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 { UnsignedTx as ApiUnsignedTx } from '../api/api-alephium'
+import { binToHex, hexToBinUnsafe } from '../utils'
+import { Script, scriptCodec, statefulScriptCodecOpt } from './script-codec'
+import { Option } from './option-codec'
+import { DecodedCompactInt, compactSignedIntCodec, compactUnsignedIntCodec } from './compact-int-codec'
+import { Input, InputCodec, inputsCodec } from './input-codec'
+import { AssetOutput, AssetOutputCodec, assetOutputsCodec } from './asset-output-codec'
+import { DecodedArray } from './array-codec'
+import { blakeHash } from './hash'
+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 class UnsignedTxCodec implements Codec<UnsignedTx> {
+  parser = new Parser()
+    .uint8('version')
+    .uint8('networkId')
+    .nest('statefulScript', {
+      type: statefulScriptCodecOpt.parser
+    })
+    .nest('gasAmount', {
+      type: compactSignedIntCodec.parser
+    })
+    .nest('gasPrice', {
+      type: compactUnsignedIntCodec.parser
+    })
+    .nest('inputs', {
+      type: inputsCodec.parser
+    })
+    .nest('fixedOutputs', {
+      type: assetOutputsCodec.parser
+    })
+
+  encode(decodedUnsignedTx: UnsignedTx): Buffer {
+    return Buffer.concat([
+      Buffer.from([decodedUnsignedTx.version, decodedUnsignedTx.networkId]),
+      statefulScriptCodecOpt.encode(decodedUnsignedTx.statefulScript),
+      compactSignedIntCodec.encode(decodedUnsignedTx.gasAmount),
+      compactUnsignedIntCodec.encode(decodedUnsignedTx.gasPrice),
+      inputsCodec.encode(decodedUnsignedTx.inputs.value),
+      assetOutputsCodec.encode(decodedUnsignedTx.fixedOutputs.value)
+    ])
+  }
+
+  decode(input: Buffer): UnsignedTx {
+    return this.parser.parse(input)
+  }
+
+  encodeApiUnsignedTx(input: ApiUnsignedTx): Buffer {
+    const decoded = UnsignedTxCodec.fromApiUnsignedTx(input)
+    return this.encode(decoded)
+  }
+
+  decodeApiUnsignedTx(input: Buffer): ApiUnsignedTx {
+    const decoded = this.parser.parse(input)
+    return UnsignedTxCodec.toApiUnsignedTx(decoded)
+  }
+
+  static txId(unsignedTx: UnsignedTx): string {
+    return binToHex(blakeHash(unsignedTxCodec.encode(unsignedTx)))
+  }
+
+  static toApiUnsignedTx(unsigned: UnsignedTx): ApiUnsignedTx {
+    const txId = UnsignedTxCodec.txId(unsigned)
+    const txIdBytes = hexToBinUnsafe(txId)
+    const version = unsigned.version
+    const networkId = unsigned.networkId
+    const gasAmount = compactSignedIntCodec.toI32(unsigned.gasAmount)
+    const gasPrice = compactUnsignedIntCodec.toU256(unsigned.gasPrice).toString()
+    const inputs = InputCodec.toAssetInputs(unsigned.inputs.value)
+    const fixedOutputs = AssetOutputCodec.toFixedAssetOutputs(txIdBytes, unsigned.fixedOutputs.value)
+    let scriptOpt: string | undefined = undefined
+    if (unsigned.statefulScript.option === 1) {
+      scriptOpt = scriptCodec.encode(unsigned.statefulScript.value!).toString('hex')
+    }
+
+    return { txId, version, networkId, gasAmount, scriptOpt, gasPrice, inputs, fixedOutputs }
+  }
+
+  static fromApiUnsignedTx(unsignedTx: ApiUnsignedTx): UnsignedTx {
+    const version = unsignedTx.version
+    const networkId = unsignedTx.networkId
+    const gasAmount = compactSignedIntCodec.fromI32(unsignedTx.gasAmount)
+    const gasPrice = compactUnsignedIntCodec.fromU256(BigInt(unsignedTx.gasPrice))
+    const inputsValue = InputCodec.fromAssetInputs(unsignedTx.inputs)
+    const inputs = inputsCodec.fromArray(inputsValue)
+    const fixedOutputsValue = AssetOutputCodec.fromFixedAssetOutputs(unsignedTx.fixedOutputs)
+    const fixedOutputs = assetOutputsCodec.fromArray(fixedOutputsValue)
+    const statefulScript = statefulScriptCodecOpt.fromBuffer(
+      unsignedTx.scriptOpt ? Buffer.from(unsignedTx.scriptOpt, 'hex') : undefined
+    )
+
+    return { version, networkId, gasAmount, gasPrice, inputs, fixedOutputs, statefulScript }
+  }
+}
+
+export const unsignedTxCodec = new UnsignedTxCodec()

package/src/contract/contract.ts

@@ -57,7 +57,8 @@ import {
   WebCrypto,
   hexToBinUnsafe,
   isDevnet,
-  addressFromContractId
+  addressFromContractId,
+  subContractId
 } from '../utils'
 import { getCurrentNodeProvider } from '../global'
 import * as path from 'path'
@@ -66,10 +67,24 @@ import { ONE_ALPH, TOTAL_NUMBER_OF_GROUPS } from '../constants'
 import * as blake from 'blakejs'
 import { parseError } from '../utils/error'
 import { isContractDebugMessageEnabled } from '../debug'
+import {
+  contract,
+  Method,
+  LoadLocal,
+  LoadImmFieldByIndex,
+  LoadMutFieldByIndex,
+  CallerContractId,
+  LoadImmField,
+  ByteVecEq,
+  Assert,
+  StoreMutFieldByIndex,
+  DestroySelf
+} from '../codec'
 
 const crypto = new WebCrypto()
 
 export type FieldsSig = node.FieldsSig
+export type MapsSig = node.MapsSig
 export type EventSig = node.EventSig
 export type FunctionSig = node.FunctionSig
 export type Fields = NamedVals
@@ -890,6 +905,7 @@ export class Contract extends Artifact {
   readonly constants: Constant[]
   readonly enums: Enum[]
   readonly structs: Struct[]
+  readonly mapsSig?: MapsSig
   readonly stdInterfaceId?: HexString
 
   readonly bytecodeDebug: string
@@ -908,6 +924,7 @@ export class Contract extends Artifact {
     constants: Constant[],
     enums: Enum[],
     structs: Struct[],
+    mapsSig?: MapsSig,
     stdInterfaceId?: HexString
   ) {
     super(version, name, functions)
@@ -919,6 +936,7 @@ export 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)
@@ -953,6 +971,7 @@ export class Contract extends Artifact {
       artifact.constants,
       artifact.enums,
       structs,
+      artifact.mapsSig === null ? undefined : artifact.mapsSig,
       artifact.stdInterfaceId === null ? undefined : artifact.stdInterfaceId
     )
     return contract
@@ -972,6 +991,7 @@ export class Contract extends Artifact {
       result.constants,
       result.enums,
       structs,
+      result.maps,
       result.stdInterfaceId
     )
   }
@@ -1000,6 +1020,9 @@ export 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
     }
@@ -1542,7 +1565,16 @@ function toApiInputAssets(inputAssets?: InputAsset[]): node.TestInputAsset[] | u
   return typeof inputAssets !== 'undefined' ? inputAssets.map(toApiInputAsset) : undefined
 }
 
-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 // default 0
   address?: string
   callerAddress?: string
@@ -1550,6 +1582,7 @@ export interface TestContractParams<F extends Fields = Fields, A extends Argumen
   blockTimeStamp?: number
   txId?: string
   initialFields: F
+  initialMaps?: M
   initialAsset?: Asset // default 1 ALPH
   testArgs: A
   existingContracts?: ContractState[] // default no existing contracts
@@ -1567,11 +1600,14 @@ export interface ContractEvent<T extends Fields = Fields> {
 
 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[]
@@ -1824,23 +1860,244 @@ export function addStdIdToFields<F extends Fields>(
     : { ...fields, __stdInterfaceId: stdInterfaceIdPrefix + contract.stdInterfaceId }
 }
 
-export async function testMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(
-  contract: ContractFactory<I, F>,
+function calcWrapperContractId(
+  parentContractId: string,
+  mapIndex: number,
+  key: Val,
+  keyType: string,
+  group: number
+): string {
+  const prefix = ralph.encodeMapPrefix(mapIndex)
+  const encodedKey = ralph.primitiveToByteVec(key, keyType)
+  const path = binToHex(prefix) + binToHex(encodedKey)
+  return subContractId(parentContractId, path, group)
+}
+
+function genCodeForType(type: string, structs: Struct[]): { bytecode: string; codeHash: string } {
+  const { immFields, mutFields } = ralph.calcFieldSize(type, true, structs)
+  const loadImmFieldByIndex: Method = {
+    isPublic: true,
+    assetModifier: 0,
+    argsLength: 1,
+    localsLength: 1,
+    returnLength: 1,
+    instrs: [LoadLocal(0), LoadImmFieldByIndex]
+  }
+  const loadMutFieldByIndex: Method = {
+    ...loadImmFieldByIndex,
+    instrs: [LoadLocal(0), LoadMutFieldByIndex]
+  }
+  const parentContractIdIndex = immFields
+  const storeMutFieldByIndex: Method = {
+    ...loadImmFieldByIndex,
+    argsLength: 2,
+    localsLength: 2,
+    returnLength: 0,
+    instrs: [
+      CallerContractId,
+      LoadImmField(parentContractIdIndex),
+      ByteVecEq,
+      Assert,
+      LoadLocal(0), // value
+      LoadLocal(1), // index
+      StoreMutFieldByIndex
+    ]
+  }
+  const destroy: Method = {
+    isPublic: true,
+    assetModifier: 2,
+    argsLength: 1,
+    localsLength: 1,
+    returnLength: 0,
+    instrs: [CallerContractId, LoadImmField(parentContractIdIndex), ByteVecEq, Assert, LoadLocal(0), DestroySelf]
+  }
+  const c = {
+    fieldLength: immFields + mutFields + 1, // parentContractId
+    methods: [loadImmFieldByIndex, loadMutFieldByIndex, storeMutFieldByIndex, destroy]
+  }
+  const bytecode = contract.contractCodec.encode(contract.toHalfDecoded(c))
+  const codeHash = blake.blake2b(bytecode, undefined, 32)
+  return { bytecode: binToHex(bytecode), codeHash: binToHex(codeHash) }
+}
+
+function getContractFieldsSig(mapValueType: string): FieldsSig {
+  return {
+    names: ['value', 'parentContractId'],
+    types: [mapValueType, 'ByteVec'],
+    isMutable: [true, false]
+  }
+}
+
+function mapToExistingContracts(
+  contract: Contract,
+  parentContractId: string,
+  group: number,
+  map: Map<Val, Val>,
+  mapIndex: number,
+  type: string
+): ContractState[] {
+  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: addressFromContractId(contractId),
+      contractId: contractId,
+      fieldsSig: getContractFieldsSig(valueType),
+      fields,
+      asset: { alphAmount: ONE_ALPH }
+    }
+  })
+}
+
+function mapsToExistingContracts(
+  contract: Contract,
+  parentContractId: string,
+  group: number,
+  initialMaps: Record<string, Map<Val, Val>>
+) {
+  const mapsSig = contract.mapsSig
+  if (mapsSig === undefined) return []
+  const contractStates: ContractState[] = []
+  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
+}
+
+export async 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>, 'testArgs' | 'initialFields'>
-): Promise<TestContractResult<R>> {
+  params: Optional<TestContractParams<F, A, M>, 'testArgs' | 'initialFields'>
+): Promise<TestContractResult<R, M>> {
   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 ?? addressFromContractId(binToHex(crypto.getRandomValues(new Uint8Array(32))))
+  const contractId = binToHex(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 getCurrentNodeProvider().contracts.postContractsTestContract(apiParams)
-  const testResult = contract.contract.fromApiTestContractResult(methodName, apiResult, txId)
-  contract.contract.printDebugMessages(methodName, testResult.debugMessages)
-  return testResult as TestContractResult<R>
+  const maps = existingContractsToMaps(contract, address, group, apiResult, initialMaps)
+  const testResult = contract.fromApiTestContractResult(methodName, apiResult, txId)
+  contract.printDebugMessages(methodName, testResult.debugMessages)
+  return {
+    ...testResult,
+    maps
+  } as TestContractResult<R, M>
+}
+
+interface MapInfo {
+  name: string
+  value: Map<Val, Val>
+  keyType: string
+  valueType: string
+  index: number
+}
+
+function buildMapInfo(contract: Contract, fields: Fields): MapInfo[] {
+  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<Val, Val>()) as Map<Val, Val>
+    const [keyType, valueType] = ralph.parseMapType(mapType)
+    return { name, value, keyType, valueType, index }
+  })
+}
+
+function extractFromEventLog(
+  contract: Contract,
+  result: node.TestContractResult,
+  allMaps: MapInfo[],
+  address: string,
+  group: number
+): string[] {
+  const parentContractId = binToHex(contractIdFromAddress(address))
+  const newInserted: string[] = []
+  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 = subContractId(parentContractId, decoded.path, group)
+    if (!decoded.isInsert) {
+      map.value.delete(decodedKey)
+      return
+    }
+    const state = result.contracts.find((s) => s.address === 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: Contract,
+  result: node.TestContractResult,
+  allMaps: MapInfo[],
+  address: Address,
+  group: number
+): string[] {
+  const parentContractId = binToHex(contractIdFromAddress(address))
+  const updated: string[] = []
+  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 === 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: Contract,
+  address: Address,
+  group: number,
+  result: node.TestContractResult,
+  maps: Record<string, Map<Val, Val>>
+): Record<string, Map<Val, Val>> {
+  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
+  }, {})
 }
 
 export abstract class ContractInstance {