@d9-network/ink 0.0.3 → 0.0.4

package/dist/index.cjs

@@ -0,0 +1,1274 @@
+let polkadot_api = require("polkadot-api");
+let polkadot_api_utils = require("polkadot-api/utils");
+let _polkadot_api_ink_contracts = require("@polkadot-api/ink-contracts");
+let _polkadot_labs_hdkd_helpers = require("@polkadot-labs/hdkd-helpers");
+let _subsquid_scale_codec = require("@subsquid/scale-codec");
+let _polkadot_api_substrate_bindings = require("@polkadot-api/substrate-bindings");
+let _noble_hashes_blake2_js = require("@noble/hashes/blake2.js");
+let rxjs = require("rxjs");
+
+//#region src/encode.ts
+/**
+* Encode a contract call for ContractsApi_call state_call.
+*
+* The encoded format matches the ContractsApi::call runtime API:
+* - origin: AccountId (32 bytes)
+* - dest: AccountId (32 bytes)
+* - value: Balance (u128)
+* - gas_limit: Option<Weight> (1 byte for None)
+* - storage_deposit_limit: Option<Balance> (1 byte for None)
+* - input_data: Vec<u8> (compact length + bytes)
+*
+* @param origin - The origin account (as Uint8Array or hex string)
+* @param dest - The contract address (as Uint8Array or hex string)
+* @param input - The encoded call data (selector + arguments)
+* @param value - Optional value to transfer (default: 0)
+* @returns Hex-encoded bytes for state_call
+*/
+function encodeContractCall(origin, dest, input, value = 0n) {
+	const sink = new _subsquid_scale_codec.HexSink();
+	const originBytes = typeof origin === "string" ? (0, polkadot_api_utils.fromHex)(origin) : origin;
+	const destBytes = typeof dest === "string" ? (0, polkadot_api_utils.fromHex)(dest) : dest;
+	const inputBytes = "asBytes" in input ? input.asBytes() : input;
+	sink.bytes(originBytes);
+	sink.bytes(destBytes);
+	sink.u128(value);
+	sink.u8(0);
+	sink.u8(0);
+	sink.compact(inputBytes.length);
+	sink.bytes(inputBytes);
+	return sink.toHex();
+}
+/**
+* Encode a contract call using the same address for origin and dest.
+* This is a simplified version for query operations where the origin
+* doesn't matter much.
+*
+* @param address - The contract address
+* @param input - The encoded call data
+* @param value - Optional value to transfer
+* @returns Hex-encoded bytes for state_call
+*/
+function encodeCall(address, input, value = 0n) {
+	return encodeContractCall(address, address, input, value);
+}
+/**
+* Encode a contract call with specific gas limit and storage deposit limit.
+*
+* @param origin - The origin account
+* @param dest - The contract address
+* @param input - The encoded call data
+* @param options - Call options including value, gas limit, storage deposit limit
+* @returns Hex-encoded bytes for state_call
+*/
+function encodeContractCallWithLimits(origin, dest, input, options = {}) {
+	const sink = new _subsquid_scale_codec.HexSink();
+	const originBytes = typeof origin === "string" ? (0, polkadot_api_utils.fromHex)(origin) : origin;
+	const destBytes = typeof dest === "string" ? (0, polkadot_api_utils.fromHex)(dest) : dest;
+	const inputBytes = "asBytes" in input ? input.asBytes() : input;
+	sink.bytes(originBytes);
+	sink.bytes(destBytes);
+	sink.u128(options.value ?? 0n);
+	if (options.gasLimit) {
+		sink.u8(1);
+		sink.compact(options.gasLimit.refTime);
+		sink.compact(options.gasLimit.proofSize);
+	} else sink.u8(0);
+	if (options.storageDepositLimit !== void 0) {
+		sink.u8(1);
+		sink.u128(options.storageDepositLimit);
+	} else sink.u8(0);
+	sink.compact(inputBytes.length);
+	sink.bytes(inputBytes);
+	return sink.toHex();
+}
+
+//#endregion
+//#region src/decode.ts
+/**
+* Decoding utilities for ContractsApi_call response
+*/
+/**
+* Decode the raw ContractsApi_call response.
+*
+* The response format is:
+* - gasConsumed: Weight { ref_time: Compact<u64>, proof_size: Compact<u64> }
+* - gasRequired: Weight
+* - storageDeposit: StorageDeposit { variant: u8, amount: u128 }
+* - debugMessage: String
+* - result: Result<ExecReturnValue, DispatchError>
+*   - ExecReturnValue: { flags: u32, data: Vec<u8> }
+*
+* @param result - The raw response bytes from state_call ContractsApi_call
+* @returns Decoded contract call result
+*/
+function decodeContractCallResult(result) {
+	const src = new _subsquid_scale_codec.Src(result);
+	const gasConsumedRefTime = BigInt(src.compact());
+	const gasConsumedProofSize = BigInt(src.compact());
+	const gasRequiredRefTime = BigInt(src.compact());
+	const gasRequiredProofSize = BigInt(src.compact());
+	const storageDepositVariant = src.u8();
+	const storageDepositAmount = src.u128();
+	const debugMessage = src.str();
+	const success = src.u8() === 0;
+	const flags = src.u32();
+	const data = src.bytes(src.compactLength());
+	return {
+		gas: {
+			gasConsumed: {
+				refTime: gasConsumedRefTime,
+				proofSize: gasConsumedProofSize
+			},
+			gasRequired: {
+				refTime: gasRequiredRefTime,
+				proofSize: gasRequiredProofSize
+			}
+		},
+		storageDeposit: {
+			type: storageDepositVariant === 0 ? "Refund" : "Charge",
+			amount: storageDepositAmount
+		},
+		debugMessage,
+		success,
+		flags,
+		data
+	};
+}
+/**
+* Legacy function - decode and return just the exec result data.
+* @deprecated Use decodeContractCallResult for full information
+*/
+function decodeResult(result) {
+	return decodeContractCallResult(result).data;
+}
+/**
+* Unwrap the inner value from Result<T, LangError> by checking the variant byte.
+*
+* Ink contracts wrap their return values in Result<T, LangError>.
+* This function handles the unwrapping and throws an error for LangError.
+*
+* @param data - The exec result bytes (Result<T, LangError> encoded)
+* @returns The inner value bytes (T encoded)
+* @throws Error if the result is Err variant (LangError)
+*/
+function unwrapInkResult(data) {
+	if (data.length === 0) throw new Error("Empty result data");
+	const variant = data[0];
+	if (variant === 0) return data.slice(1);
+	else if (variant === 1) throw new Error("Contract call returned LangError");
+	else throw new Error(`Unknown result variant: ${variant}`);
+}
+/**
+* Check if the result indicates a LangError
+*
+* @param data - The exec result bytes
+* @returns True if it's a LangError (Err variant)
+*/
+function isLangError(data) {
+	return data.length > 0 && data[0] === 1;
+}
+/**
+* Decode ink contract message result using a custom SCALE codec.
+* This bypasses polkadot-api's ink decoder which has issues with LangError type.
+*
+* @param data - The exec result bytes (Result<T, LangError> encoded)
+* @param codec - The SCALE codec for the inner value type T
+* @returns The decoded value
+*/
+function decodeInkValue(data, codec) {
+	const innerData = unwrapInkResult(data);
+	return codec.dec(innerData);
+}
+/**
+* Pre-defined codecs for common types
+*/
+const InkCodecs = {
+	u128: _polkadot_api_substrate_bindings.u128,
+	balancePair: (0, _polkadot_api_substrate_bindings.Tuple)(_polkadot_api_substrate_bindings.u128, _polkadot_api_substrate_bindings.u128)
+};
+
+//#endregion
+//#region src/codec-builder.ts
+/**
+* Auto-build SCALE decoders from ink metadata type definitions.
+*
+* This module provides a way to automatically construct decoders for ink contract
+* message return types without manually specifying codecs for each message.
+*/
+/**
+* Build a SCALE codec from ink metadata type definition
+*/
+function buildCodecFromType(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 = (0, _polkadot_api_substrate_bindings.Vector)(buildCodecFromType(def.sequence.type, types, cache));
+		cache.set(typeId, codec);
+		return codec;
+	}
+	if (def.array) {
+		const innerCodec = buildCodecFromType(def.array.type, types, cache);
+		if (def.array.type === findPrimitiveTypeId(types, "u8")) {
+			const codec$1 = (0, _polkadot_api_substrate_bindings.Bytes)(def.array.len);
+			cache.set(typeId, codec$1);
+			return codec$1;
+		}
+		const codec = (0, _polkadot_api_substrate_bindings.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}: ${JSON.stringify(def)}`);
+}
+/**
+* Build codec for primitive types
+*/
+function buildPrimitiveCodec(primitive) {
+	switch (primitive) {
+		case "u8": return _polkadot_api_substrate_bindings.u8;
+		case "u16": return _polkadot_api_substrate_bindings.u16;
+		case "u32": return _polkadot_api_substrate_bindings.u32;
+		case "u64": return _polkadot_api_substrate_bindings.u64;
+		case "u128": return _polkadot_api_substrate_bindings.u128;
+		case "i8": return _polkadot_api_substrate_bindings.i8;
+		case "i16": return _polkadot_api_substrate_bindings.i16;
+		case "i32": return _polkadot_api_substrate_bindings.i32;
+		case "i64": return _polkadot_api_substrate_bindings.i64;
+		case "i128": return _polkadot_api_substrate_bindings.i128;
+		case "bool": return _polkadot_api_substrate_bindings.bool;
+		case "str": return _polkadot_api_substrate_bindings.str;
+		default: throw new Error(`Unknown primitive type: ${primitive}`);
+	}
+}
+/**
+* Build codec for special types based on path
+*/
+function buildSpecialTypeCodec(path, typeEntry, types, cache) {
+	if (path.join("::").includes("AccountId")) return (0, _polkadot_api_substrate_bindings.AccountId)();
+	if (path[0] === "Option") {
+		const params = typeEntry.type.params;
+		if (params && params.length > 0 && params[0]?.type !== void 0) return (0, _polkadot_api_substrate_bindings.Option)(buildCodecFromType(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 (0, _polkadot_api_substrate_bindings.Variant)({
+				Ok: buildCodecFromType(okTypeId, types, cache),
+				Err: buildCodecFromType(errTypeId, types, cache)
+			}, [0, 1]);
+		}
+	}
+	return null;
+}
+/**
+* Build codec for tuple types
+*/
+function buildTupleCodec(tupleTypes, types, cache) {
+	if (tupleTypes.length === 0) return _polkadot_api_substrate_bindings._void;
+	const innerCodecs = tupleTypes.map((t) => buildCodecFromType(t, types, cache));
+	switch (innerCodecs.length) {
+		case 1: return (0, _polkadot_api_substrate_bindings.Tuple)(innerCodecs[0]);
+		case 2: return (0, _polkadot_api_substrate_bindings.Tuple)(innerCodecs[0], innerCodecs[1]);
+		case 3: return (0, _polkadot_api_substrate_bindings.Tuple)(innerCodecs[0], innerCodecs[1], innerCodecs[2]);
+		case 4: return (0, _polkadot_api_substrate_bindings.Tuple)(innerCodecs[0], innerCodecs[1], innerCodecs[2], innerCodecs[3]);
+		default: return (0, _polkadot_api_substrate_bindings.Tuple)(...innerCodecs);
+	}
+}
+/**
+* Build codec for composite (struct) types
+*/
+function buildCompositeCodec(composite, types, cache) {
+	const fields = composite.fields;
+	if (fields.length === 1 && !fields[0]?.name) return buildCodecFromType(fields[0].type, types, cache);
+	const structDef = {};
+	for (const field of fields) {
+		const fieldName = field.name || `field${fields.indexOf(field)}`;
+		structDef[fieldName] = buildCodecFromType(field.type, types, cache);
+	}
+	return (0, _polkadot_api_substrate_bindings.Struct)(structDef);
+}
+/**
+* Build codec for variant (enum) types
+*/
+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"] = _polkadot_api_substrate_bindings._void;
+		indices.push(0);
+	}
+	for (const v of variants) {
+		let fieldCodec;
+		const fields = v.fields ?? [];
+		if (fields.length === 0) fieldCodec = _polkadot_api_substrate_bindings._void;
+		else if (fields.length === 1 && !fields[0]?.name) fieldCodec = buildCodecFromType(fields[0].type, types, cache);
+		else {
+			const structDef = {};
+			for (const field of fields) {
+				const fieldName = field.name || `field${fields.indexOf(field)}`;
+				structDef[fieldName] = buildCodecFromType(field.type, types, cache);
+			}
+			fieldCodec = (0, _polkadot_api_substrate_bindings.Struct)(structDef);
+		}
+		variantDef[v.name] = fieldCodec;
+		indices.push(v.index);
+	}
+	return (0, _polkadot_api_substrate_bindings.Variant)(variantDef, indices);
+}
+/**
+* Find the type ID for a primitive type
+*/
+function findPrimitiveTypeId(types, primitive) {
+	return types.find((t) => t.type.def.primitive === primitive)?.id ?? -1;
+}
+/**
+* Extract the inner type from Result<T, LangError>
+* Returns the type ID of T
+*/
+function extractResultInnerType(typeEntry) {
+	const path = typeEntry.type.path;
+	if (!path || path[0] !== "Result") return null;
+	const params = typeEntry.type.params;
+	if (!params || params.length < 1) return null;
+	return params[0]?.type ?? null;
+}
+/**
+* Build a decoder for a message's return type from ink metadata.
+* This handles the Result<T, LangError> wrapper and returns a decoder for T.
+*
+* @param metadata - The ink contract metadata
+* @param messageLabel - The message label (e.g., "PSP22::balance_of")
+* @returns A decoder function that decodes the inner value bytes
+*/
+function buildMessageDecoder(metadata, messageLabel) {
+	const types = metadata.types;
+	const message = metadata.spec.messages.find((m) => m.label === messageLabel);
+	if (!message) throw new Error(`Message "${messageLabel}" not found in metadata`);
+	const returnTypeId = message.returnType.type;
+	const returnTypeEntry = types.find((t) => t.id === returnTypeId);
+	if (!returnTypeEntry) throw new Error(`Return type ${returnTypeId} not found for message "${messageLabel}"`);
+	const cache = /* @__PURE__ */ new Map();
+	const innerTypeId = extractResultInnerType(returnTypeEntry);
+	if (innerTypeId !== null) {
+		const innerCodec = buildCodecFromType(innerTypeId, types, cache);
+		return (data) => innerCodec.dec(data);
+	}
+	const codec = buildCodecFromType(returnTypeId, types, cache);
+	return (data) => codec.dec(data);
+}
+/**
+* Build decoders for all messages in the metadata.
+* Returns a Map of message label -> decoder function.
+*/
+function buildAllMessageDecoders(metadata) {
+	const decoders = /* @__PURE__ */ new Map();
+	for (const message of metadata.spec.messages) try {
+		const decoder = buildMessageDecoder(metadata, message.label);
+		decoders.set(message.label, decoder);
+	} catch (error) {
+		console.warn(`Failed to build decoder for message "${message.label}":`, error);
+	}
+	return decoders;
+}
+/**
+* Create a codec registry compatible with ResponseDecoder type
+*/
+function createCodecRegistry(metadata) {
+	const decoders = buildAllMessageDecoders(metadata);
+	const registry = /* @__PURE__ */ new Map();
+	for (const [label, decoder] of decoders) registry.set(label, { dec: decoder });
+	return registry;
+}
+/**
+* Build a SCALE decoder for a contract event from ink metadata
+*
+* @param metadata - The ink contract metadata
+* @param eventLabel - The event label (e.g., "Transfer", "Approval")
+* @returns A decoder function that decodes the event data bytes
+*/
+function buildEventDecoder(metadata, eventLabel) {
+	const types = metadata.types;
+	const event = metadata.spec.events.find((e) => e.label === eventLabel);
+	if (!event) throw new Error(`Event "${eventLabel}" not found in metadata`);
+	const cache = /* @__PURE__ */ new Map();
+	const structDef = {};
+	for (const arg of event.args) {
+		const fieldName = arg.label;
+		structDef[fieldName] = buildCodecFromType(arg.type.type, types, cache);
+	}
+	if (event.args.length === 0) return () => void 0;
+	if (event.args.length === 1) {
+		const argCodec = structDef[event.args[0].label];
+		return (data) => argCodec.dec(data);
+	}
+	const codec = (0, _polkadot_api_substrate_bindings.Struct)(structDef);
+	return (data) => codec.dec(data);
+}
+/**
+* Build decoders for all events in the metadata
+*
+* @param metadata - The ink contract metadata
+* @returns Map of event label -> decoder function
+*/
+function buildAllEventDecoders(metadata) {
+	const decoders = /* @__PURE__ */ new Map();
+	const events = metadata.spec.events;
+	for (const event of events) try {
+		const decoder = buildEventDecoder(metadata, event.label);
+		decoders.set(event.label, decoder);
+	} catch (error) {
+		console.warn(`Failed to build decoder for event "${event.label}":`, error);
+	}
+	return decoders;
+}
+/**
+* Get event signature (topic[0]) for filtering
+* Events in ink! use blake2_256 hash of event label as topic[0]
+*
+* @param eventLabel - The event label (e.g., "Transfer")
+* @returns Event signature as Uint8Array (32 bytes)
+*/
+function getEventSignature(eventLabel) {
+	return (0, _noble_hashes_blake2_js.blake2b)(new TextEncoder().encode(eventLabel), { dkLen: 32 });
+}
+
+//#endregion
+//#region src/events.ts
+/**
+* Event parser for a specific contract
+*/
+var ContractEventParser = class {
+	eventDecoders;
+	eventSignatures;
+	contractAddressBytes;
+	contractAddress;
+	metadata;
+	constructor(metadata, contractAddress) {
+		this.metadata = metadata;
+		this.contractAddress = contractAddress;
+		this.eventDecoders = buildAllEventDecoders(metadata);
+		this.contractAddressBytes = (0, _polkadot_labs_hdkd_helpers.ss58Decode)(contractAddress)[0];
+		this.eventSignatures = /* @__PURE__ */ new Map();
+		const events = 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)
+	* Returns null if the event is not from this contract or cannot be parsed
+	*/
+	parseEvent(chainEvent) {
+		const extracted = this.extractContractEmittedEvent(chainEvent);
+		if (!extracted) return null;
+		const { contract, data, topics, blockNumber, blockHash, eventIndex } = extracted;
+		if (!this.bytesEqual(contract, this.contractAddressBytes)) return null;
+		if (topics.length === 0) return null;
+		const signature = topics[0];
+		let eventLabel = null;
+		for (const [label, sig] of this.eventSignatures) if (this.bytesEqual(signature, sig)) {
+			eventLabel = label;
+			break;
+		}
+		if (!eventLabel) {
+			console.warn("Unknown event signature:", signature);
+			return null;
+		}
+		const decoder = this.eventDecoders.get(eventLabel);
+		if (!decoder) {
+			console.warn(`No decoder for event ${eventLabel}`);
+			return null;
+		}
+		try {
+			const decodedData = decoder(data);
+			return {
+				label: eventLabel,
+				data: decodedData,
+				raw: {
+					blockNumber,
+					blockHash,
+					eventIndex,
+					contractAddress: this.getContractAddress(),
+					data,
+					topics
+				}
+			};
+		} catch (error) {
+			console.warn(`Failed to decode event ${eventLabel}:`, error);
+			return null;
+		}
+	}
+	/**
+	* Filter a batch of 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?.fromBlock && parsed.raw.blockNumber < options.fromBlock) continue;
+			if (options?.toBlock && parsed.raw.blockNumber > options.toBlock) continue;
+			results.push(parsed);
+		}
+		return results;
+	}
+	/**
+	* Get the contract address as SS58 string
+	*/
+	getContractAddress() {
+		return this.contractAddress;
+	}
+	/**
+	* Extract ContractEmitted event from chain event structure
+	* Based on polkadot-api event format
+	*/
+	extractContractEmittedEvent(chainEvent) {
+		if (!chainEvent || typeof chainEvent !== "object") return null;
+		const record = chainEvent;
+		const event = record.event;
+		if (!event || typeof event !== "object") return null;
+		if (event.type !== "Contracts") return null;
+		const eventValue = event.value;
+		if (!eventValue || typeof eventValue !== "object") return null;
+		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 topics = [];
+		if (record.topics && Array.isArray(record.topics)) {
+			for (const topic of record.topics) if (topic instanceof Uint8Array) topics.push(topic);
+		}
+		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
+		};
+	}
+	/**
+	* Compare two Uint8Arrays for equality
+	*/
+	bytesEqual(a, b) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+		return true;
+	}
+	/**
+	* Build event signature map from metadata
+	*/
+	static buildEventSignatureMap(metadata) {
+		const signatures = /* @__PURE__ */ new Map();
+		const events = metadata.spec.events;
+		for (const event of events) {
+			const sig = getEventSignature(event.label);
+			signatures.set(event.label, sig);
+		}
+		return signatures;
+	}
+};
+
+//#endregion
+//#region src/subscriptions.ts
+/**
+* Event subscriptions using RxJS
+*/
+/**
+* Create an observable stream of contract events
+*
+* @param client - Polkadot API client
+* @param metadata - Contract metadata
+* @param options - Subscription options
+* @returns Observable stream of decoded contract events
+*/
+function createContractEventStream(client, metadata, options) {
+	const parser = new ContractEventParser(metadata, options.contractAddress);
+	return client.finalizedBlock$.pipe((0, rxjs.mergeMap)(async (block) => {
+		try {
+			return {
+				block,
+				events: await options.getEvents(block.hash)
+			};
+		} catch (error) {
+			console.error("Error fetching events at block", block.number, ":", error instanceof Error ? error.message : String(error));
+			return {
+				block,
+				events: []
+			};
+		}
+	}), (0, rxjs.map)(({ block, events }) => {
+		return events.map((event, index) => {
+			const eventWithMeta = {
+				...event,
+				blockNumber: block.number,
+				blockHash: block.hash,
+				eventIndex: index
+			};
+			return parser.parseEvent(eventWithMeta);
+		}).filter((e) => e !== null);
+	}), (0, rxjs.mergeMap)((events) => (0, rxjs.from)(events)), (0, rxjs.filter)((event) => {
+		if (!options.eventLabels) return true;
+		return options.eventLabels.includes(event.label);
+	}), (0, rxjs.catchError)((error) => {
+		console.error("Error in contract event stream:", error);
+		return (0, rxjs.of)();
+	}), (0, rxjs.share)());
+}
+/**
+* Convenience helper to create a Transfer event stream for PSP22 tokens
+*
+* @param client - Polkadot API client
+* @param metadata - PSP22 contract metadata
+* @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, {
+		contractAddress,
+		eventLabels: ["Transfer"],
+		getEvents
+	}).pipe((0, rxjs.filter)((event) => {
+		if (!watchAddress) return true;
+		const data = event.data;
+		return data.from === watchAddress || data.to === watchAddress;
+	}));
+}
+/**
+* Create a native token (D9) transfer event stream
+*
+* This monitors System.Transfer events instead of contract events
+*
+* @param client - Polkadot API client
+* @param getEvents - Function to fetch System.Events at a block hash
+* @param watchAddress - Address to monitor for transfers
+* @returns Observable stream of native transfer events
+*/
+function createNativeTransferStream(client, getEvents, watchAddress) {
+	return client.finalizedBlock$.pipe((0, rxjs.mergeMap)(async (block) => {
+		try {
+			return {
+				block,
+				events: await getEvents(block.hash)
+			};
+		} catch (error) {
+			console.error("Error fetching events for native transfers:", error instanceof Error ? error.message : String(error));
+			return {
+				block,
+				events: []
+			};
+		}
+	}), (0, rxjs.map)(({ block, events }) => {
+		return events.map((record) => {
+			if (record.event?.type !== "Balances") return null;
+			if (record.event?.value?.type !== "Transfer") return null;
+			const { from: from$1, to, amount } = record.event.value.value;
+			if (from$1 !== watchAddress && to !== watchAddress) return null;
+			return {
+				from: from$1,
+				to,
+				amount,
+				blockNumber: block.number,
+				blockHash: block.hash
+			};
+		}).filter((t) => t !== null);
+	}), (0, rxjs.mergeMap)((transfers) => (0, rxjs.from)(transfers)), (0, rxjs.catchError)((error) => {
+		console.error("Error in native transfer stream:", error);
+		return (0, rxjs.of)();
+	}), (0, rxjs.share)());
+}
+
+//#endregion
+//#region src/errors.ts
+/**
+* Base error class for all contract-related errors
+*/
+var ContractError = class ContractError extends Error {
+	timestamp;
+	cause;
+	constructor(message, type, label, details, cause) {
+		super(message, { cause });
+		this.type = type;
+		this.label = label;
+		this.details = details;
+		this.name = "ContractError";
+		this.timestamp = /* @__PURE__ */ new Date();
+		if (Error.captureStackTrace) Error.captureStackTrace(this, ContractError);
+	}
+	/**
+	* Create a formatted error message for logging
+	*/
+	toLogString() {
+		const parts = [
+			`[${this.type}]`,
+			this.label ? `${this.label}:` : "",
+			this.message
+		].filter(Boolean);
+		if (this.details) parts.push(`Details: ${JSON.stringify(this.details)}`);
+		return parts.join(" ");
+	}
+	/**
+	* Convert to a plain object for serialization
+	*/
+	toJSON() {
+		return {
+			name: this.name,
+			type: this.type,
+			message: this.message,
+			label: this.label,
+			details: this.details,
+			timestamp: this.timestamp.toISOString(),
+			stack: this.stack
+		};
+	}
+};
+/**
+* Error thrown when contract metadata is missing or invalid
+*/
+var MetadataError = class extends ContractError {
+	constructor(message, details) {
+		super(message, "METADATA_ERROR", void 0, details);
+		this.name = "MetadataError";
+	}
+};
+/**
+* Error thrown when encoding call data fails
+*/
+var EncodeError = class extends ContractError {
+	constructor(label, message, details) {
+		super(message, "ENCODE_ERROR", label, details);
+		this.name = "EncodeError";
+	}
+};
+/**
+* Error thrown when decoding response fails
+*/
+var DecodeError = class extends ContractError {
+	constructor(label, message, details) {
+		super(message, "DECODE_ERROR", label, details);
+		this.name = "DecodeError";
+	}
+};
+/**
+* Error thrown for network/RPC errors
+*/
+var NetworkError = class extends ContractError {
+	constructor(message, cause, details) {
+		super(message, "NETWORK_ERROR", void 0, details, cause);
+		this.name = "NetworkError";
+	}
+};
+/**
+* Error thrown when contract returns an error result
+*/
+var ContractExecutionError = class extends ContractError {
+	constructor(label, errorValue) {
+		super(`Contract execution failed: ${JSON.stringify(errorValue)}`, "CONTRACT_ERROR", label, errorValue);
+		this.errorValue = errorValue;
+		this.name = "ContractExecutionError";
+	}
+};
+/**
+* Error thrown for Ink LangError
+*/
+var LangError = class extends ContractError {
+	constructor(label, variant) {
+		const variantName = variant === 1 ? "CouldNotReadInput" : `Unknown(${variant})`;
+		super(`Ink LangError: ${variantName}`, "LANG_ERROR", label, {
+			variant,
+			variantName
+		});
+		this.variant = variant;
+		this.name = "LangError";
+	}
+};
+/**
+* Error thrown when request times out
+*/
+var TimeoutError = class extends ContractError {
+	constructor(label, timeoutMs) {
+		super(`Request timed out after ${timeoutMs}ms`, "TIMEOUT_ERROR", label, { timeoutMs });
+		this.timeoutMs = timeoutMs;
+		this.name = "TimeoutError";
+	}
+};
+/**
+* Error thrown when request is aborted
+*/
+var AbortedError = class extends ContractError {
+	constructor(label, reason) {
+		super(reason || "Request was aborted", "ABORTED", label, { reason });
+		this.name = "AbortedError";
+	}
+};
+/**
+* Error thrown for signer-related issues
+*/
+var SignerError = class extends ContractError {
+	constructor(message, details) {
+		super(message, "SIGNER_ERROR", void 0, details);
+		this.name = "SignerError";
+	}
+};
+/**
+* Error thrown when transaction submission fails
+*/
+var TransactionError = class extends ContractError {
+	constructor(label, message, txHash, details) {
+		super(message, "TX_ERROR", label, {
+			...details,
+			txHash
+		});
+		this.txHash = txHash;
+		this.name = "TransactionError";
+	}
+};
+/**
+* Type guard to check if an error is a ContractError
+*/
+function isContractError(error) {
+	return error instanceof ContractError;
+}
+/**
+* Type guard to check for specific error types
+*/
+function isErrorType(error, type) {
+	return isContractError(error) && error.type === type;
+}
+
+//#endregion
+//#region src/contract.ts
+/**
+* Patch LangError type in ink metadata to fix the missing index 0 variant issue.
+* Uses structuredClone for efficient deep cloning.
+*/
+function patchLangErrorInMetadata(metadata) {
+	const patched = structuredClone(metadata);
+	for (const typeEntry of patched.types) {
+		const path = typeEntry.type?.path;
+		const def = typeEntry.type?.def;
+		if (path && Array.isArray(path) && path.includes("LangError") && def?.variant) {
+			const variants = def.variant.variants;
+			if (Array.isArray(variants)) {
+				if (!variants.some((v) => v.index === 0)) variants.unshift({
+					index: 0,
+					name: "_Placeholder",
+					fields: [],
+					docs: []
+				});
+			}
+		}
+	}
+	return patched;
+}
+/**
+* Convert SS58 address to bytes
+*/
+function ss58ToBytes(address) {
+	const [publicKey] = (0, _polkadot_labs_hdkd_helpers.ss58Decode)(address);
+	return publicKey;
+}
+/**
+* Create a promise that rejects after a timeout
+*/
+function createTimeout(ms, label) {
+	let timeoutId;
+	return {
+		promise: new Promise((_, reject) => {
+			timeoutId = setTimeout(() => {
+				reject(new TimeoutError(label, ms));
+			}, ms);
+		}),
+		clear: () => clearTimeout(timeoutId)
+	};
+}
+/**
+* Check if AbortSignal is aborted and throw if so
+*/
+function checkAborted(signal, label) {
+	if (signal?.aborted) throw new AbortedError(label, signal.reason);
+}
+/**
+* Create a D9 Ink Contract instance
+*/
+function createD9InkContract(descriptor, address, options) {
+	const { client, typedApi, defaultQueryOptions = {}, defaultSendOptions = {} } = options;
+	if (!descriptor.metadata) throw new MetadataError("Contract descriptor must include metadata");
+	const patchedMetadata = patchLangErrorInMetadata(descriptor.metadata);
+	const builder = (0, _polkadot_api_ink_contracts.getInkDynamicBuilder)((0, _polkadot_api_ink_contracts.getInkLookup)(patchedMetadata));
+	let codecRegistry;
+	try {
+		codecRegistry = createCodecRegistry(patchedMetadata);
+	} catch (error) {
+		console.warn("Failed to auto-generate codecs from metadata:", error);
+		codecRegistry = /* @__PURE__ */ new Map();
+	}
+	const addressBytes = ss58ToBytes(address);
+	const messageCodecCache = /* @__PURE__ */ new Map();
+	function getMessageCodec(label) {
+		const cached = messageCodecCache.get(label);
+		if (cached) return cached;
+		const codec = builder.buildMessage(label);
+		messageCodecCache.set(label, codec);
+		return codec;
+	}
+	/**
+	* Get the decoder for a message
+	*/
+	function getDecoder(label) {
+		return codecRegistry.get(label) ?? null;
+	}
+	/**
+	* Execute a query (dry-run)
+	*/
+	async function executeQuery(method, queryOptions) {
+		const { origin, args, value = 0n, signal, timeout, at } = {
+			...defaultQueryOptions,
+			...queryOptions
+		};
+		try {
+			checkAborted(signal, method);
+			const originBytes = ss58ToBytes(origin);
+			const codec = getMessageCodec(method);
+			const message = encodeContractCall(originBytes, addressBytes, codec.call.enc(args ?? {}), value);
+			const blockHash = at ?? (await client.getFinalizedBlock()).hash;
+			checkAborted(signal, method);
+			const executeCall = async () => {
+				return (0, polkadot_api_utils.fromHex)(await client._request("state_call", [
+					"ContractsApi_call",
+					message,
+					blockHash
+				]));
+			};
+			let rawResponse;
+			if (timeout) {
+				const { promise: timeoutPromise, clear } = createTimeout(timeout, method);
+				try {
+					rawResponse = await Promise.race([executeCall(), timeoutPromise]);
+				} finally {
+					clear();
+				}
+			} else rawResponse = await executeCall();
+			checkAborted(signal, method);
+			const callResult = decodeContractCallResult(rawResponse);
+			if (!callResult.success) return {
+				success: false,
+				error: new ContractError(`Contract execution failed: ${callResult.debugMessage}`, "CONTRACT_ERROR", method)
+			};
+			if (isLangError(callResult.data)) return {
+				success: false,
+				error: new LangError(method, callResult.data[1] ?? 1)
+			};
+			const innerData = unwrapInkResult(callResult.data);
+			let decodedResponse;
+			const decoder = getDecoder(method);
+			if (decoder) try {
+				decodedResponse = decoder.dec(innerData);
+			} catch (decodeError) {
+				console.warn("D9InkContract: Failed to decode response:", decodeError);
+				const fullResult = new Uint8Array(1 + innerData.length);
+				fullResult[0] = 0;
+				fullResult.set(innerData, 1);
+				try {
+					const papiResult = codec.value.dec(fullResult);
+					if (papiResult !== null && typeof papiResult === "object" && "success" in papiResult && "value" in papiResult) if (papiResult.success) decodedResponse = papiResult.value;
+					else return {
+						success: false,
+						error: new DecodeError(method, `Contract returned error: ${JSON.stringify(papiResult.value)}`, papiResult.value)
+					};
+					else decodedResponse = papiResult;
+				} catch (error) {
+					return {
+						success: false,
+						error: new DecodeError(method, `Failed to decode response: ${error instanceof Error ? error.message : String(error)}`, { error })
+					};
+				}
+			}
+			else {
+				const fullResult = new Uint8Array(1 + innerData.length);
+				fullResult[0] = 0;
+				fullResult.set(innerData, 1);
+				const papiResult = codec.value.dec(fullResult);
+				if (papiResult !== null && typeof papiResult === "object" && "success" in papiResult && "value" in papiResult) if (papiResult.success) decodedResponse = papiResult.value;
+				else return {
+					success: false,
+					error: new DecodeError(method, `Contract returned error: ${JSON.stringify(papiResult.value)}`, papiResult.value)
+				};
+				else decodedResponse = papiResult;
+			}
+			return {
+				success: true,
+				value: decodedResponse,
+				events: [],
+				gasConsumed: callResult.gas.gasConsumed,
+				gasRequired: callResult.gas.gasRequired,
+				storageDeposit: callResult.storageDeposit.amount,
+				send: () => createSendableTransaction(method, {
+					origin,
+					args,
+					value,
+					gasLimit: callResult.gas.gasRequired
+				})
+			};
+		} catch (error) {
+			if (error instanceof ContractError) return {
+				success: false,
+				error
+			};
+			return {
+				success: false,
+				error: new ContractError(error instanceof Error ? error.message : String(error), "NETWORK_ERROR", method)
+			};
+		}
+	}
+	/**
+	* Create a sendable transaction
+	*/
+	function createSendableTransaction(method, sendOptions) {
+		const { origin, args, value = 0n, gasLimit, storageDepositLimit } = {
+			...defaultSendOptions,
+			...sendOptions
+		};
+		const originBytes = ss58ToBytes(origin);
+		const callData = getMessageCodec(method).call.enc(args ?? {});
+		return {
+			getEncodedData: () => callData,
+			async signAndSubmit(signer) {
+				if (!typedApi) throw new TransactionError(method, "typedApi is required for transaction submission. Pass typedApi in SDK options.");
+				try {
+					let gas = gasLimit;
+					if (!gas) {
+						const message = encodeContractCall(originBytes, addressBytes, callData, value);
+						const blockHash = (await client.getFinalizedBlock()).hash;
+						gas = decodeContractCallResult((0, polkadot_api_utils.fromHex)(await client._request("state_call", [
+							"ContractsApi_call",
+							message,
+							blockHash
+						]))).gas.gasRequired;
+					}
+					const txResult = await typedApi.tx.Contracts.call({
+						dest: {
+							type: "Id",
+							value: address
+						},
+						value,
+						gas_limit: {
+							ref_time: gas.refTime,
+							proof_size: gas.proofSize
+						},
+						storage_deposit_limit: storageDepositLimit,
+						data: polkadot_api.Binary.fromBytes(callData)
+					}).signAndSubmit(signer, { at: "finalized" });
+					return {
+						ok: true,
+						txHash: txResult.txHash,
+						block: txResult.block,
+						events: txResult.events ?? []
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						txHash: "",
+						block: {
+							hash: "",
+							number: 0
+						},
+						events: [],
+						dispatchError: error
+					};
+				}
+			}
+		};
+	}
+	/**
+	* Create send method that returns a sendable transaction
+	*/
+	function send(method, sendOptions) {
+		return createSendableTransaction(method, sendOptions);
+	}
+	/**
+	* Create storage query interface
+	*/
+	function getStorage() {
+		return {
+			async getRoot() {
+				console.warn("D9InkContract: getRoot not implemented");
+				return {
+					success: false,
+					value: new ContractError("Storage queries not yet implemented", "METADATA_ERROR")
+				};
+			},
+			async getNested(path, ..._keys) {
+				console.warn("D9InkContract: getNested not implemented");
+				return {
+					success: false,
+					value: new ContractError(`Storage query for "${path}" not yet implemented`, "METADATA_ERROR")
+				};
+			}
+		};
+	}
+	/**
+	* Filter events for this contract
+	*/
+	function filterEvents(events) {
+		return new ContractEventParser(patchedMetadata, address).filterEvents(events);
+	}
+	/**
+	* Subscribe to contract events as an RxJS Observable
+	*
+	* @param options - Subscription options (contractAddress is automatically set)
+	* @param options.getEvents - Function to fetch System.Events at a block hash
+	* @param options.eventLabels - Optional filter for specific event names
+	* @param options.fromBlock - Optional starting block number
+	*/
+	function subscribeToEvents(options$1) {
+		return createContractEventStream(client, patchedMetadata, {
+			...options$1,
+			contractAddress: address
+		});
+	}
+	return {
+		address,
+		metadata: patchedMetadata,
+		query: executeQuery,
+		send,
+		getStorage,
+		filterEvents,
+		subscribeToEvents
+	};
+}
+
+//#endregion
+//#region src/sdk.ts
+/**
+* Create a D9 Ink SDK instance.
+*
+* This SDK provides a similar API to the official @polkadot-api/sdk-ink,
+* but uses state_call + ContractsApi_call instead of ReviveApi.
+*
+* @example
+* ```ts
+* import { createD9InkSdk } from "@d9-network/ink";
+* import { contracts } from "@polkadot-api/descriptors";
+*
+* const sdk = createD9InkSdk(client);
+* const usdtContract = sdk.getContract(
+*   contracts.d9_usdt,
+*   "uLj9DRUujbpCyK7USZY5ebGbxdtKoWvdRvGyyUsoLWDsNng"
+* );
+*
+* // Query balance
+* const result = await usdtContract.query("PSP22::balance_of", {
+*   origin: aliceAddress,
+*   args: { owner: aliceAddress }
+* });
+*
+* if (result.success) {
+*   console.log("Balance:", result.value.response);
+*
+*   // Send transaction from the query result
+*   const txResult = await result.value.send().signAndSubmit(aliceSigner);
+* }
+*
+* // Or send directly
+* const txResult = await usdtContract
+*   .send("PSP22::transfer", {
+*     origin: aliceAddress,
+*     args: { to: bobAddress, value: 1000n, data: [] }
+*   })
+*   .signAndSubmit(aliceSigner);
+* ```
+*
+* @param client - The PolkadotClient instance
+* @param options - Optional SDK configuration
+* @returns D9 Ink SDK instance
+*/
+function createD9InkSdk(client, options = {}) {
+	const { typedApi, defaultQueryOptions, defaultSendOptions } = options;
+	return { getContract(descriptor, address) {
+		return createD9InkContract(descriptor, address, {
+			client,
+			typedApi,
+			defaultQueryOptions,
+			defaultSendOptions
+		});
+	} };
+}
+
+//#endregion
+exports.AbortedError = AbortedError;
+exports.ContractError = ContractError;
+exports.ContractEventParser = ContractEventParser;
+exports.ContractExecutionError = ContractExecutionError;
+exports.DecodeError = DecodeError;
+exports.EncodeError = EncodeError;
+exports.InkCodecs = InkCodecs;
+exports.LangError = LangError;
+exports.MetadataError = MetadataError;
+exports.NetworkError = NetworkError;
+exports.SignerError = SignerError;
+exports.TimeoutError = TimeoutError;
+exports.TransactionError = TransactionError;
+exports.buildAllEventDecoders = buildAllEventDecoders;
+exports.buildAllMessageDecoders = buildAllMessageDecoders;
+exports.buildEventDecoder = buildEventDecoder;
+exports.buildMessageDecoder = buildMessageDecoder;
+exports.createCodecRegistry = createCodecRegistry;
+exports.createContractEventStream = createContractEventStream;
+exports.createD9InkContract = createD9InkContract;
+exports.createD9InkSdk = createD9InkSdk;
+exports.createNativeTransferStream = createNativeTransferStream;
+exports.createPSP22TransferStream = createPSP22TransferStream;
+exports.decodeContractCallResult = decodeContractCallResult;
+exports.decodeInkValue = decodeInkValue;
+exports.decodeResult = decodeResult;
+exports.encodeCall = encodeCall;
+exports.encodeContractCall = encodeContractCall;
+exports.encodeContractCallWithLimits = encodeContractCallWithLimits;
+exports.getEventSignature = getEventSignature;
+exports.isContractError = isContractError;
+exports.isErrorType = isErrorType;
+exports.isLangError = isLangError;
+exports.unwrapInkResult = unwrapInkResult;
+//# sourceMappingURL=index.cjs.map