@d9-network/ink 0.0.1

package/src/events.ts

@@ -0,0 +1,258 @@
+/**
+ * Event parsing and filtering for ink! contracts
+ */
+import type { InkMetadata } from "@polkadot-api/ink-contracts";
+import type { SS58String } from "polkadot-api";
+import { ss58Decode } from "@polkadot-labs/hdkd-helpers";
+import {
+	buildAllEventDecoders,
+	buildEventDecoder,
+	getEventSignature,
+} from "./codec-builder";
+import type {
+	DecodedContractEvent,
+	EventFilterOptions,
+	RawContractEvent,
+} from "./event-types";
+
+/**
+ * Event parser for a specific contract
+ */
+export class ContractEventParser {
+	private eventDecoders: Map<string, (data: Uint8Array) => unknown>;
+	private eventSignatures: Map<string, Uint8Array>;
+	private contractAddressBytes: Uint8Array;
+	private contractAddress: SS58String;
+	private metadata: InkMetadata;
+
+	constructor(metadata: InkMetadata, contractAddress: SS58String) {
+		this.metadata = metadata;
+		this.contractAddress = contractAddress;
+		this.eventDecoders = buildAllEventDecoders(metadata);
+		this.contractAddressBytes = ss58Decode(contractAddress)[0];
+
+		// Build signature map for topic filtering
+		this.eventSignatures = new Map();
+		const events = metadata.spec.events as Array<{ label: string }>;
+
+		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: unknown): DecodedContractEvent | null {
+		// Extract Contracts.ContractEmitted event from chain event
+		const extracted = this.extractContractEmittedEvent(chainEvent);
+		if (!extracted) return null;
+
+		const { contract, data, topics, blockNumber, blockHash, eventIndex } =
+			extracted;
+
+		// Filter by contract address
+		if (!this.bytesEqual(contract, this.contractAddressBytes)) {
+			return null;
+		}
+
+		// Decode event based on topic[0] signature
+		if (topics.length === 0) return null;
+
+		const signature = topics[0];
+		let eventLabel: string | null = 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: unknown[],
+		options?: EventFilterOptions,
+	): DecodedContractEvent[] {
+		const results: DecodedContractEvent[] = [];
+
+		for (const chainEvent of chainEvents) {
+			const parsed = this.parseEvent(chainEvent);
+			if (!parsed) continue;
+
+			// Apply label filter
+			if (
+				options?.eventLabels &&
+				!options.eventLabels.includes(parsed.label)
+			) {
+				continue;
+			}
+
+			// Apply block range filter
+			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
+	 */
+	private getContractAddress(): SS58String {
+		return this.contractAddress;
+	}
+
+	/**
+	 * Extract ContractEmitted event from chain event structure
+	 * Based on polkadot-api event format
+	 */
+	private extractContractEmittedEvent(chainEvent: unknown): {
+		contract: Uint8Array;
+		data: Uint8Array;
+		topics: Uint8Array[];
+		blockNumber: number;
+		blockHash: string;
+		eventIndex: number;
+	} | null {
+		// Type guard and extract event structure
+		if (!chainEvent || typeof chainEvent !== "object") {
+			return null;
+		}
+
+		const record = chainEvent as any;
+
+		// Extract event data
+		const event = record.event;
+		if (!event || typeof event !== "object") {
+			return null;
+		}
+
+		// Check if this is a Contracts pallet event
+		if (event.type !== "Contracts") {
+			return null;
+		}
+
+		// Check if this is a ContractEmitted event
+		const eventValue = event.value;
+		if (!eventValue || typeof eventValue !== "object") {
+			return null;
+		}
+
+		if (eventValue.type !== "ContractEmitted") {
+			return null;
+		}
+
+		// Extract contract address and data
+		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;
+		}
+
+		// Extract topics from the event record
+		// Topics are typically stored in the event record, not in the event value
+		const topics: Uint8Array[] = [];
+
+		// Polkadot-API typically stores topics at the record level
+		if (record.topics && Array.isArray(record.topics)) {
+			for (const topic of record.topics) {
+				if (topic instanceof Uint8Array) {
+					topics.push(topic);
+				}
+			}
+		}
+
+		// Extract block metadata
+		const blockNumber =
+			typeof record.blockNumber === "number" ? record.blockNumber : 0;
+		const blockHash =
+			typeof record.blockHash === "string" ? record.blockHash : "";
+		const eventIndex =
+			typeof record.eventIndex === "number" ? record.eventIndex : 0;
+
+		return {
+			contract,
+			data,
+			topics,
+			blockNumber,
+			blockHash,
+			eventIndex,
+		};
+	}
+
+	/**
+	 * Compare two Uint8Arrays for equality
+	 */
+	private bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
+		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
+	 */
+	private static buildEventSignatureMap(
+		metadata: InkMetadata,
+	): Map<string, Uint8Array> {
+		const signatures = new Map<string, Uint8Array>();
+		const events = metadata.spec.events as Array<{ label: string }>;
+
+		for (const event of events) {
+			const sig = getEventSignature(event.label);
+			signatures.set(event.label, sig);
+		}
+
+		return signatures;
+	}
+}

package/src/index.ts

@@ -0,0 +1,94 @@
+/**
+ * D9 Ink SDK
+ *
+ * A type-safe ink! smart contract SDK that uses state_call + ContractsApi_call
+ * instead of ReviveApi, for chains that don't support it.
+ */
+
+// Main SDK entry point
+export { createD9InkSdk, type CreateD9InkSdkOptions } from "./sdk";
+
+// Contract creation
+export { createD9InkContract } from "./contract";
+
+// Types
+export type {
+  D9InkSdk,
+  D9InkSdkOptions,
+  D9InkContract,
+  QueryOptions,
+  QueryResult,
+  QuerySuccessValue,
+  SendOptions,
+  SendableTransaction,
+  TxResult,
+  ContractStorage,
+  CreateContractOptions,
+  InferMessages,
+  ResponseDecoder,
+  D9InkContractFromDescriptor,
+} from "./types";
+
+// Errors
+export {
+  ContractError,
+  MetadataError,
+  EncodeError,
+  DecodeError,
+  NetworkError,
+  ContractExecutionError,
+  LangError,
+  TimeoutError,
+  AbortedError,
+  SignerError,
+  TransactionError,
+  isContractError,
+  isErrorType,
+  type ContractErrorType,
+} from "./errors";
+
+// Encoding utilities
+export {
+  encodeCall,
+  encodeContractCall,
+  encodeContractCallWithLimits,
+} from "./encode";
+
+// Decoding utilities
+export {
+  decodeResult,
+  decodeContractCallResult,
+  unwrapInkResult,
+  isLangError,
+  decodeInkValue,
+  InkCodecs,
+  type GasInfo,
+  type StorageDepositInfo,
+  type ContractCallResult,
+} from "./decode";
+
+// Codec builder
+export {
+  buildMessageDecoder,
+  buildAllMessageDecoders,
+  createCodecRegistry,
+  buildEventDecoder,
+  buildAllEventDecoders,
+  getEventSignature,
+} from "./codec-builder";
+
+// Event handling
+export { ContractEventParser } from "./events";
+export {
+  createContractEventStream,
+  createPSP22TransferStream,
+  createNativeTransferStream,
+} from "./subscriptions";
+
+// Event types
+export type {
+  RawContractEvent,
+  DecodedContractEvent,
+  EventFilterOptions,
+  EventSubscriptionOptions,
+} from "./event-types";

package/src/sdk.ts

@@ -0,0 +1,116 @@
+/**
+ * D9 Ink SDK entry point
+ *
+ * Creates an ink SDK that uses state_call + ContractsApi_call
+ * instead of ReviveApi for chains that don't support it.
+ */
+
+import type { PolkadotClient, SS58String } from "polkadot-api";
+import {
+  type InkDescriptors,
+  type InkCallableDescriptor,
+  type InkStorageDescriptor,
+  type Event,
+} from "@polkadot-api/ink-contracts";
+
+import type {
+  D9InkSdk,
+  D9InkSdkOptions,
+  D9InkContract,
+  QueryOptions,
+  SendOptions,
+} from "./types";
+import { createD9InkContract } from "./contract";
+
+/**
+ * Options for creating D9 Ink SDK
+ */
+export 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
+ */
+export function createD9InkSdk(
+  client: PolkadotClient,
+  options: CreateD9InkSdkOptions = {},
+): D9InkSdk {
+  const { typedApi, defaultQueryOptions, defaultSendOptions } = options;
+
+  return {
+    getContract<
+      S extends InkStorageDescriptor,
+      M extends InkCallableDescriptor,
+      C extends InkCallableDescriptor,
+      E extends Event,
+    >(
+      descriptor: InkDescriptors<S, M, C, E>,
+      address: SS58String,
+    ): D9InkContract<M> {
+      return createD9InkContract(descriptor, address, {
+        client,
+        typedApi,
+        defaultQueryOptions,
+        defaultSendOptions,
+      });
+    },
+  };
+}
+
+// Re-export types for convenience
+export type {
+  D9InkSdk,
+  D9InkSdkOptions,
+  D9InkContract,
+  QueryOptions,
+  SendOptions,
+  QueryResult,
+  SendableTransaction,
+  TxResult,
+  ContractStorage,
+} from "./types";

package/src/subscriptions.ts

@@ -0,0 +1,207 @@
+/**
+ * Event subscriptions using RxJS
+ */
+import { Observable, filter, map, mergeMap, share, from, of, catchError } from "rxjs";
+import type { PolkadotClient } from "polkadot-api";
+import type { InkMetadata } from "@polkadot-api/ink-contracts";
+import type { SS58String } from "polkadot-api";
+import { ContractEventParser } from "./events";
+import type { DecodedContractEvent, EventSubscriptionOptions } from "./event-types";
+
+/**
+ * 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
+ */
+export function createContractEventStream(
+  client: PolkadotClient,
+  metadata: InkMetadata,
+  options: EventSubscriptionOptions,
+): Observable<DecodedContractEvent> {
+  const parser = new ContractEventParser(metadata, options.contractAddress);
+
+  // Subscribe to finalized blocks
+  return client.finalizedBlock$.pipe(
+    // For each finalized block, fetch its events
+    mergeMap(async (block) => {
+      try {
+        // Fetch System.Events at this block using the provided callback
+        const events = await options.getEvents(block.hash);
+        return { block, events };
+      } catch (error: unknown) {
+        console.error(
+          "Error fetching events at block",
+          block.number,
+          ":",
+          error instanceof Error ? error.message : String(error),
+        );
+        // Return empty events on error to keep stream alive
+        return { block, events: [] };
+      }
+    }),
+
+    // Parse and filter events for this contract
+    map(({ block, events }) => {
+      const parsedEvents = events
+        .map((event, index) => {
+          // Attach block metadata to each event before parsing
+          const eventWithMeta = {
+            ...(event as object),
+            blockNumber: block.number,
+            blockHash: block.hash,
+            eventIndex: index,
+          };
+          return parser.parseEvent(eventWithMeta);
+        })
+        .filter((e: DecodedContractEvent | null): e is DecodedContractEvent => e !== null);
+
+      return parsedEvents;
+    }),
+
+    // Flatten array of events to individual emissions
+    mergeMap((events: DecodedContractEvent[]) => from(events)),
+
+    // Filter by event labels if specified
+    filter((event: DecodedContractEvent) => {
+      if (!options.eventLabels) return true;
+      return options.eventLabels.includes(event.label);
+    }),
+
+    // Handle errors gracefully
+    catchError((error: unknown) => {
+      console.error("Error in contract event stream:", error);
+      return of(); // Return empty observable on error
+    }),
+
+    // Share subscription among multiple subscribers
+    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
+ */
+export 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;
+  }>
+> {
+  return createContractEventStream(client, metadata, {
+    contractAddress,
+    eventLabels: ["Transfer"],
+    getEvents,
+  }).pipe(
+    filter((event: DecodedContractEvent) => {
+      if (!watchAddress) return true;
+
+      // Filter transfers where from=watchAddress or to=watchAddress
+      const data = event.data as {
+        from?: SS58String | null;
+        to?: SS58String | null;
+        value: bigint;
+      };
+
+      return data.from === watchAddress || data.to === watchAddress;
+    }),
+  ) as 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
+ */
+export function createNativeTransferStream(
+  client: PolkadotClient,
+  getEvents: (blockHash: string) => Promise<unknown[]>,
+  watchAddress: SS58String,
+): Observable<{
+  from: SS58String;
+  to: SS58String;
+  amount: bigint;
+  blockNumber: number;
+  blockHash: string;
+}> {
+  return client.finalizedBlock$.pipe(
+    // For each block, query system events
+    mergeMap(async (block: any) => {
+      try {
+        const events = await getEvents(block.hash);
+        return { block, events };
+      } catch (error: unknown) {
+        console.error(
+          "Error fetching events for native transfers:",
+          error instanceof Error ? error.message : String(error),
+        );
+        return { block, events: [] };
+      }
+    }),
+
+    // Filter for Balances.Transfer events
+    map(({ block, events }) => {
+      const transfers = events
+        .map((record: any) => {
+          // Check if this is a Balances.Transfer event
+          if (record.event?.type !== "Balances") return null;
+          if (record.event?.value?.type !== "Transfer") return null;
+
+          const { from, to, amount } = record.event.value.value;
+
+          // Filter by watchAddress
+          if (from !== watchAddress && to !== watchAddress) return null;
+
+          return {
+            from: from as SS58String,
+            to: to as SS58String,
+            amount: amount as bigint,
+            blockNumber: block.number,
+            blockHash: block.hash,
+          };
+        })
+        .filter((t: any): t is NonNullable<typeof t> => t !== null);
+
+      return transfers;
+    }),
+
+    // Flatten array to individual emissions
+    mergeMap((transfers: any[]) => from(transfers)),
+
+    // Handle errors
+    catchError((error: unknown) => {
+      console.error("Error in native transfer stream:", error);
+      return of();
+    }),
+
+    // Share subscription
+    share(),
+  );
+}