@d9-network/ink 0.0.6 → 0.0.8

package/dist/index.d.cts

@@ -1131,6 +1131,19 @@ declare function buildAllEventDecoders(metadata: InkMetadata): Map<string, (data
  * @returns Event signature as Uint8Array (32 bytes)
  */
 declare function getEventSignature(eventLabel: string): Uint8Array;
+/**
+ * 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
+ */
+declare function createAsciiEventTopic(contractName: string, eventLabel: string): Uint8Array;
 //#endregion
 //#region src/events.d.ts
 /**
@@ -1162,6 +1175,18 @@ declare class ContractEventParser<S extends InkStorageDescriptor = InkStorageDes
    * ```
    */
   parseEvent(chainEvent: unknown): TypedContractEvent<E> | null;
+  /**
+   * 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
+   */
+  private extractEventLabelFromAsciiTopic;
   /**
    * Filter a batch of events and return type-safe results
    *
@@ -1206,10 +1231,6 @@ declare class ContractEventParser<S extends InkStorageDescriptor = InkStorageDes
    * Compare two Uint8Arrays for equality
    */
   private bytesEqual;
-  /**
-   * Build event signature map from metadata
-   */
-  private static buildEventSignatureMap;
 }
 /**
  * Type guard for narrowing event types
@@ -1428,5 +1449,111 @@ declare function isCallType<M$1 extends InkCallableDescriptor, L extends Extract
  */
 declare function createTypedRpc(client: PolkadotClient): TypedRpcRequest;
 //#endregion
-export { AbortedError, type BlockHeader, type CallFilterOptions, ContractCallParser, type ContractCallResult, ContractError, type ContractErrorType, ContractEventParser, ContractExecutionError, type ContractMessageBuilder, type ContractStorage, type CreateContractOptions, type CreateD9InkSdkOptions, type D9InkContract, type D9InkContractFromDescriptor, type D9InkSdk, type D9InkSdkOptions, type D9InkSdkWithRpc, DecodeError, type DecodedContractEvent, EncodeError, type EventFilterOptions, type EventSubscriptionOptions, type ExtractEnumDef, type ExtractEventLabels, type ExtractMessageLabels, type GasInfo, type InferEvents, type InferMessages, InkCodecs, type KnownRpcMethod, LangError, type MessageAttributes, type MessageInfo, MetadataError, NetworkError, type QueryOptions, type QueryResult, type QuerySuccessValue, type RawContractCall, type RawContractEvent, type ResponseDecoder, type RpcParams, type RpcReturn, type RuntimeVersion, type SendOptions, type SendableTransaction, SignerError, type StorageChangeSet, type StorageDepositInfo, type SubstrateRpcMethods, type SystemHealth, TimeoutError, TransactionError, type TxResult, type TypedCallFilterOptions, type TypedContractCall, type TypedContractEvent, type TypedEventFilterOptions, type TypedMessage, type TypedRpcRequest, 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 };
+//#region src/utils/fees.d.ts
+/**
+ * Gas weight representation
+ */
+interface GasWeight {
+  refTime: bigint;
+  proofSize: bigint;
+}
+/**
+ * Estimated transaction cost breakdown
+ */
+interface EstimatedCost {
+  /** Cost from gas consumption */
+  gasCost: bigint;
+  /** Storage deposit (may be refunded) */
+  storageDeposit: bigint;
+  /** Total estimated cost (gas + storage) */
+  total: bigint;
+}
+/**
+ * Formatted gas information for display
+ */
+interface FormattedGasInfo {
+  /** Human-readable ref_time */
+  refTime: string;
+  /** Human-readable proof_size */
+  proofSize: string;
+}
+/**
+ * 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`);
+ * }
+ * ```
+ */
+declare function estimateTransactionCost(gasInfo: GasInfo, storageDeposit: bigint): EstimatedCost;
+/**
+ * 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}`);
+ * ```
+ */
+declare function formatGasInfo(gasInfo: GasInfo["gasRequired"]): FormattedGasInfo;
+/**
+ * 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,
+ *   });
+ * }
+ * ```
+ */
+declare function applyGasMargin(gas: GasWeight, multiplier?: number): GasWeight;
+/**
+ * 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)
+ */
+declare function compareGasWeight(a: GasWeight, b: GasWeight): -1 | 0 | 1;
+/**
+ * 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
+ */
+declare function gasExceedsLimit(gas: GasWeight, limit: GasWeight): boolean;
+//#endregion
+export { AbortedError, type BlockHeader, type CallFilterOptions, ContractCallParser, type ContractCallResult, ContractError, type ContractErrorType, ContractEventParser, ContractExecutionError, type ContractMessageBuilder, type ContractStorage, type CreateContractOptions, type CreateD9InkSdkOptions, type D9InkContract, type D9InkContractFromDescriptor, type D9InkSdk, type D9InkSdkOptions, type D9InkSdkWithRpc, DecodeError, type DecodedContractEvent, EncodeError, EstimatedCost, type EventFilterOptions, type EventSubscriptionOptions, type ExtractEnumDef, type ExtractEventLabels, type ExtractMessageLabels, FormattedGasInfo, type GasInfo, GasWeight, type InferEvents, type InferMessages, InkCodecs, type KnownRpcMethod, LangError, type MessageAttributes, type MessageInfo, MetadataError, NetworkError, type QueryOptions, type QueryResult, type QuerySuccessValue, type RawContractCall, type RawContractEvent, type ResponseDecoder, type RpcParams, type RpcReturn, type RuntimeVersion, type SendOptions, type SendableTransaction, SignerError, type StorageChangeSet, type StorageDepositInfo, type SubstrateRpcMethods, type SystemHealth, TimeoutError, TransactionError, type TxResult, type TypedCallFilterOptions, type TypedContractCall, type TypedContractEvent, type TypedEventFilterOptions, type TypedMessage, type TypedRpcRequest, applyGasMargin, buildAllEventDecoders, buildAllMessageDecoders, buildEventDecoder, buildMessageDecoder, compareGasWeight, createAsciiEventTopic, createCodecRegistry, createContractEventStream, createD9InkContract, createD9InkSdk, createMessageBuilder, createNativeTransferStream, createPSP22TransferStream, createTypedRpc, decodeContractCallResult, decodeInkValue, decodeResult, encodeCall, encodeContractCall, encodeContractCallWithLimits, estimateTransactionCost, formatGasInfo, gasExceedsLimit, getEventSignature, isCallType, isContractError, isErrorType, isEventType, isLangError, unwrapInkResult };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.mts

@@ -1131,6 +1131,19 @@ declare function buildAllEventDecoders(metadata: InkMetadata): Map<string, (data
  * @returns Event signature as Uint8Array (32 bytes)
  */
 declare function getEventSignature(eventLabel: string): Uint8Array;
+/**
+ * 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
+ */
+declare function createAsciiEventTopic(contractName: string, eventLabel: string): Uint8Array;
 //#endregion
 //#region src/events.d.ts
 /**
@@ -1162,6 +1175,18 @@ declare class ContractEventParser<S extends InkStorageDescriptor = InkStorageDes
    * ```
    */
   parseEvent(chainEvent: unknown): TypedContractEvent<E> | null;
+  /**
+   * 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
+   */
+  private extractEventLabelFromAsciiTopic;
   /**
    * Filter a batch of events and return type-safe results
    *
@@ -1206,10 +1231,6 @@ declare class ContractEventParser<S extends InkStorageDescriptor = InkStorageDes
    * Compare two Uint8Arrays for equality
    */
   private bytesEqual;
-  /**
-   * Build event signature map from metadata
-   */
-  private static buildEventSignatureMap;
 }
 /**
  * Type guard for narrowing event types
@@ -1428,5 +1449,111 @@ declare function isCallType<M$1 extends InkCallableDescriptor, L extends Extract
  */
 declare function createTypedRpc(client: PolkadotClient): TypedRpcRequest;
 //#endregion
-export { AbortedError, type BlockHeader, type CallFilterOptions, ContractCallParser, type ContractCallResult, ContractError, type ContractErrorType, ContractEventParser, ContractExecutionError, type ContractMessageBuilder, type ContractStorage, type CreateContractOptions, type CreateD9InkSdkOptions, type D9InkContract, type D9InkContractFromDescriptor, type D9InkSdk, type D9InkSdkOptions, type D9InkSdkWithRpc, DecodeError, type DecodedContractEvent, EncodeError, type EventFilterOptions, type EventSubscriptionOptions, type ExtractEnumDef, type ExtractEventLabels, type ExtractMessageLabels, type GasInfo, type InferEvents, type InferMessages, InkCodecs, type KnownRpcMethod, LangError, type MessageAttributes, type MessageInfo, MetadataError, NetworkError, type QueryOptions, type QueryResult, type QuerySuccessValue, type RawContractCall, type RawContractEvent, type ResponseDecoder, type RpcParams, type RpcReturn, type RuntimeVersion, type SendOptions, type SendableTransaction, SignerError, type StorageChangeSet, type StorageDepositInfo, type SubstrateRpcMethods, type SystemHealth, TimeoutError, TransactionError, type TxResult, type TypedCallFilterOptions, type TypedContractCall, type TypedContractEvent, type TypedEventFilterOptions, type TypedMessage, type TypedRpcRequest, 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 };
+//#region src/utils/fees.d.ts
+/**
+ * Gas weight representation
+ */
+interface GasWeight {
+  refTime: bigint;
+  proofSize: bigint;
+}
+/**
+ * Estimated transaction cost breakdown
+ */
+interface EstimatedCost {
+  /** Cost from gas consumption */
+  gasCost: bigint;
+  /** Storage deposit (may be refunded) */
+  storageDeposit: bigint;
+  /** Total estimated cost (gas + storage) */
+  total: bigint;
+}
+/**
+ * Formatted gas information for display
+ */
+interface FormattedGasInfo {
+  /** Human-readable ref_time */
+  refTime: string;
+  /** Human-readable proof_size */
+  proofSize: string;
+}
+/**
+ * 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`);
+ * }
+ * ```
+ */
+declare function estimateTransactionCost(gasInfo: GasInfo, storageDeposit: bigint): EstimatedCost;
+/**
+ * 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}`);
+ * ```
+ */
+declare function formatGasInfo(gasInfo: GasInfo["gasRequired"]): FormattedGasInfo;
+/**
+ * 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,
+ *   });
+ * }
+ * ```
+ */
+declare function applyGasMargin(gas: GasWeight, multiplier?: number): GasWeight;
+/**
+ * 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)
+ */
+declare function compareGasWeight(a: GasWeight, b: GasWeight): -1 | 0 | 1;
+/**
+ * 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
+ */
+declare function gasExceedsLimit(gas: GasWeight, limit: GasWeight): boolean;
+//#endregion
+export { AbortedError, type BlockHeader, type CallFilterOptions, ContractCallParser, type ContractCallResult, ContractError, type ContractErrorType, ContractEventParser, ContractExecutionError, type ContractMessageBuilder, type ContractStorage, type CreateContractOptions, type CreateD9InkSdkOptions, type D9InkContract, type D9InkContractFromDescriptor, type D9InkSdk, type D9InkSdkOptions, type D9InkSdkWithRpc, DecodeError, type DecodedContractEvent, EncodeError, EstimatedCost, type EventFilterOptions, type EventSubscriptionOptions, type ExtractEnumDef, type ExtractEventLabels, type ExtractMessageLabels, FormattedGasInfo, type GasInfo, GasWeight, type InferEvents, type InferMessages, InkCodecs, type KnownRpcMethod, LangError, type MessageAttributes, type MessageInfo, MetadataError, NetworkError, type QueryOptions, type QueryResult, type QuerySuccessValue, type RawContractCall, type RawContractEvent, type ResponseDecoder, type RpcParams, type RpcReturn, type RuntimeVersion, type SendOptions, type SendableTransaction, SignerError, type StorageChangeSet, type StorageDepositInfo, type SubstrateRpcMethods, type SystemHealth, TimeoutError, TransactionError, type TxResult, type TypedCallFilterOptions, type TypedContractCall, type TypedContractEvent, type TypedEventFilterOptions, type TypedMessage, type TypedRpcRequest, applyGasMargin, buildAllEventDecoders, buildAllMessageDecoders, buildEventDecoder, buildMessageDecoder, compareGasWeight, createAsciiEventTopic, createCodecRegistry, createContractEventStream, createD9InkContract, createD9InkSdk, createMessageBuilder, createNativeTransferStream, createPSP22TransferStream, createTypedRpc, decodeContractCallResult, decodeInkValue, decodeResult, encodeCall, encodeContractCall, encodeContractCallWithLimits, estimateTransactionCost, formatGasInfo, gasExceedsLimit, getEventSignature, isCallType, isContractError, isErrorType, isEventType, isLangError, unwrapInkResult };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -466,6 +466,27 @@ function buildAllEventDecoders(metadata) {
 function getEventSignature(eventLabel) {
 	return 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);
@@ -531,7 +556,7 @@ var ContractEventParser = class {
 			return null;
 		}
 		try {
-			const decodedData = decoder(data);
+			const decodedData = decoder(data.slice(1));
 			return {
 				type: eventLabel,
 				value: decodedData,
@@ -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
@@ -1811,5 +1843,126 @@ function isCallType(call, label) {
 }
 
 //#endregion
-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 };
+//#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
+export { AbortedError, ContractCallParser, ContractError, ContractEventParser, ContractExecutionError, DecodeError, EncodeError, InkCodecs, LangError, MetadataError, NetworkError, SignerError, TimeoutError, TransactionError, applyGasMargin, buildAllEventDecoders, buildAllMessageDecoders, buildEventDecoder, buildMessageDecoder, compareGasWeight, createAsciiEventTopic, createCodecRegistry, createContractEventStream, createD9InkContract, createD9InkSdk, createMessageBuilder, createNativeTransferStream, createPSP22TransferStream, createTypedRpc, decodeContractCallResult, decodeInkValue, decodeResult, encodeCall, encodeContractCall, encodeContractCallWithLimits, estimateTransactionCost, formatGasInfo, gasExceedsLimit, getEventSignature, isCallType, isContractError, isErrorType, isEventType, isLangError, unwrapInkResult };
 //# sourceMappingURL=index.mjs.map