@d9-network/ink 0.0.4 → 0.0.6

package/dist/index.mjs

@@ -207,19 +207,19 @@ function buildCodecFromType(typeId, types, cache) {
 	const def = typeEntry.type.def;
 	const path = typeEntry.type.path;
 	if (def.primitive) {
-		const codec = buildPrimitiveCodec(def.primitive);
+		const codec = buildPrimitiveCodec$1(def.primitive);
 		cache.set(typeId, codec);
 		return codec;
 	}
 	if (path && path.length > 0) {
-		const specialCodec = buildSpecialTypeCodec(path, typeEntry, types, cache);
+		const specialCodec = buildSpecialTypeCodec$1(path, typeEntry, types, cache);
 		if (specialCodec) {
 			cache.set(typeId, specialCodec);
 			return specialCodec;
 		}
 	}
 	if (def.tuple) {
-		const codec = buildTupleCodec(def.tuple, types, cache);
+		const codec = buildTupleCodec$1(def.tuple, types, cache);
 		cache.set(typeId, codec);
 		return codec;
 	}
@@ -230,7 +230,7 @@ function buildCodecFromType(typeId, types, cache) {
 	}
 	if (def.array) {
 		const innerCodec = buildCodecFromType(def.array.type, types, cache);
-		if (def.array.type === findPrimitiveTypeId(types, "u8")) {
+		if (def.array.type === findPrimitiveTypeId$1(types, "u8")) {
 			const codec$1 = Bytes$1(def.array.len);
 			cache.set(typeId, codec$1);
 			return codec$1;
@@ -240,12 +240,12 @@ function buildCodecFromType(typeId, types, cache) {
 		return codec;
 	}
 	if (def.composite) {
-		const codec = buildCompositeCodec(def.composite, types, cache);
+		const codec = buildCompositeCodec$1(def.composite, types, cache);
 		cache.set(typeId, codec);
 		return codec;
 	}
 	if (def.variant) {
-		const codec = buildVariantCodec(def.variant, path, types, cache);
+		const codec = buildVariantCodec$1(def.variant, path, types, cache);
 		cache.set(typeId, codec);
 		return codec;
 	}
@@ -254,7 +254,7 @@ function buildCodecFromType(typeId, types, cache) {
 /**
 * Build codec for primitive types
 */
-function buildPrimitiveCodec(primitive) {
+function buildPrimitiveCodec$1(primitive) {
 	switch (primitive) {
 		case "u8": return u8;
 		case "u16": return u16;
@@ -274,7 +274,7 @@ function buildPrimitiveCodec(primitive) {
 /**
 * Build codec for special types based on path
 */
-function buildSpecialTypeCodec(path, typeEntry, types, cache) {
+function buildSpecialTypeCodec$1(path, typeEntry, types, cache) {
 	if (path.join("::").includes("AccountId")) return AccountId();
 	if (path[0] === "Option") {
 		const params = typeEntry.type.params;
@@ -296,7 +296,7 @@ function buildSpecialTypeCodec(path, typeEntry, types, cache) {
 /**
 * Build codec for tuple types
 */
-function buildTupleCodec(tupleTypes, types, cache) {
+function buildTupleCodec$1(tupleTypes, types, cache) {
 	if (tupleTypes.length === 0) return _void;
 	const innerCodecs = tupleTypes.map((t) => buildCodecFromType(t, types, cache));
 	switch (innerCodecs.length) {
@@ -310,7 +310,7 @@ function buildTupleCodec(tupleTypes, types, cache) {
 /**
 * Build codec for composite (struct) types
 */
-function buildCompositeCodec(composite, types, cache) {
+function buildCompositeCodec$1(composite, types, cache) {
 	const fields = composite.fields;
 	if (fields.length === 1 && !fields[0]?.name) return buildCodecFromType(fields[0].type, types, cache);
 	const structDef = {};
@@ -323,7 +323,7 @@ function buildCompositeCodec(composite, types, cache) {
 /**
 * Build codec for variant (enum) types
 */
-function buildVariantCodec(variant, path, types, cache) {
+function buildVariantCodec$1(variant, path, types, cache) {
 	const variants = variant.variants;
 	const isLangError$1 = path?.includes("LangError");
 	const variantDef = {};
@@ -353,7 +353,7 @@ function buildVariantCodec(variant, path, types, cache) {
 /**
 * Find the type ID for a primitive type
 */
-function findPrimitiveTypeId(types, primitive) {
+function findPrimitiveTypeId$1(types, primitive) {
 	return types.find((t) => t.type.def.primitive === primitive)?.id ?? -1;
 }
 /**
@@ -470,7 +470,12 @@ function getEventSignature(eventLabel) {
 //#endregion
 //#region src/events.ts
 /**
-* Event parser for a specific contract
+* Type-safe event parser for a specific contract
+*
+* @typeParam S - The storage descriptor type
+* @typeParam M - The messages descriptor type
+* @typeParam C - The constructors descriptor type
+* @typeParam E - The event type representing all possible events for this contract
 */
 var ContractEventParser = class {
 	eventDecoders;
@@ -478,21 +483,31 @@ var ContractEventParser = class {
 	contractAddressBytes;
 	contractAddress;
 	metadata;
-	constructor(metadata, contractAddress) {
-		this.metadata = metadata;
+	constructor(descriptor, contractAddress) {
+		if (!descriptor.metadata) throw new Error("Contract descriptor must include metadata");
+		this.metadata = descriptor.metadata;
 		this.contractAddress = contractAddress;
-		this.eventDecoders = buildAllEventDecoders(metadata);
+		this.eventDecoders = buildAllEventDecoders(this.metadata);
 		this.contractAddressBytes = ss58Decode(contractAddress)[0];
 		this.eventSignatures = /* @__PURE__ */ new Map();
-		const events = metadata.spec.events;
+		const events = this.metadata.spec.events;
 		for (const event of events) {
 			const sig = getEventSignature(event.label);
 			this.eventSignatures.set(event.label, sig);
 		}
 	}
 	/**
-	* Parse a raw chain event into a contract event (if it matches)
+	* Parse a raw chain event into a type-safe contract event (if it matches)
 	* Returns null if the event is not from this contract or cannot be parsed
+	*
+	* @example
+	* ```ts
+	* const event = parser.parseEvent(chainEvent);
+	* if (event?.type === "Transfer") {
+	*   // event.value is now typed as { from: SS58String; to: SS58String; value: bigint }
+	*   console.log(event.value.from);
+	* }
+	* ```
 	*/
 	parseEvent(chainEvent) {
 		const extracted = this.extractContractEmittedEvent(chainEvent);
@@ -518,8 +533,8 @@ var ContractEventParser = class {
 		try {
 			const decodedData = decoder(data);
 			return {
-				label: eventLabel,
-				data: decodedData,
+				type: eventLabel,
+				value: decodedData,
 				raw: {
 					blockNumber,
 					blockHash,
@@ -535,14 +550,18 @@ var ContractEventParser = class {
 		}
 	}
 	/**
-	* Filter a batch of events
+	* Filter a batch of events and return type-safe results
+	*
+	* @param chainEvents - Array of chain events to filter
+	* @param options - Optional filter criteria
+	* @returns Array of type-safe contract events
 	*/
 	filterEvents(chainEvents, options) {
 		const results = [];
 		for (const chainEvent of chainEvents) {
 			const parsed = this.parseEvent(chainEvent);
 			if (!parsed) continue;
-			if (options?.eventLabels && !options.eventLabels.includes(parsed.label)) continue;
+			if (options?.eventLabels && !options.eventLabels.includes(parsed.type)) continue;
 			if (options?.fromBlock && parsed.raw.blockNumber < options.fromBlock) continue;
 			if (options?.toBlock && parsed.raw.blockNumber > options.toBlock) continue;
 			results.push(parsed);
@@ -550,6 +569,29 @@ var ContractEventParser = class {
 		return results;
 	}
 	/**
+	* Filter events by specific type with proper type narrowing
+	*
+	* This method provides better type safety than filterEvents with eventLabels
+	* because TypeScript can narrow the return type to only the specified event type.
+	*
+	* @param chainEvents - Array of chain events to filter
+	* @param label - The event label to filter by
+	* @returns Array of events narrowed to the specific type
+	*
+	* @example
+	* ```ts
+	* const transfers = parser.filterByType(events, "Transfer");
+	*
+	* for (const t of transfers) {
+	*   // t.value is fully typed as Transfer event data
+	*   console.log(t.value.from, "->", t.value.to, ":", t.value.value);
+	* }
+	* ```
+	*/
+	filterByType(chainEvents, label) {
+		return this.filterEvents(chainEvents).filter((e) => e.type === label);
+	}
+	/**
 	* Get the contract address as SS58 string
 	*/
 	getContractAddress() {
@@ -570,20 +612,31 @@ var ContractEventParser = class {
 		if (eventValue.type !== "ContractEmitted") return null;
 		const contractEmittedData = eventValue.value;
 		if (!contractEmittedData || typeof contractEmittedData !== "object") return null;
-		const contract = contractEmittedData.contract;
-		const data = contractEmittedData.data;
-		if (!(contract instanceof Uint8Array) || !(data instanceof Uint8Array)) return null;
+		const contractRaw = contractEmittedData.contract;
+		const dataRaw = contractEmittedData.data;
+		let contract;
+		if (contractRaw instanceof Uint8Array) contract = contractRaw;
+		else if (typeof contractRaw === "string") contract = ss58Decode(contractRaw)[0];
+		else return null;
+		let data;
+		if (dataRaw instanceof Uint8Array) data = dataRaw;
+		else if (dataRaw && typeof dataRaw === "object" && "asBytes" in dataRaw && typeof dataRaw.asBytes === "function") data = dataRaw.asBytes();
+		else return null;
 		const topics = [];
 		if (record.topics && Array.isArray(record.topics)) {
 			for (const topic of record.topics) if (topic instanceof Uint8Array) topics.push(topic);
+			else if (topic && typeof topic === "object" && "asBytes" in topic && typeof topic.asBytes === "function") topics.push(topic.asBytes());
 		}
+		const blockNumber = typeof record.blockNumber === "number" ? record.blockNumber : 0;
+		const blockHash = typeof record.blockHash === "string" ? record.blockHash : "";
+		const eventIndex = typeof record.eventIndex === "number" ? record.eventIndex : 0;
 		return {
 			contract,
 			data,
 			topics,
-			blockNumber: typeof record.blockNumber === "number" ? record.blockNumber : 0,
-			blockHash: typeof record.blockHash === "string" ? record.blockHash : "",
-			eventIndex: typeof record.eventIndex === "number" ? record.eventIndex : 0
+			blockNumber,
+			blockHash,
+			eventIndex
 		};
 	}
 	/**
@@ -607,6 +660,34 @@ var ContractEventParser = class {
 		return signatures;
 	}
 };
+/**
+* Type guard for narrowing event types
+*
+* Use this function when you have a `TypedContractEvent` and need to
+* narrow it to a specific event type. This is useful when the type
+* information is lost (e.g., after serialization or in generic functions).
+*
+* @typeParam E - The Enum type representing all possible events
+* @typeParam L - The specific event label to check
+* @param event - The event to check
+* @param label - The event label to match
+* @returns True if the event type matches the label
+*
+* @example
+* ```ts
+* const event = parser.parseEvent(chainEvent);
+*
+* if (event && isEventType(event, "Transfer")) {
+*   // TypeScript knows event.value is Transfer event data
+*   console.log(event.value.from);
+*   console.log(event.value.to);
+*   console.log(event.value.value);
+* }
+* ```
+*/
+function isEventType(event, label) {
+	return event.type === label;
+}
 
 //#endregion
 //#region src/subscriptions.ts
@@ -617,12 +698,12 @@ var ContractEventParser = class {
 * Create an observable stream of contract events
 *
 * @param client - Polkadot API client
-* @param metadata - Contract metadata
+* @param descriptor - Contract descriptor
 * @param options - Subscription options
-* @returns Observable stream of decoded contract events
+* @returns Observable stream of type-safe contract events
 */
-function createContractEventStream(client, metadata, options) {
-	const parser = new ContractEventParser(metadata, options.contractAddress);
+function createContractEventStream(client, descriptor, options) {
+	const parser = new ContractEventParser(descriptor, options.contractAddress);
 	return client.finalizedBlock$.pipe(mergeMap(async (block) => {
 		try {
 			return {
@@ -648,7 +729,7 @@ function createContractEventStream(client, metadata, options) {
 		}).filter((e) => e !== null);
 	}), mergeMap((events) => from(events)), filter((event) => {
 		if (!options.eventLabels) return true;
-		return options.eventLabels.includes(event.label);
+		return options.eventLabels.includes(event.type);
 	}), catchError((error) => {
 		console.error("Error in contract event stream:", error);
 		return of();
@@ -658,21 +739,21 @@ function createContractEventStream(client, metadata, options) {
 * Convenience helper to create a Transfer event stream for PSP22 tokens
 *
 * @param client - Polkadot API client
-* @param metadata - PSP22 contract metadata
+* @param descriptor - PSP22 contract descriptor
 * @param contractAddress - PSP22 contract address
 * @param getEvents - Function to fetch System.Events at a block hash
 * @param watchAddress - Optional address to filter transfers (only events involving this address)
 * @returns Observable stream of Transfer events
 */
-function createPSP22TransferStream(client, metadata, contractAddress, getEvents, watchAddress) {
-	return createContractEventStream(client, metadata, {
+function createPSP22TransferStream(client, descriptor, contractAddress, getEvents, watchAddress) {
+	return createContractEventStream(client, descriptor, {
 		contractAddress,
 		eventLabels: ["Transfer"],
 		getEvents
 	}).pipe(filter((event) => {
 		if (!watchAddress) return true;
-		const data = event.data;
-		return data.from === watchAddress || data.to === watchAddress;
+		const value = event.value;
+		return value.from === watchAddress || value.to === watchAddress;
 	}));
 }
 /**
@@ -719,6 +800,91 @@ function createNativeTransferStream(client, getEvents, watchAddress) {
 	}), share());
 }
 
+//#endregion
+//#region src/message-builder.ts
+/**
+* Create a type-safe message builder from a contract descriptor
+*
+* @typeParam S - Storage descriptor type
+* @typeParam M - Messages descriptor type
+* @typeParam C - Constructors descriptor type
+* @typeParam E - Events Enum type
+* @param descriptor - The ink! contract descriptor containing metadata
+* @returns A ContractMessageBuilder instance
+*
+* @example
+* ```ts
+* import { createMessageBuilder } from '@d9-network/ink';
+* import { contracts } from '@polkadot-api/descriptors';
+*
+* const builder = createMessageBuilder(contracts.usdt);
+*
+* // Get a typed message interface
+* const transfer = builder.message("PSP22::transfer");
+*
+* // Encode with full type checking on args
+* const encoded = transfer.encode({
+*   to: recipientAddress,   // Must be SS58String
+*   value: 1000000n,        // Must be bigint
+*   data: new Uint8Array(), // Must be Uint8Array
+* });
+*
+* // Decode response with full type inference
+* const response = transfer.decode(resultBytes);
+* ```
+*/
+function createMessageBuilder(descriptor) {
+	if (!descriptor.metadata) throw new Error("Contract descriptor must include metadata");
+	const metadata = descriptor.metadata;
+	const builder = getInkDynamicBuilder(getInkLookup(metadata));
+	const codecCache = /* @__PURE__ */ new Map();
+	const messagesMetadata = /* @__PURE__ */ new Map();
+	for (const msg of metadata.spec.messages) messagesMetadata.set(msg.label, msg);
+	function getMessageCodec(label) {
+		const cached = codecCache.get(label);
+		if (cached) return cached;
+		const codec = builder.buildMessage(label);
+		codecCache.set(label, codec);
+		return codec;
+	}
+	function parseSelector(selectorHex) {
+		const hex = selectorHex.startsWith("0x") ? selectorHex.slice(2) : selectorHex;
+		return new Uint8Array(hex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+	}
+	function message(label) {
+		const msgMeta = messagesMetadata.get(label);
+		if (!msgMeta) throw new Error(`Message "${label}" not found in metadata`);
+		const codec = getMessageCodec(label);
+		const selector = parseSelector(msgMeta.selector);
+		const encode = (args) => {
+			const encoded = codec.call.enc(args ?? {});
+			return Binary.fromBytes(encoded);
+		};
+		const decode = (response) => {
+			const bytes = response instanceof Uint8Array ? response : response.asBytes();
+			return codec.value.dec(bytes);
+		};
+		return {
+			encode,
+			decode,
+			attributes: {
+				mutates: msgMeta.mutates,
+				payable: msgMeta.payable,
+				default: msgMeta.default
+			},
+			selector,
+			label
+		};
+	}
+	function getMessageLabels() {
+		return Array.from(messagesMetadata.keys());
+	}
+	return {
+		message,
+		getMessageLabels
+	};
+}
+
 //#endregion
 //#region src/errors.ts
 /**
@@ -937,6 +1103,10 @@ function createD9InkContract(descriptor, address, options) {
 	if (!descriptor.metadata) throw new MetadataError("Contract descriptor must include metadata");
 	const patchedMetadata = patchLangErrorInMetadata(descriptor.metadata);
 	const builder = getInkDynamicBuilder(getInkLookup(patchedMetadata));
+	const patchedDescriptor = {
+		...descriptor,
+		metadata: patchedMetadata
+	};
 	let codecRegistry;
 	try {
 		codecRegistry = createCodecRegistry(patchedMetadata);
@@ -971,13 +1141,13 @@ function createD9InkContract(descriptor, address, options) {
 			checkAborted(signal, method);
 			const originBytes = ss58ToBytes(origin);
 			const codec = getMessageCodec(method);
-			const message = encodeContractCall(originBytes, addressBytes, codec.call.enc(args ?? {}), value);
+			const message$1 = encodeContractCall(originBytes, addressBytes, codec.call.enc(args ?? {}), value);
 			const blockHash = at ?? (await client.getFinalizedBlock()).hash;
 			checkAborted(signal, method);
 			const executeCall = async () => {
 				return fromHex(await client._request("state_call", [
 					"ContractsApi_call",
-					message,
+					message$1,
 					blockHash
 				]));
 			};
@@ -1079,11 +1249,11 @@ function createD9InkContract(descriptor, address, options) {
 				try {
 					let gas = gasLimit;
 					if (!gas) {
-						const message = encodeContractCall(originBytes, addressBytes, callData, value);
+						const message$1 = encodeContractCall(originBytes, addressBytes, callData, value);
 						const blockHash = (await client.getFinalizedBlock()).hash;
 						gas = decodeContractCallResult(fromHex(await client._request("state_call", [
 							"ContractsApi_call",
-							message,
+							message$1,
 							blockHash
 						]))).gas.gasRequired;
 					}
@@ -1152,7 +1322,20 @@ function createD9InkContract(descriptor, address, options) {
 	* Filter events for this contract
 	*/
 	function filterEvents(events) {
-		return new ContractEventParser(patchedMetadata, address).filterEvents(events);
+		return new ContractEventParser(patchedDescriptor, address).filterEvents(events);
+	}
+	/**
+	* Filter events by specific type with proper type narrowing
+	*/
+	function filterEventsByType(events, label) {
+		return new ContractEventParser(patchedDescriptor, address).filterByType(events, label);
+	}
+	const messageBuilder = createMessageBuilder(descriptor);
+	/**
+	* Get a type-safe message interface
+	*/
+	function message(label) {
+		return messageBuilder.message(label);
 	}
 	/**
 	* Subscribe to contract events as an RxJS Observable
@@ -1163,7 +1346,7 @@ function createD9InkContract(descriptor, address, options) {
 	* @param options.fromBlock - Optional starting block number
 	*/
 	function subscribeToEvents(options$1) {
-		return createContractEventStream(client, patchedMetadata, {
+		return createContractEventStream(client, patchedDescriptor, {
 			...options$1,
 			contractAddress: address
 		});
@@ -1175,10 +1358,43 @@ function createD9InkContract(descriptor, address, options) {
 		send,
 		getStorage,
 		filterEvents,
+		filterEventsByType,
+		message,
 		subscribeToEvents
 	};
 }
 
+//#endregion
+//#region src/rpc.ts
+/**
+* Create a type-safe RPC request function from a PolkadotClient
+*
+* This wraps the client's `_request` method with proper TypeScript types,
+* providing autocomplete for known RPC methods and type inference for
+* parameters and return values.
+*
+* @param client - The PolkadotClient instance
+* @returns A type-safe RPC request function
+*
+* @example
+* ```ts
+* const rpc = createTypedRpc(client);
+*
+* // Autocomplete for method names, typed params and return
+* const hash = await rpc("chain_getBlockHash", [12345]);
+* // hash: HexString | null
+*
+* const header = await rpc("chain_getHeader", [hash]);
+* // header: BlockHeader | null
+*
+* // Custom methods still work with explicit types
+* const custom = await rpc<MyType>("my_custom_method", [arg]);
+* ```
+*/
+function createTypedRpc(client) {
+	return ((method, params) => client._request(method, params));
+}
+
 //#endregion
 //#region src/sdk.ts
 /**
@@ -1222,20 +1438,378 @@ function createD9InkContract(descriptor, address, options) {
 *
 * @param client - The PolkadotClient instance
 * @param options - Optional SDK configuration
-* @returns D9 Ink SDK instance
+* @returns D9 Ink SDK instance with typed RPC access
 */
 function createD9InkSdk(client, options = {}) {
 	const { typedApi, defaultQueryOptions, defaultSendOptions } = options;
-	return { getContract(descriptor, address) {
-		return createD9InkContract(descriptor, address, {
-			client,
-			typedApi,
-			defaultQueryOptions,
-			defaultSendOptions
+	return {
+		getContract(descriptor, address) {
+			return createD9InkContract(descriptor, address, {
+				client,
+				typedApi,
+				defaultQueryOptions,
+				defaultSendOptions
+			});
+		},
+		rpc: createTypedRpc(client)
+	};
+}
+
+//#endregion
+//#region src/codec-builder-internal.ts
+/**
+* Internal codec building utilities
+*
+* This module provides lower-level codec building from metadata type IDs.
+*/
+/**
+* Build a SCALE codec from ink metadata type definition
+*/
+function buildCodecFromTypeInternal(typeId, types, cache) {
+	const cached = cache.get(typeId);
+	if (cached) return cached;
+	const typeEntry = types.find((t) => t.id === typeId);
+	if (!typeEntry) throw new Error(`Type ${typeId} not found in metadata`);
+	const def = typeEntry.type.def;
+	const path = typeEntry.type.path;
+	if (def.primitive) {
+		const codec = buildPrimitiveCodec(def.primitive);
+		cache.set(typeId, codec);
+		return codec;
+	}
+	if (path && path.length > 0) {
+		const specialCodec = buildSpecialTypeCodec(path, typeEntry, types, cache);
+		if (specialCodec) {
+			cache.set(typeId, specialCodec);
+			return specialCodec;
+		}
+	}
+	if (def.tuple) {
+		const codec = buildTupleCodec(def.tuple, types, cache);
+		cache.set(typeId, codec);
+		return codec;
+	}
+	if (def.sequence) {
+		const codec = Vector(buildCodecFromTypeInternal(def.sequence.type, types, cache));
+		cache.set(typeId, codec);
+		return codec;
+	}
+	if (def.array) {
+		const innerCodec = buildCodecFromTypeInternal(def.array.type, types, cache);
+		if (def.array.type === findPrimitiveTypeId(types, "u8")) {
+			const codec$1 = Bytes$1(def.array.len);
+			cache.set(typeId, codec$1);
+			return codec$1;
+		}
+		const codec = Vector(innerCodec, def.array.len);
+		cache.set(typeId, codec);
+		return codec;
+	}
+	if (def.composite) {
+		const codec = buildCompositeCodec(def.composite, types, cache);
+		cache.set(typeId, codec);
+		return codec;
+	}
+	if (def.variant) {
+		const codec = buildVariantCodec(def.variant, path, types, cache);
+		cache.set(typeId, codec);
+		return codec;
+	}
+	throw new Error(`Unknown type definition for type ${typeId}`);
+}
+function buildPrimitiveCodec(primitive) {
+	switch (primitive) {
+		case "u8": return u8;
+		case "u16": return u16;
+		case "u32": return u32;
+		case "u64": return u64;
+		case "u128": return u128;
+		case "i8": return i8;
+		case "i16": return i16;
+		case "i32": return i32;
+		case "i64": return i64;
+		case "i128": return i128;
+		case "bool": return bool;
+		case "str": return str;
+		default: throw new Error(`Unknown primitive type: ${primitive}`);
+	}
+}
+function buildSpecialTypeCodec(path, typeEntry, types, cache) {
+	if (path.join("::").includes("AccountId")) return AccountId();
+	if (path[0] === "Option") {
+		const params = typeEntry.type.params;
+		if (params && params.length > 0 && params[0]?.type !== void 0) return Option(buildCodecFromTypeInternal(params[0].type, types, cache));
+	}
+	if (path[0] === "Result") {
+		const params = typeEntry.type.params;
+		if (params && params.length >= 2) {
+			const okTypeId = params[0]?.type;
+			const errTypeId = params[1]?.type;
+			if (okTypeId !== void 0 && errTypeId !== void 0) return Variant({
+				Ok: buildCodecFromTypeInternal(okTypeId, types, cache),
+				Err: buildCodecFromTypeInternal(errTypeId, types, cache)
+			}, [0, 1]);
+		}
+	}
+	return null;
+}
+function buildTupleCodec(tupleTypes, types, cache) {
+	if (tupleTypes.length === 0) return _void;
+	const innerCodecs = tupleTypes.map((t) => buildCodecFromTypeInternal(t, types, cache));
+	switch (innerCodecs.length) {
+		case 1: return Tuple(innerCodecs[0]);
+		case 2: return Tuple(innerCodecs[0], innerCodecs[1]);
+		case 3: return Tuple(innerCodecs[0], innerCodecs[1], innerCodecs[2]);
+		case 4: return Tuple(innerCodecs[0], innerCodecs[1], innerCodecs[2], innerCodecs[3]);
+		default: return Tuple(...innerCodecs);
+	}
+}
+function buildCompositeCodec(composite, types, cache) {
+	const fields = composite.fields;
+	if (fields.length === 1 && !fields[0]?.name) return buildCodecFromTypeInternal(fields[0].type, types, cache);
+	const structDef = {};
+	for (const field of fields) {
+		const fieldName = field.name || `field${fields.indexOf(field)}`;
+		structDef[fieldName] = buildCodecFromTypeInternal(field.type, types, cache);
+	}
+	return Struct(structDef);
+}
+function buildVariantCodec(variant, path, types, cache) {
+	const variants = variant.variants;
+	const isLangError$1 = path?.includes("LangError");
+	const variantDef = {};
+	const indices = [];
+	if (isLangError$1 && !variants.some((v) => v.index === 0)) {
+		variantDef["_Placeholder"] = _void;
+		indices.push(0);
+	}
+	for (const v of variants) {
+		let fieldCodec;
+		const fields = v.fields ?? [];
+		if (fields.length === 0) fieldCodec = _void;
+		else if (fields.length === 1 && !fields[0]?.name) fieldCodec = buildCodecFromTypeInternal(fields[0].type, types, cache);
+		else {
+			const structDef = {};
+			for (const field of fields) {
+				const fieldName = field.name || `field${fields.indexOf(field)}`;
+				structDef[fieldName] = buildCodecFromTypeInternal(field.type, types, cache);
+			}
+			fieldCodec = Struct(structDef);
+		}
+		variantDef[v.name] = fieldCodec;
+		indices.push(v.index);
+	}
+	return Variant(variantDef, indices);
+}
+function findPrimitiveTypeId(types, primitive) {
+	return types.find((t) => t.type.def.primitive === primitive)?.id ?? -1;
+}
+/**
+* Build a struct codec for message arguments
+*
+* @param metadata - The ink contract metadata
+* @param args - The argument definitions
+* @returns A struct codec
+*/
+function buildArgsCodec(metadata, args) {
+	if (args.length === 0) return {
+		enc: () => new Uint8Array(0),
+		dec: () => ({})
+	};
+	const types = metadata.types;
+	const cache = /* @__PURE__ */ new Map();
+	const structDef = {};
+	for (const arg of args) structDef[arg.label] = buildCodecFromTypeInternal(arg.type.type, types, cache);
+	const codec = Struct(structDef);
+	return {
+		enc: (value) => codec.enc(value),
+		dec: (data) => codec.dec(data)
+	};
+}
+
+//#endregion
+//#region src/calls.ts
+/**
+* Build argument decoders for all messages in the metadata
+*/
+function buildAllMessageDecodersFromMetadata(metadata) {
+	const decoders = /* @__PURE__ */ new Map();
+	const messages = metadata.spec.messages;
+	for (const message of messages) try {
+		const selectorHex = message.selector.startsWith("0x") ? message.selector.slice(2) : message.selector;
+		const selector = new Uint8Array(selectorHex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+		const argsCodec = buildArgsCodec(metadata, message.args);
+		const decoder = (data) => argsCodec.dec(data);
+		decoders.set(message.label, {
+			selector,
+			decoder
 		});
-	} };
+	} catch (error) {
+		console.warn(`Failed to build decoder for message "${message.label}":`, error);
+	}
+	return decoders;
+}
+/**
+* Type-safe call parser for a specific contract
+*
+* @typeParam S - The storage descriptor type
+* @typeParam M - The InkCallableDescriptor type (message definitions)
+* @typeParam C - The constructors descriptor type
+* @typeParam E - The events Enum type
+*/
+var ContractCallParser = class {
+	messageDecoders;
+	selectorToLabel;
+	metadata;
+	constructor(descriptor) {
+		if (!descriptor.metadata) throw new Error("Contract descriptor must include metadata");
+		this.metadata = descriptor.metadata;
+		this.messageDecoders = buildAllMessageDecodersFromMetadata(this.metadata);
+		this.selectorToLabel = /* @__PURE__ */ new Map();
+		for (const [label, { selector }] of this.messageDecoders) {
+			const selectorHex = Array.from(selector).map((b) => b.toString(16).padStart(2, "0")).join("");
+			this.selectorToLabel.set(selectorHex, label);
+		}
+	}
+	/**
+	* Parse raw call data into a type-safe contract call
+	*
+	* @param callData - The raw call data (selector + encoded args) or RawContractCall
+	* @returns Parsed call or null if cannot parse
+	*
+	* @example
+	* ```ts
+	* const call = parser.parseCall(callData);
+	* if (call?.type === "PSP22::transfer") {
+	*   // call.args is typed as { to: SS58String; value: bigint; data: Uint8Array }
+	*   console.log(call.args.to);
+	* }
+	* ```
+	*/
+	parseCall(callData) {
+		const data = callData instanceof Uint8Array ? callData : callData.data;
+		const raw = callData instanceof Uint8Array ? { data: callData } : callData;
+		if (data.length < 4) return null;
+		const selector = data.slice(0, 4);
+		const selectorHex = Array.from(selector).map((b) => b.toString(16).padStart(2, "0")).join("");
+		const label = this.selectorToLabel.get(selectorHex);
+		if (!label) return null;
+		const messageInfo = this.messageDecoders.get(label);
+		if (!messageInfo) return null;
+		const argsData = data.slice(4);
+		try {
+			return {
+				type: label,
+				args: messageInfo.decoder(argsData),
+				selector,
+				raw
+			};
+		} catch (error) {
+			console.warn(`Failed to decode call "${label}":`, error);
+			return null;
+		}
+	}
+	/**
+	* Parse multiple calls and optionally filter by message labels
+	*
+	* @param calls - Array of raw call data
+	* @param options - Filter options
+	* @returns Array of parsed calls
+	*/
+	parseCalls(calls, options) {
+		const results = [];
+		for (const call of calls) {
+			const parsed = this.parseCall(call);
+			if (!parsed) continue;
+			if (options?.messageLabels && !options.messageLabels.includes(parsed.type)) continue;
+			results.push(parsed);
+		}
+		return results;
+	}
+	/**
+	* Filter calls by specific type with proper type narrowing
+	*
+	* This method provides better type safety than parseCalls with messageLabels
+	* because TypeScript can narrow the return type to only the specified call type.
+	*
+	* @param calls - Array of raw call data
+	* @param label - The message label to filter by
+	* @returns Array of calls narrowed to the specific type
+	*
+	* @example
+	* ```ts
+	* const transfers = parser.filterByType(callDataArray, "PSP22::transfer");
+	*
+	* for (const t of transfers) {
+	*   // t.args is fully typed as PSP22::transfer args
+	*   console.log(t.args.to, t.args.value);
+	* }
+	* ```
+	*/
+	filterByType(calls, label) {
+		return this.parseCalls(calls).filter((c) => c.type === label);
+	}
+	/**
+	* Get information about a message by label
+	*/
+	getMessageInfo(label) {
+		const info = this.messageDecoders.get(label);
+		if (!info) return null;
+		const message = this.metadata.spec.messages.find((m) => m.label === label);
+		if (!message) return null;
+		return {
+			label: message.label,
+			selector: info.selector,
+			mutates: message.mutates,
+			payable: message.payable,
+			args: message.args
+		};
+	}
+	/**
+	* Get all available message labels
+	*/
+	getMessageLabels() {
+		return Array.from(this.messageDecoders.keys());
+	}
+	/**
+	* Check if a selector matches a specific message
+	*/
+	matchesMessage(selector, label) {
+		const info = this.messageDecoders.get(label);
+		if (!info) return false;
+		if (selector.length !== info.selector.length) return false;
+		for (let i = 0; i < selector.length; i++) if (selector[i] !== info.selector[i]) return false;
+		return true;
+	}
+};
+/**
+* Type guard for narrowing call types
+*
+* Use this function when you have a `TypedContractCall` and need to
+* narrow it to a specific call type. This is useful when the type
+* information is lost (e.g., after serialization or in generic functions).
+*
+* @typeParam M - The InkCallableDescriptor type (message definitions)
+* @typeParam L - The specific message label to check
+* @param call - The call to check
+* @param label - The message label to match
+* @returns True if the call type matches the label
+*
+* @example
+* ```ts
+* const call = parser.parseCall(callData);
+*
+* if (call && isCallType(call, "PSP22::transfer")) {
+*   // TypeScript knows call.args is transfer args
+*   console.log(call.args.to);
+*   console.log(call.args.value);
+* }
+* ```
+*/
+function isCallType(call, label) {
+	return call.type === label;
 }
 
 //#endregion
-export { AbortedError, ContractError, ContractEventParser, ContractExecutionError, DecodeError, EncodeError, InkCodecs, LangError, MetadataError, NetworkError, SignerError, TimeoutError, TransactionError, buildAllEventDecoders, buildAllMessageDecoders, buildEventDecoder, buildMessageDecoder, createCodecRegistry, createContractEventStream, createD9InkContract, createD9InkSdk, createNativeTransferStream, createPSP22TransferStream, decodeContractCallResult, decodeInkValue, decodeResult, encodeCall, encodeContractCall, encodeContractCallWithLimits, getEventSignature, isContractError, isErrorType, isLangError, unwrapInkResult };
+export { AbortedError, ContractCallParser, ContractError, ContractEventParser, ContractExecutionError, DecodeError, EncodeError, InkCodecs, LangError, MetadataError, NetworkError, SignerError, TimeoutError, TransactionError, buildAllEventDecoders, buildAllMessageDecoders, buildEventDecoder, buildMessageDecoder, createCodecRegistry, createContractEventStream, createD9InkContract, createD9InkSdk, createMessageBuilder, createNativeTransferStream, createPSP22TransferStream, createTypedRpc, decodeContractCallResult, decodeInkValue, decodeResult, encodeCall, encodeContractCall, encodeContractCallWithLimits, getEventSignature, isCallType, isContractError, isErrorType, isEventType, isLangError, unwrapInkResult };
 //# sourceMappingURL=index.mjs.map