@d9-network/ink 1.2.5 → 1.3.0

package/dist/index.cjs

@@ -496,6 +496,8 @@ function createAsciiEventTopic(contractName, eventLabel) {
 var ContractEventParser = class {
 	eventDecoders;
 	eventSignatures;
+	/** Maps ink! variant index (first byte of event data) to event label */
+	eventVariantMap;
 	contractAddressBytes;
 	contractAddress;
 	metadata;
@@ -506,10 +508,13 @@ var ContractEventParser = class {
 		this.eventDecoders = buildAllEventDecoders(this.metadata);
 		this.contractAddressBytes = (0, _polkadot_labs_hdkd_helpers.ss58Decode)(contractAddress)[0];
 		this.eventSignatures = /* @__PURE__ */ new Map();
+		this.eventVariantMap = /* @__PURE__ */ new Map();
 		const events = this.metadata.spec.events;
-		for (const event of events) {
+		for (let i = 0; i < events.length; i++) {
+			const event = events[i];
 			const sig = getEventSignature(event.label);
 			this.eventSignatures.set(event.label, sig);
+			this.eventVariantMap.set(i, event.label);
 		}
 	}
 	/**
@@ -541,6 +546,11 @@ var ContractEventParser = class {
 				break;
 			}
 		}
+		if (!eventLabel && data.length > 0) {
+			const variantIndex = data[0];
+			const candidateLabel = this.eventVariantMap.get(variantIndex);
+			if (candidateLabel && this.eventDecoders.has(candidateLabel)) eventLabel = candidateLabel;
+		}
 		if (!eventLabel) {
 			console.warn("Unknown event signature:", signature);
 			return null;
@@ -983,6 +993,88 @@ function createTypedRpc(client) {
 	} });
 }
 
+//#endregion
+//#region src/result-normalization.ts
+function getTypeEntry(types, typeId) {
+	const entry = types.find((item) => item.id === typeId);
+	if (!entry) throw new Error(`Type ${typeId} not found in metadata`);
+	return entry;
+}
+function getResultTypeIds(typeEntry) {
+	const path = typeEntry.type.path;
+	if (!path || path[0] !== "Result") return null;
+	const params = typeEntry.type.params;
+	if (!params || params.length < 2) return null;
+	const okTypeId = params[0]?.type;
+	const errTypeId = params[1]?.type;
+	if (okTypeId === void 0 || errTypeId === void 0) return null;
+	return {
+		okTypeId,
+		errTypeId
+	};
+}
+function hasOkErrVariants(typeEntry) {
+	const variants = typeEntry.type.def.variant?.variants;
+	if (!variants) return false;
+	const names = new Set(variants.map((variant) => variant.name));
+	return names.has("Ok") && names.has("Err");
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isRuntimeResult(value) {
+	if (!isRecord(value)) return false;
+	if ("success" in value) return typeof value.success === "boolean" && "value" in value;
+	if ("type" in value) return (value.type === "Ok" || value.type === "Err") && "value" in value;
+	return false;
+}
+function isRuntimeResultSuccess(value) {
+	if ("success" in value) return value.success;
+	return value.type === "Ok";
+}
+function analyzeMessageReturn(metadata, messageLabel) {
+	const types = metadata.types;
+	const message = metadata.spec.messages.find((item) => item.label === messageLabel);
+	if (!message) throw new Error(`Message "${messageLabel}" not found in metadata`);
+	let currentTypeId = getResultTypeIds(getTypeEntry(types, message.returnType.type))?.okTypeId ?? message.returnType.type;
+	let businessResultDepth = 0;
+	while (true) {
+		const currentType = getTypeEntry(types, currentTypeId);
+		const resultTypeIds = getResultTypeIds(currentType);
+		if (!resultTypeIds || !hasOkErrVariants(currentType)) break;
+		businessResultDepth += 1;
+		currentTypeId = resultTypeIds.okTypeId;
+	}
+	return {
+		businessResultDepth,
+		finalTypeId: currentTypeId
+	};
+}
+function buildMessageReturnAnalysisMap(metadata) {
+	const analysisMap = /* @__PURE__ */ new Map();
+	const messages = metadata.spec.messages;
+	for (const message of messages) analysisMap.set(message.label, analyzeMessageReturn(metadata, message.label));
+	return analysisMap;
+}
+function normalizeDecodedResponse(value, businessResultDepth) {
+	let current = value;
+	for (let index = 0; index < businessResultDepth; index += 1) {
+		if (!isRuntimeResult(current)) return {
+			success: false,
+			error: /* @__PURE__ */ new Error(`Expected Result payload at depth ${index + 1}, received ${typeof current}`)
+		};
+		if (!isRuntimeResultSuccess(current)) return {
+			success: false,
+			error: current.value
+		};
+		current = current.value;
+	}
+	return {
+		success: true,
+		value: current
+	};
+}
+
 //#endregion
 //#region src/contract.ts
 /**
@@ -1094,6 +1186,7 @@ function createD9InkContract(descriptor, address, options) {
 	const addressBytes = ss58ToBytes(address);
 	const rpc = createTypedRpc(client);
 	const messageCodecCache = /* @__PURE__ */ new Map();
+	const messageReturnAnalysis = buildMessageReturnAnalysisMap(patchedMetadata);
 	function getMessageCodec(label) {
 		const cached = messageCodecCache.get(label);
 		if (cached) return cached;
@@ -1166,9 +1259,14 @@ function createD9InkContract(descriptor, address, options) {
 				};
 				decodedResponse = fallbackResult.value;
 			}
+			const normalizedResponse = normalizeDecodedResponse(decodedResponse, messageReturnAnalysis.get(method)?.businessResultDepth ?? 0);
+			if (!normalizedResponse.success) return {
+				success: false,
+				error: normalizedResponse.error instanceof Error ? new _d9_network_spec.DecodeError(method, normalizedResponse.error.message, normalizedResponse.error) : new _d9_network_spec.ContractExecutionError(method, normalizedResponse.error)
+			};
 			return {
 				success: true,
-				value: decodedResponse,
+				value: normalizedResponse.value,
 				events: [],
 				gasConsumed: callResult.gas.gasConsumed,
 				gasRequired: callResult.gas.gasRequired,
@@ -1354,10 +1452,10 @@ function createD9InkContract(descriptor, address, options) {
 * });
 *
 * if (result.success) {
-*   console.log("Balance:", result.value.response);
+*   console.log("Balance:", result.value);
 *
 *   // Send transaction from the query result
-*   const txResult = await result.value.send().signAndSubmit(aliceSigner);
+*   const txResult = await result.send().signAndSubmit(aliceSigner);
 * }
 *
 * // Or send directly