@d9-network/ink 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,750 @@
+import { Binary, PolkadotClient, PolkadotSigner, SS58String } from "polkadot-api";
+import { Event, InkCallableDescriptor, InkDescriptors, InkMetadata, InkStorageDescriptor } from "@polkadot-api/ink-contracts";
+import { Bytes } from "@subsquid/scale-codec";
+import * as _polkadot_api_substrate_bindings0 from "@polkadot-api/substrate-bindings";
+import { Codec } from "@polkadot-api/substrate-bindings";
+import { Observable } from "rxjs";
+
+//#region src/errors.d.ts
+/**
+ * Structured error types for contract operations.
+ * Provides detailed error information for debugging and handling.
+ */
+/**
+ * Error types for contract operations
+ */
+type ContractErrorType = "METADATA_ERROR" | "ENCODE_ERROR" | "DECODE_ERROR" | "NETWORK_ERROR" | "CONTRACT_ERROR" | "LANG_ERROR" | "TIMEOUT_ERROR" | "ABORTED" | "SIGNER_ERROR" | "TX_ERROR";
+/**
+ * Base error class for all contract-related errors
+ */
+declare class ContractError extends Error {
+  readonly type: ContractErrorType;
+  readonly label?: string | undefined;
+  readonly details?: unknown | undefined;
+  readonly timestamp: Date;
+  readonly cause?: Error;
+  constructor(message: string, type: ContractErrorType, label?: string | undefined, details?: unknown | undefined, cause?: Error);
+  /**
+   * Create a formatted error message for logging
+   */
+  toLogString(): string;
+  /**
+   * Convert to a plain object for serialization
+   */
+  toJSON(): Record<string, unknown>;
+}
+/**
+ * Error thrown when contract metadata is missing or invalid
+ */
+declare class MetadataError extends ContractError {
+  constructor(message: string, details?: unknown);
+}
+/**
+ * Error thrown when encoding call data fails
+ */
+declare class EncodeError extends ContractError {
+  constructor(label: string, message: string, details?: unknown);
+}
+/**
+ * Error thrown when decoding response fails
+ */
+declare class DecodeError extends ContractError {
+  constructor(label: string, message: string, details?: unknown);
+}
+/**
+ * Error thrown for network/RPC errors
+ */
+declare class NetworkError extends ContractError {
+  constructor(message: string, cause?: Error, details?: unknown);
+}
+/**
+ * Error thrown when contract returns an error result
+ */
+declare class ContractExecutionError extends ContractError {
+  readonly errorValue: unknown;
+  constructor(label: string, errorValue: unknown);
+}
+/**
+ * Error thrown for Ink LangError
+ */
+declare class LangError extends ContractError {
+  readonly variant: number;
+  constructor(label: string, variant: number);
+}
+/**
+ * Error thrown when request times out
+ */
+declare class TimeoutError extends ContractError {
+  readonly timeoutMs: number;
+  constructor(label: string, timeoutMs: number);
+}
+/**
+ * Error thrown when request is aborted
+ */
+declare class AbortedError extends ContractError {
+  constructor(label: string, reason?: string);
+}
+/**
+ * Error thrown for signer-related issues
+ */
+declare class SignerError extends ContractError {
+  constructor(message: string, details?: unknown);
+}
+/**
+ * Error thrown when transaction submission fails
+ */
+declare class TransactionError extends ContractError {
+  readonly txHash?: string | undefined;
+  constructor(label: string, message: string, txHash?: string | undefined, details?: unknown);
+}
+/**
+ * Type guard to check if an error is a ContractError
+ */
+declare function isContractError(error: unknown): error is ContractError;
+/**
+ * Type guard to check for specific error types
+ */
+declare function isErrorType<T extends ContractErrorType>(error: unknown, type: T): error is ContractError & {
+  type: T;
+};
+//#endregion
+//#region src/event-types.d.ts
+/**
+ * Raw event data from chain
+ */
+interface RawContractEvent {
+  /** Block number where event was emitted */
+  blockNumber: number;
+  /** Block hash */
+  blockHash: string;
+  /** Event index in block */
+  eventIndex: number;
+  /** Contract address that emitted the event */
+  contractAddress: SS58String;
+  /** Event data (SCALE encoded) */
+  data: Uint8Array;
+  /** Event topics (indexed fields) */
+  topics: Uint8Array[];
+}
+/**
+ * Decoded contract event
+ */
+interface DecodedContractEvent<T = unknown> {
+  /** Event label from metadata (e.g., "Transfer", "Approval") */
+  label: string;
+  /** Decoded event data */
+  data: T;
+  /** Original raw event */
+  raw: RawContractEvent;
+}
+/**
+ * Event filter options
+ */
+interface EventFilterOptions {
+  /** Contract address to filter by */
+  contractAddress?: SS58String;
+  /** Event labels to include (e.g., ["Transfer", "Approval"]) */
+  eventLabels?: string[];
+  /** From block number (inclusive) */
+  fromBlock?: number;
+  /** To block number (inclusive) */
+  toBlock?: number;
+}
+/**
+ * Event subscription options
+ */
+interface EventSubscriptionOptions {
+  /** Contract address to subscribe to */
+  contractAddress: SS58String;
+  /** Event labels to subscribe to (undefined = all events) */
+  eventLabels?: string[];
+  /** Include historical events from this block */
+  fromBlock?: number;
+  /**
+   * Function to fetch System.Events at a given block hash
+   * This is required because PolkadotClient doesn't expose typed API directly
+   *
+   * @example
+   * ```ts
+   * const options = {
+   *   contractAddress: usdtAddress,
+   *   getEvents: async (blockHash) => {
+   *     return await api.query.System.Events.getValue({ at: blockHash });
+   *   }
+   * };
+   * ```
+   */
+  getEvents: (blockHash: string) => Promise<unknown[]>;
+}
+//#endregion
+//#region src/types.d.ts
+/**
+ * Decoder type for response decoding
+ */
+type ResponseDecoder = {
+  dec: (data: Uint8Array) => unknown;
+};
+/**
+ * Query options for read operations (dry-run)
+ */
+interface QueryOptions<Args = unknown> {
+  /** The origin account for the call */
+  origin: SS58String;
+  /** Arguments to pass to the contract message */
+  args?: Args;
+  /** Value to transfer with the call */
+  value?: bigint;
+  /** AbortSignal for cancellation */
+  signal?: AbortSignal;
+  /** Timeout in milliseconds */
+  timeout?: number;
+  /** Block hash to query at (default: finalized) */
+  at?: string;
+}
+/**
+ * Send options for write operations
+ */
+interface SendOptions<Args = unknown> {
+  /** The origin account for the call */
+  origin: SS58String;
+  /** Arguments to pass to the contract message */
+  args?: Args;
+  /** Value to transfer with the call */
+  value?: bigint;
+  /** Gas limit (optional, will be estimated if not provided) */
+  gasLimit?: {
+    refTime: bigint;
+    proofSize: bigint;
+  };
+  /** Storage deposit limit */
+  storageDepositLimit?: bigint;
+}
+/**
+ * Sendable transaction that can be signed and submitted
+ */
+interface SendableTransaction<T> {
+  /** Sign and submit the transaction */
+  signAndSubmit(signer: PolkadotSigner): Promise<TxResult<T>>;
+  /** Get the encoded call data */
+  getEncodedData(): Uint8Array;
+}
+/**
+ * Transaction result
+ */
+interface TxResult<T> {
+  /** Whether the transaction was successful */
+  ok: boolean;
+  /** Transaction hash */
+  txHash: string;
+  /** Block information where tx was included */
+  block: {
+    hash: string;
+    number: number;
+  };
+  /** Decoded return value (if any) */
+  result?: T;
+  /** Events emitted by the transaction */
+  events: unknown[];
+  /** Dispatch error if failed */
+  dispatchError?: unknown;
+}
+/**
+ * Successful query result value
+ */
+interface QuerySuccessValue<T> {
+  /** The decoded response from the contract */
+  value: T;
+  /** Events that would be emitted */
+  events: unknown[];
+  /** Gas consumed during dry-run */
+  gasConsumed: {
+    refTime: bigint;
+    proofSize: bigint;
+  };
+  /** Gas required for execution */
+  gasRequired: {
+    refTime: bigint;
+    proofSize: bigint;
+  };
+  /** Storage deposit required */
+  storageDeposit: bigint;
+  /** Create a sendable transaction from this query result */
+  send(): SendableTransaction<T>;
+}
+/**
+ * Query result - discriminated union for success/failure
+ * On success: QuerySuccessValue fields are spread to the same level as success
+ * On failure: error field contains the ContractError
+ */
+type QueryResult<T> = ({
+  success: true;
+} & QuerySuccessValue<T>) | {
+  success: false;
+  error: ContractError;
+};
+/**
+ * Storage query interface
+ */
+interface ContractStorage {
+  /** Get the root storage value */
+  getRoot(): Promise<{
+    success: true;
+    value: unknown;
+  } | {
+    success: false;
+    value: ContractError;
+  }>;
+  /** Get a nested storage value by path */
+  getNested(path: string, ...keys: unknown[]): Promise<{
+    success: true;
+    value: unknown;
+  } | {
+    success: false;
+    value: ContractError;
+  }>;
+}
+/**
+ * Type helper to extract message args type
+ */
+type MessageArgs<M$1 extends InkCallableDescriptor, K extends keyof M$1> = M$1[K]["message"];
+/**
+ * ink! LangError type pattern
+ * papi generates LangError variants with { type: string; value?: unknown }
+ */
+type InkLangError = {
+  type: string;
+  value?: unknown;
+};
+/**
+ * ink! MessageResult type pattern (Result<T, LangError>)
+ * papi generates this as { success: true; value: T } | { success: false; value: LangError }
+ */
+type InkMessageResult<T> = {
+  success: true;
+  value: T;
+} | {
+  success: false;
+  value: unknown;
+};
+/**
+ * Type helper to unwrap ink! MessageResult (Result<T, LangError>)
+ * 1. Extract T from { success: true; value: T } | { success: false; value: ... }
+ * 2. Exclude LangError variants from T
+ */
+type UnwrapMessageResult<T> = T extends InkMessageResult<infer U> ? Exclude<U, InkLangError> : T;
+/**
+ * Type helper to extract message response type (with MessageResult unwrapped)
+ */
+type MessageResponse<M$1 extends InkCallableDescriptor, K extends keyof M$1> = UnwrapMessageResult<M$1[K]["response"]>;
+/**
+ * D9 Ink Contract interface
+ */
+interface D9InkContract<M$1 extends InkCallableDescriptor> {
+  /** Contract address */
+  readonly address: SS58String;
+  /** Contract metadata */
+  readonly metadata: InkMetadata;
+  /**
+   * Query a contract message (dry-run)
+   * @param method - The message label (e.g., "PSP22::balance_of")
+   * @param options - Query options including origin and args
+   */
+  query<K extends keyof M$1 & string>(method: K, options: QueryOptions<MessageArgs<M$1, K>>): Promise<QueryResult<MessageResponse<M$1, K>>>;
+  /**
+   * Create a sendable transaction for a contract message
+   * @param method - The message label (e.g., "PSP22::transfer")
+   * @param options - Send options including origin and args
+   */
+  send<K extends keyof M$1 & string>(method: K, options: SendOptions<MessageArgs<M$1, K>>): SendableTransaction<MessageResponse<M$1, K>>;
+  /**
+   * Get storage query interface
+   */
+  getStorage(): ContractStorage;
+  /**
+   * Filter events from a transaction result to only include this contract's events
+   */
+  filterEvents(events: unknown[]): DecodedContractEvent[];
+  /**
+   * Subscribe to contract events as an RxJS Observable
+   * @param options - Event subscription options (event labels to filter, etc.)
+   */
+  subscribeToEvents(options?: Omit<EventSubscriptionOptions, "contractAddress">): Observable<DecodedContractEvent>;
+}
+/**
+ * D9 Ink SDK options
+ */
+interface D9InkSdkOptions {
+  /** Default query options */
+  defaultQueryOptions?: Partial<QueryOptions>;
+  /** Default send options */
+  defaultSendOptions?: Partial<SendOptions>;
+}
+/**
+ * D9 Ink SDK interface
+ */
+interface D9InkSdk {
+  /**
+   * Get a contract instance for interacting with a deployed contract
+   * @param descriptor - The contract descriptor from @polkadot-api/descriptors
+   * @param address - The contract address (SS58 format)
+   */
+  getContract<S extends InkStorageDescriptor, M$1 extends InkCallableDescriptor, C extends InkCallableDescriptor, E extends Event>(descriptor: InkDescriptors<S, M$1, C, E>, address: SS58String): D9InkContract<M$1>;
+}
+type D9InkContractFromDescriptor<D> = D extends InkDescriptors<infer _S, infer M, infer _C, infer _E> ? D9InkContract<M> : never;
+/**
+ * Internal options for contract creation
+ */
+interface CreateContractOptions {
+  client: PolkadotClient;
+  typedApi?: unknown;
+  defaultQueryOptions?: Partial<QueryOptions>;
+  defaultSendOptions?: Partial<SendOptions>;
+}
+/**
+ * Type helper to infer the Messages type from an InkDescriptors
+ */
+type InferMessages<D> = D extends InkDescriptors<InkStorageDescriptor, infer M, InkCallableDescriptor, Event> ? M : never;
+//#endregion
+//#region src/sdk.d.ts
+/**
+ * Options for creating D9 Ink SDK
+ */
+interface CreateD9InkSdkOptions extends D9InkSdkOptions {
+  /**
+   * Typed API for transaction submission.
+   * Required for submitting real transactions.
+   */
+  typedApi?: unknown;
+}
+/**
+ * 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
+ */
+declare function createD9InkSdk(client: PolkadotClient, options?: CreateD9InkSdkOptions): D9InkSdk;
+//#endregion
+//#region src/contract.d.ts
+/**
+ * Create a D9 Ink Contract instance
+ */
+declare function createD9InkContract<S extends InkStorageDescriptor, M$1 extends InkCallableDescriptor, C extends InkCallableDescriptor, E extends Event>(descriptor: InkDescriptors<S, M$1, C, E>, address: SS58String, options: CreateContractOptions): D9InkContract<M$1>;
+//#endregion
+//#region src/encode.d.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
+ */
+declare function encodeContractCall(origin: Uint8Array | string, dest: Uint8Array | string, input: Binary | Uint8Array, value?: bigint): Bytes;
+/**
+ * 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
+ */
+declare function encodeCall(address: Uint8Array | string, input: Binary | Uint8Array, value?: bigint): Bytes;
+/**
+ * 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
+ */
+declare function encodeContractCallWithLimits(origin: Uint8Array | string, dest: Uint8Array | string, input: Binary | Uint8Array, options?: {
+  value?: bigint;
+  gasLimit?: {
+    refTime: bigint;
+    proofSize: bigint;
+  };
+  storageDepositLimit?: bigint;
+}): Bytes;
+//#endregion
+//#region src/decode.d.ts
+/**
+ * Gas information from contract execution
+ */
+interface GasInfo {
+  /** Gas consumed during execution */
+  gasConsumed: {
+    refTime: bigint;
+    proofSize: bigint;
+  };
+  /** Gas required for execution */
+  gasRequired: {
+    refTime: bigint;
+    proofSize: bigint;
+  };
+}
+/**
+ * Storage deposit information
+ */
+interface StorageDepositInfo {
+  /** Storage deposit type: 0 = Refund, 1 = Charge */
+  type: "Refund" | "Charge";
+  /** Amount of storage deposit */
+  amount: bigint;
+}
+/**
+ * Full decoded result from ContractsApi_call
+ */
+interface ContractCallResult {
+  /** Gas information */
+  gas: GasInfo;
+  /** Storage deposit information */
+  storageDeposit: StorageDepositInfo;
+  /** Debug message (if any) */
+  debugMessage: string;
+  /** Whether the execution was successful */
+  success: boolean;
+  /** Execution flags */
+  flags: number;
+  /** The raw execution result bytes (still wrapped in Result<T, LangError>) */
+  data: Uint8Array;
+}
+/**
+ * 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
+ */
+declare function decodeContractCallResult(result: Uint8Array): ContractCallResult;
+/**
+ * Legacy function - decode and return just the exec result data.
+ * @deprecated Use decodeContractCallResult for full information
+ */
+declare function decodeResult(result: Uint8Array): Uint8Array;
+/**
+ * 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)
+ */
+declare function unwrapInkResult(data: Uint8Array): Uint8Array;
+/**
+ * Check if the result indicates a LangError
+ *
+ * @param data - The exec result bytes
+ * @returns True if it's a LangError (Err variant)
+ */
+declare function isLangError(data: Uint8Array): boolean;
+/**
+ * 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
+ */
+declare function decodeInkValue<T>(data: Uint8Array, codec: Codec<T>): T;
+/**
+ * Pre-defined codecs for common types
+ */
+declare const InkCodecs: {
+  /** u128 codec for Balance type */
+  u128: Codec<bigint>;
+  /** Tuple of two u128 values, commonly used for (Balance, Balance) */
+  balancePair: [_polkadot_api_substrate_bindings0.Encoder<[bigint, bigint]>, _polkadot_api_substrate_bindings0.Decoder<[bigint, bigint]>] & {
+    enc: _polkadot_api_substrate_bindings0.Encoder<[bigint, bigint]>;
+    dec: _polkadot_api_substrate_bindings0.Decoder<[bigint, bigint]>;
+  } & {
+    inner: [Codec<bigint>, Codec<bigint>];
+  };
+};
+//#endregion
+//#region src/codec-builder.d.ts
+/**
+ * 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
+ */
+declare function buildMessageDecoder(metadata: InkMetadata, messageLabel: string): (data: Uint8Array) => unknown;
+/**
+ * Build decoders for all messages in the metadata.
+ * Returns a Map of message label -> decoder function.
+ */
+declare function buildAllMessageDecoders(metadata: InkMetadata): Map<string, (data: Uint8Array) => unknown>;
+/**
+ * Create a codec registry compatible with ResponseDecoder type
+ */
+declare function createCodecRegistry(metadata: InkMetadata): Map<string, {
+  dec: (data: Uint8Array) => unknown;
+}>;
+/**
+ * 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
+ */
+declare function buildEventDecoder(metadata: InkMetadata, eventLabel: string): (data: Uint8Array) => unknown;
+/**
+ * Build decoders for all events in the metadata
+ *
+ * @param metadata - The ink contract metadata
+ * @returns Map of event label -> decoder function
+ */
+declare function buildAllEventDecoders(metadata: InkMetadata): Map<string, (data: Uint8Array) => unknown>;
+/**
+ * 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)
+ */
+declare function getEventSignature(eventLabel: string): Uint8Array;
+//#endregion
+//#region src/events.d.ts
+/**
+ * Event parser for a specific contract
+ */
+declare class ContractEventParser {
+  private eventDecoders;
+  private eventSignatures;
+  private contractAddressBytes;
+  private contractAddress;
+  private metadata;
+  constructor(metadata: InkMetadata, contractAddress: SS58String);
+  /**
+   * 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: unknown): DecodedContractEvent | null;
+  /**
+   * Filter a batch of events
+   */
+  filterEvents(chainEvents: unknown[], options?: EventFilterOptions): DecodedContractEvent[];
+  /**
+   * Get the contract address as SS58 string
+   */
+  private getContractAddress;
+  /**
+   * Extract ContractEmitted event from chain event structure
+   * Based on polkadot-api event format
+   */
+  private extractContractEmittedEvent;
+  /**
+   * Compare two Uint8Arrays for equality
+   */
+  private bytesEqual;
+  /**
+   * Build event signature map from metadata
+   */
+  private static buildEventSignatureMap;
+}
+//#endregion
+//#region src/subscriptions.d.ts
+/**
+ * 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
+ */
+declare function createContractEventStream(client: PolkadotClient, metadata: InkMetadata, options: EventSubscriptionOptions): Observable<DecodedContractEvent>;
+/**
+ * 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
+ */
+declare function createPSP22TransferStream(client: PolkadotClient, metadata: InkMetadata, contractAddress: SS58String, getEvents: (blockHash: string) => Promise<unknown[]>, watchAddress?: SS58String): Observable<DecodedContractEvent<{
+  from?: SS58String | null;
+  to?: SS58String | null;
+  value: bigint;
+}>>;
+/**
+ * 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
+ */
+declare function createNativeTransferStream(client: PolkadotClient, getEvents: (blockHash: string) => Promise<unknown[]>, watchAddress: SS58String): Observable<{
+  from: SS58String;
+  to: SS58String;
+  amount: bigint;
+  blockNumber: number;
+  blockHash: string;
+}>;
+//#endregion
+export { AbortedError, type ContractCallResult, ContractError, type ContractErrorType, ContractEventParser, ContractExecutionError, type ContractStorage, type CreateContractOptions, type CreateD9InkSdkOptions, type D9InkContract, type D9InkContractFromDescriptor, type D9InkSdk, type D9InkSdkOptions, DecodeError, type DecodedContractEvent, EncodeError, type EventFilterOptions, type EventSubscriptionOptions, type GasInfo, type InferMessages, InkCodecs, LangError, MetadataError, NetworkError, type QueryOptions, type QueryResult, type QuerySuccessValue, type RawContractEvent, type ResponseDecoder, type SendOptions, type SendableTransaction, SignerError, type StorageDepositInfo, TimeoutError, TransactionError, type TxResult, buildAllEventDecoders, buildAllMessageDecoders, buildEventDecoder, buildMessageDecoder, createCodecRegistry, createContractEventStream, createD9InkContract, createD9InkSdk, createNativeTransferStream, createPSP22TransferStream, decodeContractCallResult, decodeInkValue, decodeResult, encodeCall, encodeContractCall, encodeContractCallWithLimits, getEventSignature, isContractError, isErrorType, isLangError, unwrapInkResult };
+//# sourceMappingURL=index.d.mts.map