@d9-network/ink 0.0.1

package/src/contract.ts

@@ -0,0 +1,571 @@
+/**
+ * D9 Ink Contract implementation
+ *
+ * Provides a type-safe interface for interacting with ink! smart contracts
+ * using state_call + ContractsApi_call instead of ReviveApi.
+ */
+
+import type { PolkadotSigner, SS58String } from "polkadot-api";
+import { Binary } from "polkadot-api";
+import { fromHex } from "polkadot-api/utils";
+import {
+  getInkLookup,
+  getInkDynamicBuilder,
+  type InkDescriptors,
+  type InkCallableDescriptor,
+  type InkStorageDescriptor,
+  type InkMetadata,
+  type Event,
+} from "@polkadot-api/ink-contracts";
+import { ss58Decode } from "@polkadot-labs/hdkd-helpers";
+
+import type {
+  D9InkContract,
+  QueryOptions,
+  QueryResult,
+  SendOptions,
+  SendableTransaction,
+  TxResult,
+  ContractStorage,
+  CreateContractOptions,
+  ResponseDecoder,
+} from "./types";
+import { encodeContractCall } from "./encode";
+import {
+  decodeContractCallResult,
+  unwrapInkResult,
+  isLangError,
+} from "./decode";
+import { createCodecRegistry } from "./codec-builder";
+import { ContractEventParser } from "./events";
+import { createContractEventStream } from "./subscriptions";
+import type {
+  DecodedContractEvent,
+  EventSubscriptionOptions,
+} from "./event-types";
+import {
+  ContractError,
+  MetadataError,
+  DecodeError,
+  LangError,
+  TimeoutError,
+  AbortedError,
+  TransactionError,
+} from "./errors";
+
+/**
+ * Patch LangError type in ink metadata to fix the missing index 0 variant issue.
+ * Uses structuredClone for efficient deep cloning.
+ */
+function patchLangErrorInMetadata(metadata: InkMetadata): InkMetadata {
+  const patched = structuredClone(metadata);
+
+  for (const typeEntry of patched.types) {
+    const path = typeEntry.type?.path;
+    const def = typeEntry.type?.def as {
+      variant?: {
+        variants: Array<{
+          index: number;
+          name: string;
+          fields: unknown[];
+          docs: string[];
+        }>;
+      };
+    };
+    if (
+      path &&
+      Array.isArray(path) &&
+      path.includes("LangError") &&
+      def?.variant
+    ) {
+      const variants = def.variant.variants;
+      if (Array.isArray(variants)) {
+        const hasIndex0 = variants.some((v) => v.index === 0);
+        if (!hasIndex0) {
+          variants.unshift({
+            index: 0,
+            name: "_Placeholder",
+            fields: [],
+            docs: [],
+          });
+        }
+      }
+    }
+  }
+
+  return patched;
+}
+
+/**
+ * Convert SS58 address to bytes
+ */
+function ss58ToBytes(address: SS58String): Uint8Array {
+  const [publicKey] = ss58Decode(address);
+  return publicKey;
+}
+
+/**
+ * Create a promise that rejects after a timeout
+ */
+function createTimeout<T>(
+  ms: number,
+  label: string,
+): { promise: Promise<T>; clear: () => void } {
+  let timeoutId: ReturnType<typeof setTimeout>;
+  const promise = new Promise<T>((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new TimeoutError(label, ms));
+    }, ms);
+  });
+  return {
+    promise,
+    clear: () => clearTimeout(timeoutId),
+  };
+}
+
+/**
+ * Check if AbortSignal is aborted and throw if so
+ */
+function checkAborted(signal: AbortSignal | undefined, label: string): void {
+  if (signal?.aborted) {
+    throw new AbortedError(label, signal.reason);
+  }
+}
+
+/**
+ * Create a D9 Ink Contract instance
+ */
+export function createD9InkContract<
+  S extends InkStorageDescriptor,
+  M extends InkCallableDescriptor,
+  C extends InkCallableDescriptor,
+  E extends Event,
+>(
+  descriptor: InkDescriptors<S, M, C, E>,
+  address: SS58String,
+  options: CreateContractOptions,
+): D9InkContract<M> {
+  const { client, typedApi, defaultQueryOptions = {}, defaultSendOptions = {} } = options;
+
+  if (!descriptor.metadata) {
+    throw new MetadataError("Contract descriptor must include metadata");
+  }
+
+  // Patch and prepare metadata
+  const patchedMetadata = patchLangErrorInMetadata(descriptor.metadata);
+  const lookup = getInkLookup(patchedMetadata);
+  const builder = getInkDynamicBuilder(lookup);
+
+  // Build auto-generated codecs
+  let codecRegistry: Map<string, ResponseDecoder>;
+  try {
+    codecRegistry = createCodecRegistry(patchedMetadata);
+  } catch (error) {
+    console.warn("Failed to auto-generate codecs from metadata:", error);
+    codecRegistry = new Map();
+  }
+
+  // Convert address to bytes
+  const addressBytes = ss58ToBytes(address);
+
+  // Cache for message codecs
+  type MessageCodec = ReturnType<typeof builder.buildMessage>;
+  const messageCodecCache = new Map<string, MessageCodec>();
+
+  function getMessageCodec(label: string): MessageCodec {
+    const cached = messageCodecCache.get(label);
+    if (cached) {
+      return cached;
+    }
+    const codec = builder.buildMessage(label);
+    messageCodecCache.set(label, codec);
+    return codec;
+  }
+
+  /**
+   * Get the decoder for a message
+   */
+  function getDecoder(label: string): ResponseDecoder | null {
+    return codecRegistry.get(label) ?? null;
+  }
+
+  /**
+   * Execute a query (dry-run)
+   */
+  async function executeQuery<K extends keyof M & string>(
+    method: K,
+    queryOptions: QueryOptions<M[K]["message"]>,
+  ): Promise<QueryResult<M[K]["response"]>> {
+    const opts = { ...defaultQueryOptions, ...queryOptions };
+    const { origin, args, value = 0n, signal, timeout, at } = opts;
+
+    try {
+      checkAborted(signal, method);
+
+      const originBytes = ss58ToBytes(origin);
+      const codec = getMessageCodec(method);
+
+      // Encode the call
+      const callData = codec.call.enc(
+        (args ?? {}) as Parameters<typeof codec.call.enc>[0],
+      );
+
+      // Create the state_call message
+      const message = encodeContractCall(
+        originBytes,
+        addressBytes,
+        callData,
+        value,
+      );
+
+      // Get block hash
+      const blockHash = at ?? (await client.getFinalizedBlock()).hash;
+
+      checkAborted(signal, method);
+
+      // Execute state_call with optional timeout
+      const executeCall = async () => {
+        const response = (await client._request("state_call", [
+          "ContractsApi_call",
+          message,
+          blockHash,
+        ])) as `0x${string}`;
+
+        return fromHex(response);
+      };
+
+      let rawResponse: Uint8Array;
+      if (timeout) {
+        const { promise: timeoutPromise, clear } = createTimeout<Uint8Array>(
+          timeout,
+          method,
+        );
+        try {
+          rawResponse = await Promise.race([executeCall(), timeoutPromise]);
+        } finally {
+          clear();
+        }
+      } else {
+        rawResponse = await executeCall();
+      }
+
+      checkAborted(signal, method);
+
+      // Decode the ContractsApi_call response
+      const callResult = decodeContractCallResult(rawResponse);
+
+      // Check for execution error
+      if (!callResult.success) {
+        return {
+          success: false,
+          error: new ContractError(
+            `Contract execution failed: ${callResult.debugMessage}`,
+            "CONTRACT_ERROR",
+            method,
+          ),
+        };
+      }
+
+      // Check for LangError
+      if (isLangError(callResult.data)) {
+        return {
+          success: false,
+          error: new LangError(method, callResult.data[1] ?? 1),
+        };
+      }
+
+      // Unwrap the Result<T, LangError>
+      const innerData = unwrapInkResult(callResult.data);
+
+      // Decode the response
+      let decodedResponse: M[K]["response"];
+      const decoder = getDecoder(method);
+
+      if (decoder) {
+        try {
+          decodedResponse = decoder.dec(innerData) as M[K]["response"];
+        } catch (decodeError) {
+          console.warn("D9InkContract: Failed to decode response:", decodeError);
+          // Fall back to papi's value codec
+          const fullResult = new Uint8Array(1 + innerData.length);
+          fullResult[0] = 0; // Ok variant
+          fullResult.set(innerData, 1);
+
+          try {
+            const papiResult = codec.value.dec(fullResult);
+            if (
+              papiResult !== null &&
+              typeof papiResult === "object" &&
+              "success" in papiResult &&
+              "value" in papiResult
+            ) {
+              if (papiResult.success) {
+                decodedResponse = papiResult.value as M[K]["response"];
+              } else {
+                return {
+                  success: false,
+                  error: new DecodeError(
+                    method,
+                    `Contract returned error: ${JSON.stringify(papiResult.value)}`,
+                    papiResult.value,
+                  ),
+                };
+              }
+            } else {
+              decodedResponse = papiResult as M[K]["response"];
+            }
+          } catch (error) {
+            return {
+              success: false,
+              error: new DecodeError(
+                method,
+                `Failed to decode response: ${error instanceof Error ? error.message : String(error)}`,
+                { error },
+              ),
+            };
+          }
+        }
+      } else {
+        // No custom decoder, use papi's codec
+        const fullResult = new Uint8Array(1 + innerData.length);
+        fullResult[0] = 0; // Ok variant
+        fullResult.set(innerData, 1);
+
+        const papiResult = codec.value.dec(fullResult);
+        if (
+          papiResult !== null &&
+          typeof papiResult === "object" &&
+          "success" in papiResult &&
+          "value" in papiResult
+        ) {
+          if (papiResult.success) {
+            decodedResponse = papiResult.value as M[K]["response"];
+          } else {
+            return {
+              success: false,
+              error: new DecodeError(
+                method,
+                `Contract returned error: ${JSON.stringify(papiResult.value)}`,
+                papiResult.value,
+              ),
+            };
+          }
+        } else {
+          decodedResponse = papiResult as M[K]["response"];
+        }
+      }
+
+      // Return success with QuerySuccessValue fields spread to same level
+      return {
+        success: true,
+        value: decodedResponse,
+        events: [],
+        gasConsumed: callResult.gas.gasConsumed,
+        gasRequired: callResult.gas.gasRequired,
+        storageDeposit: callResult.storageDeposit.amount,
+        send: () => createSendableTransaction(method, {
+          origin,
+          args,
+          value,
+          gasLimit: callResult.gas.gasRequired,
+        }),
+      };
+    } catch (error) {
+      if (error instanceof ContractError) {
+        return { success: false, error };
+      }
+      return {
+        success: false,
+        error: new ContractError(
+          error instanceof Error ? error.message : String(error),
+          "NETWORK_ERROR",
+          method,
+        ),
+      };
+    }
+  }
+
+  /**
+   * Create a sendable transaction
+   */
+  function createSendableTransaction<K extends keyof M & string>(
+    method: K,
+    sendOptions: SendOptions<M[K]["message"]>,
+  ): SendableTransaction<M[K]["response"]> {
+    const opts = { ...defaultSendOptions, ...sendOptions };
+    const { origin, args, value = 0n, gasLimit, storageDepositLimit } = opts;
+
+    const originBytes = ss58ToBytes(origin);
+    const codec = getMessageCodec(method);
+
+    // Encode the call
+    const callData = codec.call.enc(
+      (args ?? {}) as Parameters<typeof codec.call.enc>[0],
+    );
+
+    return {
+      getEncodedData: () => callData,
+
+      async signAndSubmit(signer: PolkadotSigner): Promise<TxResult<M[K]["response"]>> {
+        if (!typedApi) {
+          throw new TransactionError(
+            method,
+            "typedApi is required for transaction submission. Pass typedApi in SDK options.",
+          );
+        }
+
+        try {
+          // First do a dry-run to get gas estimate if not provided
+          let gas = gasLimit;
+          if (!gas) {
+            const message = encodeContractCall(
+              originBytes,
+              addressBytes,
+              callData,
+              value,
+            );
+            const blockHash = (await client.getFinalizedBlock()).hash;
+            const response = (await client._request("state_call", [
+              "ContractsApi_call",
+              message,
+              blockHash,
+            ])) as `0x${string}`;
+            const callResult = decodeContractCallResult(fromHex(response));
+            gas = callResult.gas.gasRequired;
+          }
+
+          // Build the transaction using typedApi
+          const api = typedApi as {
+            tx: {
+              Contracts: {
+                call: (params: {
+                  dest: { type: "Id"; value: SS58String };
+                  value: bigint;
+                  gas_limit: { ref_time: bigint; proof_size: bigint };
+                  storage_deposit_limit: bigint | undefined;
+                  data: Binary;
+                }) => {
+                  signAndSubmit: (
+                    signer: PolkadotSigner,
+                    options?: { at?: "best" | "finalized" }
+                  ) => Promise<{
+                    txHash: string;
+                    block: { hash: string; number: number };
+                    events: unknown[];
+                  }>;
+                };
+              };
+            };
+          };
+
+          const tx = api.tx.Contracts.call({
+            dest: { type: "Id", value: address },
+            value,
+            gas_limit: {
+              ref_time: gas.refTime,
+              proof_size: gas.proofSize,
+            },
+            storage_deposit_limit: storageDepositLimit,
+            data: Binary.fromBytes(callData),
+          });
+
+          const txResult = await tx.signAndSubmit(signer, { at: "finalized" });
+
+          return {
+            ok: true,
+            txHash: txResult.txHash,
+            block: txResult.block,
+            events: txResult.events ?? [],
+          };
+        } catch (error) {
+          return {
+            ok: false,
+            txHash: "",
+            block: { hash: "", number: 0 },
+            events: [],
+            dispatchError: error,
+          };
+        }
+      },
+    };
+  }
+
+  /**
+   * Create send method that returns a sendable transaction
+   */
+  function send<K extends keyof M & string>(
+    method: K,
+    sendOptions: SendOptions<M[K]["message"]>,
+  ): SendableTransaction<M[K]["response"]> {
+    return createSendableTransaction(method, sendOptions);
+  }
+
+  /**
+   * Create storage query interface
+   */
+  function getStorage(): ContractStorage {
+    return {
+      async getRoot() {
+        // TODO: Implement storage root query
+        console.warn("D9InkContract: getRoot not implemented");
+        return {
+          success: false,
+          value: new ContractError(
+            "Storage queries not yet implemented",
+            "METADATA_ERROR",
+          ),
+        };
+      },
+
+      async getNested(path: string, ..._keys: unknown[]) {
+        // TODO: Implement nested storage query
+        console.warn("D9InkContract: getNested not implemented");
+        return {
+          success: false,
+          value: new ContractError(
+            `Storage query for "${path}" not yet implemented`,
+            "METADATA_ERROR",
+          ),
+        };
+      },
+    };
+  }
+
+  /**
+   * Filter events for this contract
+   */
+  function filterEvents(events: unknown[]): DecodedContractEvent[] {
+    const parser = new ContractEventParser(patchedMetadata, address);
+    return parser.filterEvents(events);
+  }
+
+  /**
+   * Subscribe to contract events as an RxJS Observable
+   *
+   * @param options - Subscription options (contractAddress is automatically set)
+   * @param options.getEvents - Function to fetch System.Events at a block hash
+   * @param options.eventLabels - Optional filter for specific event names
+   * @param options.fromBlock - Optional starting block number
+   */
+  function subscribeToEvents(
+    options: Omit<EventSubscriptionOptions, "contractAddress">,
+  ) {
+    return createContractEventStream(client, patchedMetadata, {
+      ...options,
+      contractAddress: address,
+    });
+  }
+
+  // Type assertion needed because the runtime correctly unwraps MessageResult
+  // but TypeScript doesn't know that. The UnwrapMessageResult type in D9InkContract
+  // matches what we actually return at runtime.
+  return {
+    address,
+    metadata: patchedMetadata,
+    query: executeQuery,
+    send,
+    getStorage,
+    filterEvents,
+    subscribeToEvents,
+  } as D9InkContract<M>;
+}