@d9-network/ink 0.0.6 → 0.0.7

package/dist/index.cjs

@@ -466,6 +466,27 @@ function buildAllEventDecoders(metadata) {
 function getEventSignature(eventLabel) {
 	return (0, _noble_hashes_blake2_js.blake2b)(new TextEncoder().encode(eventLabel), { dkLen: 32 });
 }
+/**
+* Create ASCII-encoded event topic (D9 chain format)
+*
+* D9 chain uses a format where:
+* - First byte is 0x00 (null)
+* - Remaining 31 bytes are ASCII characters of `ContractName::EventLabel`
+* - Total is exactly 32 bytes (truncated/padded as needed)
+*
+* @param contractName - Contract name (e.g., "MarketMaker", "Usdt")
+* @param eventLabel - Event label (e.g., "Transfer", "USDTToD9Conversion")
+* @returns 32-byte topic with null prefix and ASCII-encoded path
+*/
+function createAsciiEventTopic(contractName, eventLabel) {
+	const topic = new Uint8Array(32);
+	topic[0] = 0;
+	const encoder = new TextEncoder();
+	const fullPath = `${contractName}::${eventLabel}`;
+	const encoded = encoder.encode(fullPath);
+	topic.set(encoded.slice(0, 31), 1);
+	return topic;
+}
 
 //#endregion
 //#region src/events.ts
@@ -517,9 +538,13 @@ var ContractEventParser = class {
 		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;
+		eventLabel = this.extractEventLabelFromAsciiTopic(signature);
+		if (eventLabel && !this.eventDecoders.has(eventLabel)) eventLabel = null;
+		if (!eventLabel) {
+			for (const [label, sig] of this.eventSignatures) if (this.bytesEqual(signature, sig)) {
+				eventLabel = label;
+				break;
+			}
 		}
 		if (!eventLabel) {
 			console.warn("Unknown event signature:", signature);
@@ -550,6 +575,25 @@ var ContractEventParser = class {
 		}
 	}
 	/**
+	* Extract event label from ASCII-encoded topic (D9 chain format)
+	*
+	* D9 chain uses a format where:
+	* - First byte is 0x00 (null)
+	* - Remaining 31 bytes are ASCII characters of `ContractName::EventLabel`
+	* - Total is exactly 32 bytes (truncated/padded as needed)
+	*
+	* @param topic - The 32-byte topic from the event
+	* @returns The extracted event label, or null if not in ASCII format
+	*/
+	extractEventLabelFromAsciiTopic(topic) {
+		if (topic.length !== 32) return null;
+		if (topic[0] !== 0) return null;
+		const ascii = new TextDecoder().decode(topic.slice(1)).replace(/\0+$/, "");
+		const colonIndex = ascii.lastIndexOf("::");
+		if (colonIndex !== -1) return ascii.slice(colonIndex + 2);
+		return ascii || null;
+	}
+	/**
 	* Filter a batch of events and return type-safe results
 	*
 	* @param chainEvents - Array of chain events to filter
@@ -647,18 +691,6 @@ var ContractEventParser = class {
 		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;
-	}
 };
 /**
 * Type guard for narrowing event types
@@ -1810,6 +1842,127 @@ function isCallType(call, label) {
 	return call.type === label;
 }
 
+//#endregion
+//#region src/utils/fees.ts
+const WEIGHT_REF_TIME_PER_SECOND = 1000000000000n;
+const WEIGHT_FEE_COEFFICIENT = 1n;
+/**
+* Estimate the transaction cost from gas info and storage deposit
+*
+* Note: This is an approximation. Actual fees depend on chain configuration
+* and may vary slightly.
+*
+* @param gasInfo - Gas information from contract query
+* @param storageDeposit - Storage deposit amount (positive for charge, negative for refund)
+* @returns Estimated cost breakdown
+*
+* @example
+* ```typescript
+* const result = await contract.query("PSP22::transfer", { origin, args });
+* if (result.success) {
+*   const cost = estimateTransactionCost(
+*     { gasConsumed: result.gasConsumed, gasRequired: result.gasRequired },
+*     result.storageDeposit
+*   );
+*   console.log(`Estimated cost: ${formatBalance(cost.total, { decimals: 12 })} D9`);
+* }
+* ```
+*/
+function estimateTransactionCost(gasInfo, storageDeposit) {
+	const { gasRequired } = gasInfo;
+	const gasCost = gasRequired.refTime * WEIGHT_FEE_COEFFICIENT / WEIGHT_REF_TIME_PER_SECOND + gasRequired.proofSize;
+	const effectiveStorageDeposit = storageDeposit > 0n ? storageDeposit : 0n;
+	return {
+		gasCost,
+		storageDeposit: effectiveStorageDeposit,
+		total: gasCost + effectiveStorageDeposit
+	};
+}
+/**
+* Format gas information for human-readable display
+*
+* @param gasInfo - Gas information from contract query
+* @returns Formatted strings for ref_time and proof_size
+*
+* @example
+* ```typescript
+* const formatted = formatGasInfo(result.gasRequired);
+* console.log(`Gas: refTime=${formatted.refTime}, proofSize=${formatted.proofSize}`);
+* ```
+*/
+function formatGasInfo(gasInfo) {
+	return {
+		refTime: formatWeight(gasInfo.refTime),
+		proofSize: formatWeight(gasInfo.proofSize)
+	};
+}
+/**
+* Format a single weight value with appropriate units
+*/
+function formatWeight(weight) {
+	if (weight >= 1000000000000n) return `${(Number(weight) / 0xe8d4a51000).toFixed(2)}T`;
+	if (weight >= 1000000000n) return `${(Number(weight) / 1e9).toFixed(2)}G`;
+	if (weight >= 1000000n) return `${(Number(weight) / 1e6).toFixed(2)}M`;
+	if (weight >= 1000n) return `${(Number(weight) / 1e3).toFixed(2)}K`;
+	return weight.toString();
+}
+/**
+* Apply a safety margin to gas limits
+*
+* It's recommended to add a small margin to gas estimates to account for
+* slight variations in execution. 10% (multiplier = 1.1) is a common choice.
+*
+* @param gas - The gas weight to adjust
+* @param multiplier - The multiplier to apply (default: 1.1 for 10% margin)
+* @returns Adjusted gas weight with margin applied
+*
+* @example
+* ```typescript
+* const result = await contract.query("PSP22::transfer", { origin, args });
+* if (result.success) {
+*   // Add 10% safety margin
+*   const safeGas = applyGasMargin(result.gasRequired, 1.1);
+*   await contract.send("PSP22::transfer", {
+*     origin,
+*     args,
+*     gasLimit: safeGas,
+*   });
+* }
+* ```
+*/
+function applyGasMargin(gas, multiplier = 1.1) {
+	if (multiplier <= 0) throw new Error("Multiplier must be positive");
+	const basisPoints = BigInt(Math.round(multiplier * 1e4));
+	return {
+		refTime: gas.refTime * basisPoints / 10000n,
+		proofSize: gas.proofSize * basisPoints / 10000n
+	};
+}
+/**
+* Compare two gas weights
+*
+* @param a - First gas weight
+* @param b - Second gas weight
+* @returns -1 if a < b, 0 if equal, 1 if a > b (compares refTime first, then proofSize)
+*/
+function compareGasWeight(a, b) {
+	if (a.refTime < b.refTime) return -1;
+	if (a.refTime > b.refTime) return 1;
+	if (a.proofSize < b.proofSize) return -1;
+	if (a.proofSize > b.proofSize) return 1;
+	return 0;
+}
+/**
+* Check if gas weight exceeds a limit
+*
+* @param gas - The gas to check
+* @param limit - The limit to compare against
+* @returns True if gas exceeds the limit in either dimension
+*/
+function gasExceedsLimit(gas, limit) {
+	return gas.refTime > limit.refTime || gas.proofSize > limit.proofSize;
+}
+
 //#endregion
 exports.AbortedError = AbortedError;
 exports.ContractCallParser = ContractCallParser;
@@ -1825,10 +1978,13 @@ exports.NetworkError = NetworkError;
 exports.SignerError = SignerError;
 exports.TimeoutError = TimeoutError;
 exports.TransactionError = TransactionError;
+exports.applyGasMargin = applyGasMargin;
 exports.buildAllEventDecoders = buildAllEventDecoders;
 exports.buildAllMessageDecoders = buildAllMessageDecoders;
 exports.buildEventDecoder = buildEventDecoder;
 exports.buildMessageDecoder = buildMessageDecoder;
+exports.compareGasWeight = compareGasWeight;
+exports.createAsciiEventTopic = createAsciiEventTopic;
 exports.createCodecRegistry = createCodecRegistry;
 exports.createContractEventStream = createContractEventStream;
 exports.createD9InkContract = createD9InkContract;
@@ -1843,6 +1999,9 @@ exports.decodeResult = decodeResult;
 exports.encodeCall = encodeCall;
 exports.encodeContractCall = encodeContractCall;
 exports.encodeContractCallWithLimits = encodeContractCallWithLimits;
+exports.estimateTransactionCost = estimateTransactionCost;
+exports.formatGasInfo = formatGasInfo;
+exports.gasExceedsLimit = gasExceedsLimit;
 exports.getEventSignature = getEventSignature;
 exports.isCallType = isCallType;
 exports.isContractError = isContractError;