@alephium/web3 1.7.1 → 1.7.3

package/dist/src/address/address.d.ts

@@ -1,4 +1,5 @@
 import { KeyType } from '../signer';
+import { LockupScript } from '../codec/lockup-script-codec';
 export declare enum AddressType {
     P2PKH = 0,
     P2MPKH = 1,
@@ -20,4 +21,4 @@ export declare function addressFromContractId(contractId: string): string;
 export declare function addressFromTokenId(tokenId: string): string;
 export declare function contractIdFromTx(txId: string, outputIndex: number): string;
 export declare function subContractId(parentContractId: string, pathInHex: string, group: number): string;
-export declare function xorByte(intValue: number): number;
+export declare function groupOfLockupScript(lockupScript: LockupScript): number;

package/dist/src/address/address.js

@@ -20,16 +20,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.xorByte = exports.subContractId = exports.contractIdFromTx = exports.addressFromTokenId = exports.addressFromContractId = exports.addressFromScript = exports.addressFromPublicKey = exports.publicKeyFromPrivateKey = exports.groupOfPrivateKey = exports.tokenIdFromAddress = exports.contractIdFromAddress = exports.groupOfAddress = exports.isContractAddress = exports.isAssetAddress = exports.isValidAddress = exports.validateAddress = exports.AddressType = void 0;
+exports.groupOfLockupScript = exports.subContractId = exports.contractIdFromTx = exports.addressFromTokenId = exports.addressFromContractId = exports.addressFromScript = exports.addressFromPublicKey = exports.publicKeyFromPrivateKey = exports.groupOfPrivateKey = exports.tokenIdFromAddress = exports.contractIdFromAddress = exports.groupOfAddress = exports.isContractAddress = exports.isAssetAddress = exports.isValidAddress = exports.validateAddress = exports.AddressType = void 0;
 const elliptic_1 = require("elliptic");
 const bn_js_1 = __importDefault(require("bn.js"));
 const constants_1 = require("../constants");
 const blakejs_1 = __importDefault(require("blakejs"));
 const bs58_1 = __importDefault(require("../utils/bs58"));
-const djb2_1 = __importDefault(require("../utils/djb2"));
 const utils_1 = require("../utils");
 const lockup_script_codec_1 = require("../codec/lockup-script-codec");
 const codec_1 = require("../codec");
+const djb2_1 = __importDefault(require("../utils/djb2"));
 const ec = new elliptic_1.ec('secp256k1');
 const PublicKeyHashSize = 32;
 var AddressType;
@@ -120,23 +120,17 @@ function groupOfAddress(address) {
     }
 }
 exports.groupOfAddress = groupOfAddress;
-function groupOfAddressBytes(bytes) {
-    const hint = (0, djb2_1.default)(bytes) | 1;
-    const hash = xorByte(hint);
-    const group = hash % constants_1.TOTAL_NUMBER_OF_GROUPS;
-    return group;
-}
 // Pay to public key hash address
 function groupOfP2pkhAddress(address) {
-    return groupOfAddressBytes(address);
+    return groupFromBytesForAssetAddress(address);
 }
 // Pay to multiple public key hash address
 function groupOfP2mpkhAddress(address) {
-    return groupOfAddressBytes(address.slice(1, 33));
+    return groupFromBytesForAssetAddress(address.slice(1, 33));
 }
 // Pay to script hash address
 function groupOfP2shAddress(address) {
-    return groupOfAddressBytes(address);
+    return groupFromBytesForAssetAddress(address);
 }
 function contractIdFromAddress(address) {
     return idFromAddress(address);
@@ -228,11 +222,25 @@ function subContractId(parentContractId, pathInHex, group) {
     return (0, utils_1.binToHex)(bytes);
 }
 exports.subContractId = subContractId;
-function xorByte(intValue) {
-    const byte0 = (intValue >> 24) & 0xff;
-    const byte1 = (intValue >> 16) & 0xff;
-    const byte2 = (intValue >> 8) & 0xff;
-    const byte3 = intValue & 0xff;
-    return (byte0 ^ byte1 ^ byte2 ^ byte3) & 0xff;
-}
-exports.xorByte = xorByte;
+function groupOfLockupScript(lockupScript) {
+    if (lockupScript.kind === 'P2PKH') {
+        return groupFromBytesForAssetAddress(lockupScript.value);
+    }
+    else if (lockupScript.kind === 'P2MPKH') {
+        return groupFromBytesForAssetAddress(lockupScript.value.publicKeyHashes[0]);
+    }
+    else if (lockupScript.kind === 'P2SH') {
+        return groupFromBytesForAssetAddress(lockupScript.value);
+    }
+    else {
+        // P2C
+        const contractId = lockupScript.value;
+        return contractId[`${contractId.length - 1}`];
+    }
+}
+exports.groupOfLockupScript = groupOfLockupScript;
+function groupFromBytesForAssetAddress(bytes) {
+    const hint = (0, djb2_1.default)(bytes) | 1;
+    const hash = (0, utils_1.xorByte)(hint);
+    return hash % constants_1.TOTAL_NUMBER_OF_GROUPS;
+}

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

@@ -121,6 +121,9 @@ export interface ContractState<T extends Fields = Fields> {
     fieldsSig: FieldsSig;
     asset: Asset;
 }
+export interface ContractStateWithMaps<T extends Fields = Fields, M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>> extends ContractState<T> {
+    maps?: M;
+}
 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;
@@ -133,7 +136,7 @@ export interface TestContractParams<F extends Fields = Fields, A extends Argumen
     initialMaps?: M;
     initialAsset?: Asset;
     testArgs: A;
-    existingContracts?: ContractState[];
+    existingContracts?: ContractStateWithMaps[];
     inputAssets?: InputAsset[];
 }
 export interface ContractEvent<T extends Fields = Fields> {
@@ -152,7 +155,7 @@ export interface TestContractResult<R, M extends Record<string, Map<Val, Val>> =
     returns: R;
     gasUsed: number;
     maps?: M;
-    contracts: ContractState[];
+    contracts: ContractStateWithMaps[];
     txOutputs: Output[];
     events: ContractEvent[];
     debugMessages: DebugMessage[];
@@ -190,7 +193,7 @@ export declare abstract class ContractFactory<I extends ContractInstance, F exte
     abstract at(address: string): I;
     deploy(signer: SignerProvider, deployParams: DeployContractParams<F>): Promise<DeployContractResult<I>>;
     deployTemplate(signer: SignerProvider): Promise<DeployContractResult<I>>;
-    stateForTest(initFields: F, asset?: Asset, address?: string): ContractState<F>;
+    protected stateForTest_(initFields: F, asset?: Asset, address?: string, maps?: Record<string, Map<Val, Val>>): ContractState<F> | ContractStateWithMaps<F>;
 }
 export declare class ExecutableScript<P extends Fields = Fields, R extends Val | null = null> {
     readonly script: Script;
@@ -266,6 +269,10 @@ 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 extractMapsFromApiResult(selfAddress: string, params: Optional<TestContractParams, 'testArgs' | 'initialFields'>, group: number, apiResult: node.TestContractResult, getContractByCodeHash: (codeHash: string) => Contract): {
+    address: string;
+    maps: Record<string, Map<Val, Val>>;
+}[];
 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'>, getContractByCodeHash: (codeHash: string) => Contract): Promise<TestContractResult<R, M>>;
 export declare class RalphMap<K extends Val, V extends Val> {
     private readonly parentContract;

package/dist/src/contract/contract.js

@@ -40,7 +40,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTokenIdFromUnsignedTx = exports.getContractIdFromUnsignedTx = exports.getContractEventsCurrentCount = exports.multicallMethods = exports.signExecuteMethod = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.getMapItem = exports.RalphMap = 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.Struct = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = exports.StdIdFieldName = void 0;
+exports.getTokenIdFromUnsignedTx = exports.getContractIdFromUnsignedTx = exports.getContractEventsCurrentCount = exports.multicallMethods = exports.signExecuteMethod = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.getMapItem = exports.RalphMap = exports.testMethod = exports.extractMapsFromApiResult = 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.Struct = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = exports.StdIdFieldName = void 0;
 const fs_1 = require("fs");
 const api_1 = require("../api");
 const ralph = __importStar(require("./ralph"));
@@ -672,12 +672,18 @@ class ContractFactory {
         });
     }
     // This is used for testing contract functions
-    stateForTest(initFields, asset, address) {
+    stateForTest_(initFields, asset, address, maps) {
         const newAsset = {
-            alphAmount: asset?.alphAmount ?? constants_1.ONE_ALPH,
+            alphAmount: asset?.alphAmount ?? constants_1.MINIMAL_CONTRACT_DEPOSIT,
             tokens: asset?.tokens
         };
-        return this.contract.toState(addStdIdToFields(this.contract, initFields), newAsset, address);
+        const state = this.contract.toState(addStdIdToFields(this.contract, initFields), newAsset, address);
+        return {
+            ...state,
+            bytecode: this.contract.bytecodeDebug,
+            codeHash: this.contract.codeHash,
+            maps: maps
+        };
     }
 }
 exports.ContractFactory = ContractFactory;
@@ -875,29 +881,65 @@ function mapsToExistingContracts(contract, parentContractId, group, initialMaps)
     });
     return contractStates;
 }
+function hasMap(state) {
+    return state.maps !== undefined;
+}
+function getTestExistingContracts(selfContract, selfContractId, group, params, getContractByCodeHash) {
+    const selfMaps = params.initialMaps ?? {};
+    const selfMapEntries = mapsToExistingContracts(selfContract, selfContractId, group, selfMaps);
+    const existingContracts = params.existingContracts ?? [];
+    const existingMapEntries = existingContracts.flatMap((contractState) => {
+        return hasMap(contractState)
+            ? mapsToExistingContracts(getContractByCodeHash(contractState.codeHash), contractState.contractId, group, contractState.maps ?? {})
+            : [];
+    });
+    return existingContracts.concat(selfMapEntries, existingMapEntries);
+}
+function extractMapsFromApiResult(selfAddress, params, group, apiResult, getContractByCodeHash) {
+    const selfMaps = params.initialMaps ?? {};
+    const existingContracts = params.existingContracts ?? [];
+    const filtered = apiResult.contracts.filter((c) => c.address === selfAddress || existingContracts.find((s) => s.address === c.address) !== undefined);
+    const allMaps = [];
+    filtered.forEach((state) => {
+        const artifact = getContractByCodeHash(state.codeHash);
+        if (artifact.mapsSig !== undefined) {
+            const originMaps = state.address === selfAddress
+                ? selfMaps
+                : existingContracts.find((s) => s.address === state.address).maps;
+            const maps = existingContractsToMaps(artifact, state.address, group, apiResult, originMaps ?? {});
+            allMaps.push({ address: state.address, maps });
+        }
+    });
+    return allMaps;
+}
+exports.extractMapsFromApiResult = extractMapsFromApiResult;
 async function testMethod(factory, methodName, params, getContractByCodeHash) {
     const txId = params?.txId ?? randomTxId();
-    const contract = factory.contract;
-    const address = params.address ?? (0, address_1.addressFromContractId)((0, utils_1.binToHex)(crypto.getRandomValues(new Uint8Array(32))));
-    const contractId = (0, utils_1.binToHex)((0, address_1.contractIdFromAddress)(address));
+    const selfContract = factory.contract;
+    const selfAddress = params.address ?? (0, address_1.addressFromContractId)((0, utils_1.binToHex)(crypto.getRandomValues(new Uint8Array(32))));
+    const selfContractId = (0, utils_1.binToHex)((0, address_1.contractIdFromAddress)(selfAddress));
     const group = params.group ?? 0;
-    const initialMaps = params.initialMaps ?? {};
-    const contractStates = mapsToExistingContracts(contract, contractId, group, initialMaps);
-    const apiParams = contract.toApiTestContractParams(methodName, {
+    const existingContracts = getTestExistingContracts(selfContract, selfContractId, group, params, getContractByCodeHash);
+    const apiParams = selfContract.toApiTestContractParams(methodName, {
         ...params,
-        address,
+        address: selfAddress,
         txId: txId,
-        initialFields: addStdIdToFields(contract, params.initialFields ?? {}),
+        initialFields: addStdIdToFields(selfContract, params.initialFields ?? {}),
         testArgs: params.testArgs === undefined ? {} : params.testArgs,
-        existingContracts: (params.existingContracts ?? []).concat(contractStates)
+        existingContracts
     });
     const apiResult = await (0, global_1.getCurrentNodeProvider)().contracts.postContractsTestContract(apiParams);
-    const maps = existingContractsToMaps(contract, address, group, apiResult, initialMaps);
-    const testResult = contract.fromApiTestContractResult(methodName, apiResult, txId, getContractByCodeHash);
-    contract.printDebugMessages(methodName, testResult.debugMessages);
+    const allMaps = extractMapsFromApiResult(selfAddress, params, group, apiResult, getContractByCodeHash);
+    const testResult = selfContract.fromApiTestContractResult(methodName, apiResult, txId, getContractByCodeHash);
+    testResult.contracts.forEach((c) => {
+        const maps = allMaps.find((v) => v.address === c.address)?.maps;
+        if (maps !== undefined)
+            c['maps'] = maps;
+    });
+    selfContract.printDebugMessages(methodName, testResult.debugMessages);
     return {
         ...testResult,
-        maps
+        maps: allMaps.find((v) => v.address === selfAddress)?.maps
     };
 }
 exports.testMethod = testMethod;

package/dist/src/signer/tx-builder.d.ts

@@ -8,5 +8,5 @@ export declare abstract class TransactionBuilder {
     buildTransferTx(params: SignTransferTxParams, publicKey: string): Promise<Omit<SignTransferTxResult, 'signature'>>;
     buildDeployContractTx(params: SignDeployContractTxParams, publicKey: string): Promise<Omit<SignDeployContractTxResult, 'signature'>>;
     buildExecuteScriptTx(params: SignExecuteScriptTxParams, publicKey: string): Promise<Omit<SignExecuteScriptTxResult, 'signature'>>;
-    buildUnsignedTx(params: SignUnsignedTxParams): Promise<Omit<SignUnsignedTxResult, 'signature'>>;
+    buildUnsignedTx(params: SignUnsignedTxParams): Omit<SignUnsignedTxResult, 'signature'>;
 }

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

@@ -22,6 +22,9 @@ const utils_1 = require("../utils");
 const api_1 = require("../api");
 const address_1 = require("../address");
 const signer_1 = require("./signer");
+const codec_1 = require("../codec");
+const transaction_1 = require("../transaction");
+const hash_1 = require("../codec/hash");
 class TransactionBuilder {
     static from(param0, param1, customFetch) {
         const nodeProvider = typeof param0 === 'string' ? new api_1.NodeProvider(param0, param1, customFetch) : param0;
@@ -80,16 +83,18 @@ class TransactionBuilder {
         const response = await this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data);
         return { ...response, groupIndex: response.fromGroup, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
-    async buildUnsignedTx(params) {
-        const data = { unsignedTx: params.unsignedTx };
-        const decoded = await this.nodeProvider.transactions.postTransactionsDecodeUnsignedTx(data);
+    buildUnsignedTx(params) {
+        const unsignedTxBin = (0, utils_1.hexToBinUnsafe)(params.unsignedTx);
+        const decoded = codec_1.unsignedTxCodec.decode(unsignedTxBin);
+        const txId = (0, utils_1.binToHex)((0, hash_1.blakeHash)(unsignedTxBin));
+        const [fromGroup, toGroup] = (0, transaction_1.groupIndexOfTransaction)(decoded);
         return {
-            fromGroup: decoded.fromGroup,
-            toGroup: decoded.toGroup,
+            fromGroup: fromGroup,
+            toGroup: toGroup,
             unsignedTx: params.unsignedTx,
-            txId: decoded.unsignedTx.txId,
-            gasAmount: decoded.unsignedTx.gasAmount,
-            gasPrice: (0, api_1.fromApiNumber256)(decoded.unsignedTx.gasPrice)
+            txId: txId,
+            gasAmount: decoded.gasAmount,
+            gasPrice: decoded.gasPrice
         };
     }
 }

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

@@ -1,2 +1,4 @@
 import { node } from '../api';
+import { UnsignedTx } from '../codec';
 export declare function waitForTxConfirmation(txId: string, confirmations: number, requestInterval: number): Promise<node.Confirmed>;
+export declare function groupIndexOfTransaction(unsignedTx: UnsignedTx): [number, number];

package/dist/src/transaction/utils.js

@@ -17,8 +17,11 @@ 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/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitForTxConfirmation = void 0;
+exports.groupIndexOfTransaction = exports.waitForTxConfirmation = void 0;
+const address_1 = require("../address");
+const constants_1 = require("../constants");
 const global_1 = require("../global");
+const utils_1 = require("../utils");
 function isConfirmed(txStatus) {
     return txStatus.type === 'Confirmed';
 }
@@ -32,3 +35,22 @@ async function waitForTxConfirmation(txId, confirmations, requestInterval) {
     return waitForTxConfirmation(txId, confirmations, requestInterval);
 }
 exports.waitForTxConfirmation = waitForTxConfirmation;
+function groupIndexOfTransaction(unsignedTx) {
+    if (unsignedTx.inputs.length === 0)
+        throw new Error('Empty inputs for unsignedTx');
+    const fromGroup = groupFromHint(unsignedTx.inputs[0].hint);
+    let toGroup = fromGroup;
+    for (const output of unsignedTx.fixedOutputs) {
+        const outputGroup = (0, address_1.groupOfLockupScript)(output.lockupScript);
+        if (outputGroup !== fromGroup) {
+            toGroup = outputGroup;
+            break;
+        }
+    }
+    return [fromGroup, toGroup];
+}
+exports.groupIndexOfTransaction = groupIndexOfTransaction;
+function groupFromHint(hint) {
+    const hash = (0, utils_1.xorByte)(hint);
+    return hash % constants_1.TOTAL_NUMBER_OF_GROUPS;
+}

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

@@ -24,6 +24,7 @@ export declare function isDevnet(networkId?: number): boolean;
 export declare function targetToDifficulty(compactedTarget: HexString): bigint;
 export declare function difficultyToTarget(diff: bigint): HexString;
 export declare function concatBytes(arrays: Uint8Array[]): Uint8Array;
+export declare function xorByte(intValue: number): number;
 type _Eq<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
 export type Eq<X, Y> = _Eq<{
     [P in keyof X]: X[P];

package/dist/src/utils/utils.js

@@ -20,7 +20,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertType = exports.concatBytes = exports.difficultyToTarget = exports.targetToDifficulty = exports.isDevnet = exports.sleep = exports.hexToString = exports.stringToHex = exports.blockChainIndex = exports.binToHex = exports.hexToBinUnsafe = exports.toNonNegativeBigInt = exports.isHexString = exports.signatureDecode = exports.encodeHexSignature = exports.encodeSignature = exports.networkIds = void 0;
+exports.assertType = exports.xorByte = exports.concatBytes = exports.difficultyToTarget = exports.targetToDifficulty = exports.isDevnet = exports.sleep = exports.hexToString = exports.stringToHex = exports.blockChainIndex = exports.binToHex = exports.hexToBinUnsafe = exports.toNonNegativeBigInt = exports.isHexString = exports.signatureDecode = exports.encodeHexSignature = exports.encodeSignature = exports.networkIds = void 0;
 const elliptic_1 = require("elliptic");
 const bn_js_1 = __importDefault(require("bn.js"));
 const constants_1 = require("../constants");
@@ -153,6 +153,14 @@ function concatBytes(arrays) {
     return result;
 }
 exports.concatBytes = concatBytes;
+function xorByte(intValue) {
+    const byte0 = (intValue >> 24) & 0xff;
+    const byte1 = (intValue >> 16) & 0xff;
+    const byte2 = (intValue >> 8) & 0xff;
+    const byte3 = intValue & 0xff;
+    return (byte0 ^ byte1 ^ byte2 ^ byte3) & 0xff;
+}
+exports.xorByte = xorByte;
 // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars
 function assertType() { }
 exports.assertType = assertType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -83,7 +83,7 @@
     "ts-node": "^10.9.1",
     "tslib": "^2.5.0",
     "typescript": "^4.9.5",
-    "webpack": "^5.77.0",
+    "webpack": "^5.94.0",
     "webpack-cli": "^4.10.0"
   },
   "engines": {

package/src/address/address.ts

@@ -21,11 +21,12 @@ import BN from 'bn.js'
 import { TOTAL_NUMBER_OF_GROUPS } from '../constants'
 import blake from 'blakejs'
 import bs58 from '../utils/bs58'
-import djb2 from '../utils/djb2'
-import { binToHex, concatBytes, hexToBinUnsafe, isHexString } from '../utils'
+import { binToHex, concatBytes, hexToBinUnsafe, isHexString, xorByte } from '../utils'
 import { KeyType } from '../signer'
 import { P2MPKH, lockupScriptCodec } from '../codec/lockup-script-codec'
 import { i32Codec } from '../codec'
+import { LockupScript } from '../codec/lockup-script-codec'
+import djb2 from '../utils/djb2'
 
 const ec = new EC('secp256k1')
 const PublicKeyHashSize = 32
@@ -112,26 +113,19 @@ export function groupOfAddress(address: string): number {
   }
 }
 
-function groupOfAddressBytes(bytes: Uint8Array): number {
-  const hint = djb2(bytes) | 1
-  const hash = xorByte(hint)
-  const group = hash % TOTAL_NUMBER_OF_GROUPS
-  return group
-}
-
 // Pay to public key hash address
 function groupOfP2pkhAddress(address: Uint8Array): number {
-  return groupOfAddressBytes(address)
+  return groupFromBytesForAssetAddress(address)
 }
 
 // Pay to multiple public key hash address
 function groupOfP2mpkhAddress(address: Uint8Array): number {
-  return groupOfAddressBytes(address.slice(1, 33))
+  return groupFromBytesForAssetAddress(address.slice(1, 33))
 }
 
 // Pay to script hash address
 function groupOfP2shAddress(address: Uint8Array): number {
-  return groupOfAddressBytes(address)
+  return groupFromBytesForAssetAddress(address)
 }
 
 export function contractIdFromAddress(address: string): Uint8Array {
@@ -225,10 +219,22 @@ export function subContractId(parentContractId: string, pathInHex: string, group
   return binToHex(bytes)
 }
 
-export function xorByte(intValue: number): number {
-  const byte0 = (intValue >> 24) & 0xff
-  const byte1 = (intValue >> 16) & 0xff
-  const byte2 = (intValue >> 8) & 0xff
-  const byte3 = intValue & 0xff
-  return (byte0 ^ byte1 ^ byte2 ^ byte3) & 0xff
+export function groupOfLockupScript(lockupScript: LockupScript): number {
+  if (lockupScript.kind === 'P2PKH') {
+    return groupFromBytesForAssetAddress(lockupScript.value)
+  } else if (lockupScript.kind === 'P2MPKH') {
+    return groupFromBytesForAssetAddress(lockupScript.value.publicKeyHashes[0])
+  } else if (lockupScript.kind === 'P2SH') {
+    return groupFromBytesForAssetAddress(lockupScript.value)
+  } else {
+    // P2C
+    const contractId = lockupScript.value
+    return contractId[`${contractId.length - 1}`]
+  }
+}
+
+function groupFromBytesForAssetAddress(bytes: Uint8Array): number {
+  const hint = djb2(bytes) | 1
+  const hash = xorByte(hint)
+  return hash % TOTAL_NUMBER_OF_GROUPS
 }

package/src/contract/contract.ts

@@ -59,7 +59,7 @@ import {
 import { contractIdFromAddress, groupOfAddress, addressFromContractId, subContractId } from '../address'
 import { getCurrentNodeProvider } from '../global'
 import { EventSubscribeOptions, EventSubscription, subscribeToEvents } from './events'
-import { ONE_ALPH, TOTAL_NUMBER_OF_GROUPS } from '../constants'
+import { MINIMAL_CONTRACT_DEPOSIT, ONE_ALPH, TOTAL_NUMBER_OF_GROUPS } from '../constants'
 import * as blake from 'blakejs'
 import { isContractDebugMessageEnabled } from '../debug'
 import {
@@ -885,6 +885,13 @@ export interface ContractState<T extends Fields = Fields> {
   asset: Asset
 }
 
+export interface ContractStateWithMaps<
+  T extends Fields = Fields,
+  M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>
+> extends ContractState<T> {
+  maps?: M
+}
+
 function toApiContractState(state: ContractState, structs: Struct[]): node.ContractState {
   const stateFields = state.fields ?? {}
   const fieldsSig = state.fieldsSig
@@ -942,7 +949,7 @@ export interface TestContractParams<
   initialMaps?: M
   initialAsset?: Asset // default 1 ALPH
   testArgs: A
-  existingContracts?: ContractState[] // default no existing contracts
+  existingContracts?: ContractStateWithMaps[] // default no existing contracts
   inputAssets?: InputAsset[] // default no input asserts
 }
 
@@ -965,7 +972,7 @@ export interface TestContractResult<R, M extends Record<string, Map<Val, Val>> =
   returns: R
   gasUsed: number
   maps?: M
-  contracts: ContractState[]
+  contracts: ContractStateWithMaps[]
   txOutputs: Output[]
   events: ContractEvent[]
   debugMessages: DebugMessage[]
@@ -1065,12 +1072,23 @@ export abstract class ContractFactory<I extends ContractInstance, F extends Fiel
   }
 
   // This is used for testing contract functions
-  stateForTest(initFields: F, asset?: Asset, address?: string): ContractState<F> {
+  protected stateForTest_(
+    initFields: F,
+    asset?: Asset,
+    address?: string,
+    maps?: Record<string, Map<Val, Val>>
+  ): ContractState<F> | ContractStateWithMaps<F> {
     const newAsset = {
-      alphAmount: asset?.alphAmount ?? ONE_ALPH,
+      alphAmount: asset?.alphAmount ?? MINIMAL_CONTRACT_DEPOSIT,
       tokens: asset?.tokens
     }
-    return this.contract.toState(addStdIdToFields(this.contract, initFields), newAsset, address)
+    const state = this.contract.toState(addStdIdToFields(this.contract, initFields), newAsset, address)
+    return {
+      ...state,
+      bytecode: this.contract.bytecodeDebug,
+      codeHash: this.contract.codeHash,
+      maps: maps
+    }
   }
 }
 
@@ -1381,6 +1399,60 @@ function mapsToExistingContracts(
   return contractStates
 }
 
+function hasMap(state: ContractState): state is ContractStateWithMaps {
+  return (state as ContractStateWithMaps).maps !== undefined
+}
+
+function getTestExistingContracts(
+  selfContract: Contract,
+  selfContractId: string,
+  group: number,
+  params: Optional<TestContractParams, 'testArgs' | 'initialFields'>,
+  getContractByCodeHash: (codeHash: string) => Contract
+): ContractState[] {
+  const selfMaps = params.initialMaps ?? {}
+  const selfMapEntries = mapsToExistingContracts(selfContract, selfContractId, group, selfMaps)
+  const existingContracts = params.existingContracts ?? []
+  const existingMapEntries = existingContracts.flatMap((contractState) => {
+    return hasMap(contractState)
+      ? mapsToExistingContracts(
+          getContractByCodeHash(contractState.codeHash),
+          contractState.contractId,
+          group,
+          contractState.maps ?? {}
+        )
+      : []
+  })
+  return existingContracts.concat(selfMapEntries, existingMapEntries)
+}
+
+export function extractMapsFromApiResult(
+  selfAddress: string,
+  params: Optional<TestContractParams, 'testArgs' | 'initialFields'>,
+  group: number,
+  apiResult: node.TestContractResult,
+  getContractByCodeHash: (codeHash: string) => Contract
+): { address: string; maps: Record<string, Map<Val, Val>> }[] {
+  const selfMaps = params.initialMaps ?? {}
+  const existingContracts = params.existingContracts ?? []
+  const filtered = apiResult.contracts.filter(
+    (c) => c.address === selfAddress || existingContracts.find((s) => s.address === c.address) !== undefined
+  )
+  const allMaps: { address: string; maps: Record<string, Map<Val, Val>> }[] = []
+  filtered.forEach((state) => {
+    const artifact = getContractByCodeHash(state.codeHash)
+    if (artifact.mapsSig !== undefined) {
+      const originMaps =
+        state.address === selfAddress
+          ? selfMaps
+          : (existingContracts.find((s) => s.address === state.address) as ContractStateWithMaps).maps
+      const maps = existingContractsToMaps(artifact, state.address, group, apiResult, originMaps ?? {})
+      allMaps.push({ address: state.address, maps })
+    }
+  })
+  return allMaps
+}
+
 export async function testMethod<
   I extends ContractInstance,
   F extends Fields,
@@ -1394,27 +1466,31 @@ export async function testMethod<
   getContractByCodeHash: (codeHash: string) => Contract
 ): Promise<TestContractResult<R, M>> {
   const txId = params?.txId ?? randomTxId()
-  const contract = factory.contract
-  const address = params.address ?? addressFromContractId(binToHex(crypto.getRandomValues(new Uint8Array(32))))
-  const contractId = binToHex(contractIdFromAddress(address))
+  const selfContract = factory.contract
+  const selfAddress = params.address ?? addressFromContractId(binToHex(crypto.getRandomValues(new Uint8Array(32))))
+  const selfContractId = binToHex(contractIdFromAddress(selfAddress))
   const group = params.group ?? 0
-  const initialMaps = params.initialMaps ?? {}
-  const contractStates = mapsToExistingContracts(contract, contractId, group, initialMaps)
-  const apiParams = contract.toApiTestContractParams(methodName, {
+  const existingContracts = getTestExistingContracts(selfContract, selfContractId, group, params, getContractByCodeHash)
+
+  const apiParams = selfContract.toApiTestContractParams(methodName, {
     ...params,
-    address,
+    address: selfAddress,
     txId: txId,
-    initialFields: addStdIdToFields(contract, params.initialFields ?? {}),
+    initialFields: addStdIdToFields(selfContract, params.initialFields ?? {}),
     testArgs: params.testArgs === undefined ? {} : params.testArgs,
-    existingContracts: (params.existingContracts ?? []).concat(contractStates)
+    existingContracts
   })
   const apiResult = await getCurrentNodeProvider().contracts.postContractsTestContract(apiParams)
-  const maps = existingContractsToMaps(contract, address, group, apiResult, initialMaps)
-  const testResult = contract.fromApiTestContractResult(methodName, apiResult, txId, getContractByCodeHash)
-  contract.printDebugMessages(methodName, testResult.debugMessages)
+  const allMaps = extractMapsFromApiResult(selfAddress, params, group, apiResult, getContractByCodeHash)
+  const testResult = selfContract.fromApiTestContractResult(methodName, apiResult, txId, getContractByCodeHash)
+  testResult.contracts.forEach((c) => {
+    const maps = allMaps.find((v) => v.address === c.address)?.maps
+    if (maps !== undefined) c['maps'] = maps
+  })
+  selfContract.printDebugMessages(methodName, testResult.debugMessages)
   return {
     ...testResult,
-    maps
+    maps: allMaps.find((v) => v.address === selfAddress)?.maps
   } as TestContractResult<R, M>
 }