@d9-network/ink 1.0.2 → 1.1.0

package/dist/index.d.cts

@@ -127,6 +127,180 @@ interface EventSubscriptionOptions {
    */
   getEvents: (blockHash: string) => Promise<unknown[]>;
 }
+/**
+ * Chain event record structure (matches polkadot-api format)
+ *
+ * Use this type when processing raw chain events to avoid `as any` casts.
+ *
+ * @example
+ * ```ts
+ * // Instead of: const events = await api.query.System.Events.getValue() as any[];
+ * // Use: const events: ChainEventRecord[] = await api.query.System.Events.getValue();
+ *
+ * for (const event of events) {
+ *   if (isContractEmittedEvent(event)) {
+ *     // event is now properly typed!
+ *   }
+ * }
+ * ```
+ */
+interface ChainEventRecord {
+  /** The event phase */
+  phase?: {
+    type: string;
+    value?: number;
+  };
+  /** The event pallet and variant */
+  event: {
+    type: string;
+    value: {
+      type: string;
+      value: unknown;
+    };
+  };
+  /** Event topics (for indexed fields) */
+  topics?: Array<Uint8Array | {
+    asBytes?: () => Uint8Array;
+  }>;
+  /** Block number (if available) */
+  blockNumber?: number;
+  /** Block hash (if available) */
+  blockHash?: string;
+  /** Event index in block (if available) */
+  eventIndex?: number;
+}
+/**
+ * Contracts.ContractEmitted event value
+ */
+interface ContractEmittedValue {
+  /** Contract address (SS58 or Uint8Array) */
+  contract: SS58String | Uint8Array;
+  /** Event data (Binary or Uint8Array) */
+  data: Uint8Array | {
+    asBytes: () => Uint8Array;
+  };
+}
+/**
+ * Contracts.Called event value
+ */
+interface ContractCalledValue {
+  /** Caller address */
+  caller: SS58String;
+  /** Contract address being called */
+  contract: SS58String;
+}
+/**
+ * Typed chain event for Contracts.ContractEmitted
+ */
+interface ContractEmittedChainEvent extends ChainEventRecord {
+  event: {
+    type: "Contracts";
+    value: {
+      type: "ContractEmitted";
+      value: ContractEmittedValue;
+    };
+  };
+}
+/**
+ * Typed chain event for Contracts.Called
+ */
+interface ContractCalledChainEvent extends ChainEventRecord {
+  event: {
+    type: "Contracts";
+    value: {
+      type: "Called";
+      value: ContractCalledValue;
+    };
+  };
+}
+/**
+ * Typed chain event for Balances.Transfer
+ */
+interface BalancesTransferChainEvent extends ChainEventRecord {
+  event: {
+    type: "Balances";
+    value: {
+      type: "Transfer";
+      value: {
+        from: SS58String;
+        to: SS58String;
+        amount: bigint;
+      };
+    };
+  };
+}
+/**
+ * Type guard for Contracts.ContractEmitted events
+ *
+ * @example
+ * ```ts
+ * for (const event of events) {
+ *   if (isContractEmittedEvent(event)) {
+ *     // event.event.value.value is ContractEmittedValue
+ *     const { contract, data } = event.event.value.value;
+ *   }
+ * }
+ * ```
+ */
+declare function isContractEmittedEvent(event: ChainEventRecord): event is ContractEmittedChainEvent;
+/**
+ * Type guard for Contracts.Called events
+ *
+ * @example
+ * ```ts
+ * for (const event of events) {
+ *   if (isContractCalledEvent(event)) {
+ *     // event.event.value.value is ContractCalledValue
+ *     const { caller, contract } = event.event.value.value;
+ *   }
+ * }
+ * ```
+ */
+declare function isContractCalledEvent(event: ChainEventRecord): event is ContractCalledChainEvent;
+/**
+ * Type guard for Balances.Transfer events
+ *
+ * @example
+ * ```ts
+ * for (const event of events) {
+ *   if (isBalancesTransferEvent(event)) {
+ *     const { from, to, amount } = event.event.value.value;
+ *   }
+ * }
+ * ```
+ */
+declare function isBalancesTransferEvent(event: ChainEventRecord): event is BalancesTransferChainEvent;
+/**
+ * Check if event is in ApplyExtrinsic phase
+ *
+ * @example
+ * ```ts
+ * for (const event of events) {
+ *   if (isApplyExtrinsicPhase(event)) {
+ *     const extrinsicIndex = event.phase.value;
+ *   }
+ * }
+ * ```
+ */
+declare function isApplyExtrinsicPhase(event: ChainEventRecord): event is ChainEventRecord & {
+  phase: {
+    type: "ApplyExtrinsic";
+    value: number;
+  };
+};
+/**
+ * Extract contract emitted data with proper typing
+ *
+ * Handles both Uint8Array and Binary object formats.
+ *
+ * @param event - Chain event record
+ * @returns Extracted data or null if not a ContractEmitted event
+ */
+declare function extractContractEmittedData(event: ChainEventRecord): {
+  contract: Uint8Array;
+  data: Uint8Array;
+  topics: Uint8Array[];
+} | null;
 //#endregion
 //#region src/call-types.d.ts
 /**
@@ -1088,10 +1262,40 @@ declare class ContractEventParser<S extends InkStorageDescriptor = InkStorageDes
   filterByType<L extends string>(chainEvents: unknown[], label: L): Array<TypedContractEvent<E> & {
     type: L;
   }>;
+  /**
+   * Parse chain event records with proper typing
+   *
+   * Unlike parseEvent/filterEvents which accept `unknown[]`, this method
+   * accepts typed `ChainEventRecord[]` which eliminates the need for
+   * `as any` casts in user code.
+   *
+   * @param events - Array of typed chain event records
+   * @param options - Optional filter criteria
+   * @returns Array of typed contract events
+   *
+   * @example
+   * ```ts
+   * // No more `as any` needed!
+   * const events: ChainEventRecord[] = await api.query.System.Events.getValue();
+   * const contractEvents = parser.parseChainEvents(events);
+   *
+   * for (const event of contractEvents) {
+   *   if (event.type === "Transfer") {
+   *     // Fully typed!
+   *     console.log(event.value.from, event.value.to, event.value.value);
+   *   }
+   * }
+   * ```
+   */
+  parseChainEvents(events: ChainEventRecord[], options?: EventFilterOptions): TypedContractEvent<E>[];
   /**
    * Get the contract address as SS58 string
    */
   private getContractAddress;
+  /**
+   * Get the contract address as bytes
+   */
+  getContractAddressBytes(): Uint8Array;
   /**
    * Extract ContractEmitted event from chain event structure
    * Based on polkadot-api event format
@@ -1262,6 +1466,80 @@ declare class ContractCallParser<S extends InkStorageDescriptor = InkStorageDesc
    * Check if a selector matches a specific message
    */
   matchesMessage(selector: Uint8Array, label: string): boolean;
+  /**
+   * Get selector for a message label
+   *
+   * @param label - Message label (e.g., "PSP22::transfer")
+   * @returns Selector as Uint8Array or null if not found
+   *
+   * @example
+   * ```ts
+   * const selector = parser.getSelector("PSP22::transfer");
+   * // selector is Uint8Array([0xdb, 0x20, 0xf9, 0xf5])
+   * ```
+   */
+  getSelector(label: string): Uint8Array | null;
+  /**
+   * Get selector as hex string for a message label
+   *
+   * @param label - Message label (e.g., "PSP22::transfer")
+   * @returns Selector hex string (without 0x) or null if not found
+   *
+   * @example
+   * ```ts
+   * const selectorHex = parser.getSelectorHex("PSP22::transfer");
+   * // selectorHex is "db20f9f5"
+   * ```
+   */
+  getSelectorHex(label: string): string | null;
+  /**
+   * Get the label for a selector
+   *
+   * @param selector - Selector as Uint8Array or hex string (with or without 0x)
+   * @returns Message label or null if not found
+   *
+   * @example
+   * ```ts
+   * const label = parser.getLabel("db20f9f5");
+   * // label is "PSP22::transfer"
+   *
+   * // Also works with Uint8Array
+   * const label2 = parser.getLabel(callData.slice(0, 4));
+   * ```
+   */
+  getLabel(selector: Uint8Array | string): string | null;
+  /**
+   * Get all selector-to-label mappings
+   *
+   * @returns Map of selector hex (without 0x) -> label
+   *
+   * @example
+   * ```ts
+   * const map = parser.getSelectorMap();
+   * for (const [selectorHex, label] of map) {
+   *   console.log(`${selectorHex} -> ${label}`);
+   * }
+   * ```
+   */
+  getSelectorMap(): Map<string, string>;
+  /**
+   * Check if a selector exists in this contract
+   *
+   * @param selector - Selector to check (Uint8Array or hex string)
+   * @returns True if selector is valid for this contract
+   *
+   * @example
+   * ```ts
+   * if (parser.hasSelector("db20f9f5")) {
+   *   // This selector is valid for this contract
+   * }
+   * ```
+   */
+  hasSelector(selector: Uint8Array | string): boolean;
+  /**
+   * Normalize selector to hex string (without 0x prefix)
+   */
+  private normalizeSelector;
 }
 /**
  * Type guard for narrowing call types
@@ -1291,6 +1569,432 @@ declare function isCallType<M$1 extends InkCallableDescriptor, L extends Extract
   type: L;
 }>;
 //#endregion
+//#region src/infer-types.d.ts
+/**
+ * Infer ContractCallParser type from a contract descriptor
+ *
+ * Use this when you need to declare a property type without instantiation.
+ *
+ * @typeParam D - The contract descriptor type (e.g., typeof contracts.usdt)
+ *
+ * @example
+ * ```ts
+ * import { contracts } from "@d9-network/spec";
+ * import type { ContractCallParserOf } from "@d9-network/ink";
+ *
+ * class USDTIndexer {
+ *   private callParser: ContractCallParserOf<typeof contracts.usdt>;
+ *
+ *   constructor() {
+ *     this.callParser = new ContractCallParser(contracts.usdt);
+ *   }
+ * }
+ * ```
+ */
+type ContractCallParserOf<D> = D extends InkDescriptors<infer S, infer M, infer C, infer E> ? ContractCallParser<S extends InkStorageDescriptor ? S : InkStorageDescriptor, M extends InkCallableDescriptor ? M : InkCallableDescriptor, C extends InkCallableDescriptor ? C : InkCallableDescriptor, E extends Event ? E : Event> : never;
+/**
+ * Infer ContractEventParser type from a contract descriptor
+ *
+ * Use this when you need to declare a property type without instantiation.
+ *
+ * @typeParam D - The contract descriptor type (e.g., typeof contracts.usdt)
+ *
+ * @example
+ * ```ts
+ * import { contracts } from "@d9-network/spec";
+ * import type { ContractEventParserOf } from "@d9-network/ink";
+ *
+ * class USDTIndexer {
+ *   private eventParser: ContractEventParserOf<typeof contracts.usdt>;
+ *
+ *   constructor(contractAddress: SS58String) {
+ *     this.eventParser = new ContractEventParser(contracts.usdt, contractAddress);
+ *   }
+ * }
+ * ```
+ */
+type ContractEventParserOf<D> = D extends InkDescriptors<infer S, infer M, infer C, infer E> ? ContractEventParser<S extends InkStorageDescriptor ? S : InkStorageDescriptor, M extends InkCallableDescriptor ? M : InkCallableDescriptor, C extends InkCallableDescriptor ? C : InkCallableDescriptor, E extends Event ? E : Event> : never;
+/**
+ * Infer D9InkContract type from a contract descriptor
+ *
+ * Use this when you need to declare a property type without instantiation.
+ *
+ * @typeParam D - The contract descriptor type (e.g., typeof contracts.usdt)
+ *
+ * @example
+ * ```ts
+ * import { contracts } from "@d9-network/spec";
+ * import type { D9InkContractOf } from "@d9-network/ink";
+ *
+ * class WalletService {
+ *   private usdtContract: D9InkContractOf<typeof contracts.usdt>;
+ *
+ *   constructor(sdk: D9InkSdk, contractAddress: SS58String) {
+ *     this.usdtContract = sdk.getContract(contracts.usdt, contractAddress);
+ *   }
+ * }
+ * ```
+ */
+type D9InkContractOf<D> = D extends InkDescriptors<infer _S, infer M, infer _C, infer E> ? D9InkContract<M extends InkCallableDescriptor ? M : InkCallableDescriptor, E extends Event ? E : Event> : never;
+//#endregion
+//#region src/selectors.d.ts
+/**
+ * Information about a contract message selector
+ */
+interface SelectorInfo {
+  /** Message label (e.g., "PSP22::transfer") */
+  label: string;
+  /** 4-byte selector */
+  selector: Uint8Array;
+  /** Hex string without 0x prefix (e.g., "db20f9f5") */
+  selectorHex: string;
+  /** Whether the message mutates state */
+  mutates: boolean;
+  /** Whether the message is payable */
+  payable: boolean;
+}
+/**
+ * PSP22 standard selectors for quick reference
+ *
+ * These are derived from the PSP22 standard and are consistent across implementations.
+ * Use these when you need to quickly check if call data matches a specific PSP22 method.
+ *
+ * @example
+ * ```ts
+ * import { PSP22_SELECTORS, extractSelectorHex } from "@d9-network/ink";
+ *
+ * const selectorHex = extractSelectorHex(callData);
+ * if (selectorHex === PSP22_SELECTORS.transfer) {
+ *   // This is a PSP22::transfer call
+ * }
+ * ```
+ */
+declare const PSP22_SELECTORS: {
+  /** PSP22::total_supply - 0x162df8c2 */
+  readonly totalSupply: "162df8c2";
+  /** PSP22::balance_of - 0x6568382f */
+  readonly balanceOf: "6568382f";
+  /** PSP22::allowance - 0x4d47d921 */
+  readonly allowance: "4d47d921";
+  /** PSP22::transfer - 0xdb20f9f5 */
+  readonly transfer: "db20f9f5";
+  /** PSP22::transfer_from - 0x54b3c76e */
+  readonly transferFrom: "54b3c76e";
+  /** PSP22::approve - 0xb20f1bbd */
+  readonly approve: "b20f1bbd";
+  /** PSP22::increase_allowance - 0x96d6b57a */
+  readonly increaseAllowance: "96d6b57a";
+  /** PSP22::decrease_allowance - 0xfecb57d5 */
+  readonly decreaseAllowance: "fecb57d5";
+};
+/**
+ * PSP22 selector type for type safety
+ */
+type PSP22SelectorKey = keyof typeof PSP22_SELECTORS;
+/**
+ * Build a selector lookup map from contract metadata
+ *
+ * @param metadata - Contract metadata
+ * @returns Map of selector hex (without 0x) -> SelectorInfo
+ *
+ * @example
+ * ```ts
+ * import { contracts } from "@d9-network/spec";
+ * import { buildSelectorMap } from "@d9-network/ink";
+ *
+ * const selectors = buildSelectorMap(contracts.usdt.metadata);
+ * const info = selectors.get("db20f9f5");
+ * if (info) {
+ *   console.log(info.label); // "PSP22::transfer"
+ * }
+ * ```
+ */
+declare function buildSelectorMap(metadata: InkMetadata): Map<string, SelectorInfo>;
+/**
+ * Build a reverse lookup map (label -> selector info)
+ *
+ * @param metadata - Contract metadata
+ * @returns Map of label -> SelectorInfo
+ *
+ * @example
+ * ```ts
+ * const labelMap = buildLabelMap(contracts.usdt.metadata);
+ * const info = labelMap.get("PSP22::transfer");
+ * console.log(info?.selectorHex); // "db20f9f5"
+ * ```
+ */
+declare function buildLabelMap(metadata: InkMetadata): Map<string, SelectorInfo>;
+/**
+ * Get selector for a message label
+ *
+ * @param metadata - Contract metadata
+ * @param label - Message label (e.g., "PSP22::transfer")
+ * @returns Selector info or null if not found
+ *
+ * @example
+ * ```ts
+ * const info = getSelectorForLabel(contracts.usdt.metadata, "PSP22::transfer");
+ * console.log(info?.selectorHex); // "db20f9f5"
+ * ```
+ */
+declare function getSelectorForLabel(metadata: InkMetadata, label: string): SelectorInfo | null;
+/**
+ * Get message label for a selector
+ *
+ * @param metadata - Contract metadata
+ * @param selector - Selector as Uint8Array or hex string (with or without 0x)
+ * @returns Selector info or null if not found
+ *
+ * @example
+ * ```ts
+ * const info = getLabelForSelector(contracts.usdt.metadata, "db20f9f5");
+ * console.log(info?.label); // "PSP22::transfer"
+ *
+ * // Also works with Uint8Array
+ * const info2 = getLabelForSelector(contracts.usdt.metadata, callData.slice(0, 4));
+ * ```
+ */
+declare function getLabelForSelector(metadata: InkMetadata, selector: Uint8Array | string): SelectorInfo | null;
+/**
+ * Check if call data matches a specific message
+ *
+ * @param metadata - Contract metadata
+ * @param callData - Call data bytes or hex string
+ * @param label - Message label to check
+ * @returns True if the call data selector matches the label
+ *
+ * @example
+ * ```ts
+ * if (isMessageCall(contracts.usdt.metadata, callData, "PSP22::transfer")) {
+ *   // This is a transfer call
+ * }
+ * ```
+ */
+declare function isMessageCall(metadata: InkMetadata, callData: Uint8Array | string, label: string): boolean;
+/**
+ * Check if call data matches a PSP22 method
+ *
+ * @param callData - Call data bytes or hex string
+ * @param method - PSP22 method name (e.g., "transfer", "transferFrom")
+ * @returns True if the call data selector matches the PSP22 method
+ *
+ * @example
+ * ```ts
+ * if (isPSP22Call(callData, "transfer")) {
+ *   // This is a PSP22::transfer call
+ * }
+ * ```
+ */
+declare function isPSP22Call(callData: Uint8Array | string, method: PSP22SelectorKey): boolean;
+/**
+ * Get all selectors from contract metadata
+ *
+ * @param metadata - Contract metadata
+ * @returns Array of SelectorInfo for all messages
+ */
+declare function getAllSelectors(metadata: InkMetadata): SelectorInfo[];
+//#endregion
+//#region src/extrinsic-parser.d.ts
+/**
+ * Raw extrinsic data that may contain a contract call
+ *
+ * This interface is designed to work with various extrinsic formats
+ * from different data sources (polkadot-api, subsquid, etc.)
+ */
+interface RawExtrinsic {
+  /** Extrinsic hash */
+  hash?: string;
+  /** Block number */
+  blockNumber?: number;
+  /** Block hash */
+  blockHash?: string;
+  /** Extrinsic index in block */
+  index?: number;
+  /** Signer address */
+  signer?: SS58String | string;
+  /** The call structure - can be nested */
+  call?: ExtrinsicCall;
+}
+/**
+ * Extrinsic call structure (matches polkadot-api format)
+ */
+interface ExtrinsicCall {
+  type?: string;
+  value?: {
+    type?: string;
+    value?: ContractsCallValue;
+  };
+}
+/**
+ * Contracts.call extrinsic value
+ */
+interface ContractsCallValue {
+  /** Contract address (SS58 or other format) */
+  dest?: SS58String | {
+    type: string;
+    value: SS58String;
+  } | {
+    Id: SS58String;
+  };
+  /** Value transferred with the call */
+  value?: bigint | string | number;
+  /** Call data (Binary or Uint8Array) */
+  data?: Uint8Array | {
+    asBytes?: () => Uint8Array;
+  };
+  /** Gas limit */
+  gas_limit?: unknown;
+  gasLimit?: unknown;
+  /** Storage deposit limit */
+  storage_deposit_limit?: unknown;
+  storageDepositLimit?: unknown;
+}
+/**
+ * Parsed contract extrinsic result
+ */
+interface ParsedContractExtrinsic<M$1 extends InkCallableDescriptor = InkCallableDescriptor> {
+  /** The parsed contract call */
+  call: TypedContractCall<M$1>;
+  /** Extrinsic metadata */
+  extrinsic: {
+    /** Extrinsic hash */
+    hash: string;
+    /** Block number */
+    blockNumber: number;
+    /** Block hash */
+    blockHash: string;
+    /** Extrinsic index in block */
+    index: number;
+    /** Signer address */
+    signer: string;
+  };
+  /** Contract address being called */
+  contractAddress: SS58String;
+  /** Value transferred with call */
+  value: bigint;
+}
+/**
+ * Extrinsic parser options
+ */
+interface ExtrinsicParserOptions {
+  /** Contract addresses to filter for (if not provided, parses all contract calls) */
+  contractAddresses?: SS58String[];
+  /** Message labels to filter for */
+  messageLabels?: string[];
+}
+/**
+ * Parser for extracting contract calls from extrinsics
+ *
+ * This class provides a high-level API for indexers to parse contract
+ * interactions from blockchain extrinsics without manual hex manipulation.
+ *
+ * @typeParam S - The storage descriptor type
+ * @typeParam M - The InkCallableDescriptor type (message definitions)
+ * @typeParam C - The constructors descriptor type
+ * @typeParam E - The events type
+ *
+ * @example
+ * ```ts
+ * import { ExtrinsicParser } from "@d9-network/ink";
+ * import { contracts } from "@d9-network/spec";
+ *
+ * // Create parser for USDT contract
+ * const parser = new ExtrinsicParser(contracts.usdt, {
+ *   contractAddresses: [USDT_ADDRESS],
+ * });
+ *
+ * // Parse extrinsics from a block
+ * for (const extrinsic of block.extrinsics) {
+ *   const parsed = parser.parseExtrinsic(extrinsic);
+ *   if (parsed?.call.type === "PSP22::transfer") {
+ *     console.log(`Transfer: ${parsed.call.args.value} to ${parsed.call.args.to}`);
+ *   }
+ * }
+ * ```
+ */
+declare class ExtrinsicParser<S extends InkStorageDescriptor = InkStorageDescriptor, M$1 extends InkCallableDescriptor = InkCallableDescriptor, C extends InkCallableDescriptor = InkCallableDescriptor, E extends Event = Event> {
+  private callParser;
+  private options;
+  constructor(descriptor: InkDescriptors<S, M$1, C, E>, options?: ExtrinsicParserOptions);
+  /**
+   * Parse a single extrinsic for contract calls
+   *
+   * @param extrinsic - Raw extrinsic data
+   * @returns Parsed contract extrinsic or null if not a valid contract call
+   */
+  parseExtrinsic(extrinsic: RawExtrinsic): ParsedContractExtrinsic<M$1> | null;
+  /**
+   * Parse multiple extrinsics and filter contract calls
+   *
+   * @param extrinsics - Array of raw extrinsics
+   * @returns Array of parsed contract extrinsics
+   */
+  parseExtrinsics(extrinsics: RawExtrinsic[]): ParsedContractExtrinsic<M$1>[];
+  /**
+   * Filter extrinsics by message type with type narrowing
+   *
+   * @param extrinsics - Array of raw extrinsics
+   * @param label - Message label to filter by
+   * @returns Filtered and typed extrinsics
+   *
+   * @example
+   * ```ts
+   * const transfers = parser.filterByMessageType(extrinsics, "PSP22::transfer");
+   * for (const tx of transfers) {
+   *   // tx.call.args is fully typed
+   *   console.log(tx.call.args.to, tx.call.args.value);
+   * }
+   * ```
+   */
+  filterByMessageType<L extends string>(extrinsics: RawExtrinsic[], label: L): Array<ParsedContractExtrinsic<M$1> & {
+    call: {
+      type: L;
+    };
+  }>;
+  /**
+   * Check if an extrinsic is a contract call
+   *
+   * @param extrinsic - Raw extrinsic
+   * @returns True if this is a Contracts.call extrinsic
+   */
+  isContractCall(extrinsic: RawExtrinsic): boolean;
+  /**
+   * Extract call data from an extrinsic structure
+   *
+   * Handles various extrinsic formats (polkadot-api, subsquid, etc.)
+   *
+   * @param extrinsic - Raw extrinsic
+   * @returns Extracted call data or null
+   */
+  extractCallData(extrinsic: RawExtrinsic): {
+    data: Uint8Array;
+    contractAddress: SS58String;
+    value: bigint;
+  } | null;
+  /**
+   * Get access to the underlying call parser
+   */
+  getCallParser(): ContractCallParser<S, M$1, C, E>;
+  private extractContractAddress;
+  private extractBytes;
+  private extractBigInt;
+}
+/**
+ * Create an extrinsic parser from a contract descriptor
+ *
+ * @param descriptor - Contract descriptor
+ * @param options - Parser options
+ * @returns ExtrinsicParser instance
+ *
+ * @example
+ * ```ts
+ * const parser = createExtrinsicParser(contracts.usdt, {
+ *   contractAddresses: [USDT_ADDRESS],
+ * });
+ * ```
+ */
+declare function createExtrinsicParser<S extends InkStorageDescriptor, M$1 extends InkCallableDescriptor, C extends InkCallableDescriptor, E extends Event>(descriptor: InkDescriptors<S, M$1, C, E>, options?: ExtrinsicParserOptions): ExtrinsicParser<S, M$1, C, E>;
+//#endregion
 //#region src/rpc.d.ts
 /**
  * Create a type-safe RPC proxy from a PolkadotClient
@@ -1424,5 +2128,5 @@ declare function compareGasWeight(a: GasWeight, b: GasWeight): -1 | 0 | 1;
  */
 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, LangError, type MessageAttributes, type MessageInfo, MetadataError, NetworkError, type QueryOptions, type QueryResult, type QuerySuccessValue, type RawContractCall, type RawContractEvent, type ResponseDecoder, 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 TypedRpc, applyGasMargin, buildAllEventDecoders, buildAllMessageDecoders, buildEventDecoder, buildMessageDecoder, compareGasWeight, createAsciiEventTopic, createCodecRegistry, createContractEventStream, createD9InkContract, createD9InkSdk, createMessageBuilder, createNativeTransferStream, createPSP22TransferStream, createTypedRpc, decodeContractCallResult, decodeInkValue, encodeCall, encodeContractCall, encodeContractCallWithLimits, estimateTransactionCost, formatGasInfo, gasExceedsLimit, getEventSignature, isCallType, isContractError, isErrorType, isEventType, isLangError, unwrapInkResult };
+export { AbortedError, type BalancesTransferChainEvent, type BlockHeader, type CallFilterOptions, type ChainEventRecord, ContractCallParser, type ContractCallParserOf, type ContractCallResult, type ContractCalledChainEvent, type ContractCalledValue, type ContractEmittedChainEvent, type ContractEmittedValue, ContractError, type ContractErrorType, ContractEventParser, type ContractEventParserOf, ContractExecutionError, type ContractMessageBuilder, type ContractStorage, type ContractsCallValue, type CreateContractOptions, type CreateD9InkSdkOptions, type D9InkContract, type D9InkContractFromDescriptor, type D9InkContractOf, type D9InkSdk, type D9InkSdkOptions, type D9InkSdkWithRpc, DecodeError, type DecodedContractEvent, EncodeError, EstimatedCost, type EventFilterOptions, type EventSubscriptionOptions, type ExtractEnumDef, type ExtractEventLabels, type ExtractMessageLabels, type ExtrinsicCall, ExtrinsicParser, type ExtrinsicParserOptions, FormattedGasInfo, type GasInfo, GasWeight, type InferEvents, type InferMessages, InkCodecs, LangError, type MessageAttributes, type MessageInfo, MetadataError, NetworkError, type PSP22SelectorKey, PSP22_SELECTORS, type ParsedContractExtrinsic, type QueryOptions, type QueryResult, type QuerySuccessValue, type RawContractCall, type RawContractEvent, type RawExtrinsic, type ResponseDecoder, type RuntimeVersion, type SelectorInfo, 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 TypedRpc, applyGasMargin, buildAllEventDecoders, buildAllMessageDecoders, buildEventDecoder, buildLabelMap, buildMessageDecoder, buildSelectorMap, compareGasWeight, createAsciiEventTopic, createCodecRegistry, createContractEventStream, createD9InkContract, createD9InkSdk, createExtrinsicParser, createMessageBuilder, createNativeTransferStream, createPSP22TransferStream, createTypedRpc, decodeContractCallResult, decodeInkValue, encodeCall, encodeContractCall, encodeContractCallWithLimits, estimateTransactionCost, extractContractEmittedData, formatGasInfo, gasExceedsLimit, getAllSelectors, getEventSignature, getLabelForSelector, getSelectorForLabel, isApplyExtrinsicPhase, isBalancesTransferEvent, isCallType, isContractCalledEvent, isContractEmittedEvent, isContractError, isErrorType, isEventType, isLangError, isMessageCall, isPSP22Call, unwrapInkResult };
 //# sourceMappingURL=index.d.cts.map