@d9-network/ink 0.0.1

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@d9-network/ink",
+  "version": "0.0.1",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "publishConfig": {
+    "exports": {
+      ".": {
+        "require": "./dist/index.cjs",
+        "import": "./dist/index.mjs"
+      },
+      "./package.json": "./package.json"
+    },
+    "access": "public"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "test": "bun test",
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@noble/hashes": "^2.0.1",
+    "@polkadot-api/ink-contracts": "^0.4.4",
+    "@polkadot-api/substrate-bindings": "^0.16.5",
+    "@polkadot-labs/hdkd-helpers": "^0.0.11",
+    "@subsquid/scale-codec": "^4.0.1",
+    "polkadot-api": "^1.23.1"
+  },
+  "devDependencies": {
+    "@polkadot-api/descriptors": "file:../spec/.papi/descriptors",
+    "@polkadot-api/legacy-provider": "^0.3.6",
+    "@polkadot-api/signer": "^0.2.11",
+    "@polkadot-labs/hdkd": "^0.0.11",
+    "@types/bun": "latest",
+    "@types/node": "latest",
+    "tsdown": "^0.18.1",
+    "typescript": "~5.9.3"
+  }
+}

package/src/codec-builder.ts

@@ -0,0 +1,573 @@
+/**
+ * Auto-build SCALE decoders from ink metadata type definitions.
+ *
+ * This module provides a way to automatically construct decoders for ink contract
+ * message return types without manually specifying codecs for each message.
+ */
+
+import {
+  u8,
+  u16,
+  u32,
+  u64,
+  u128,
+  i8,
+  i16,
+  i32,
+  i64,
+  i128,
+  bool,
+  str,
+  Bytes,
+  Vector,
+  Tuple,
+  Struct,
+  Variant,
+  _void,
+  Option,
+  AccountId,
+  type Codec,
+} from "@polkadot-api/substrate-bindings";
+import type { InkMetadata } from "@polkadot-api/ink-contracts";
+import { blake2b } from "@noble/hashes/blake2.js";
+
+// Use 'any' for dynamic codec building to avoid TypeScript strict type issues
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyCodec = Codec<any>;
+
+/**
+ * Type definition from ink metadata
+ */
+interface TypeDef {
+  primitive?: string;
+  composite?: {
+    fields: Array<{
+      name?: string;
+      type: number;
+      typeName?: string;
+    }>;
+  };
+  variant?: {
+    variants: Array<{
+      name: string;
+      index: number;
+      fields: Array<{
+        name?: string;
+        type: number;
+        typeName?: string;
+      }>;
+    }>;
+  };
+  sequence?: {
+    type: number;
+  };
+  array?: {
+    len: number;
+    type: number;
+  };
+  tuple?: number[];
+}
+
+interface TypeEntry {
+  id: number;
+  type: {
+    def: TypeDef;
+    path?: string[];
+    params?: Array<{
+      name: string;
+      type?: number;
+    }>;
+  };
+}
+
+/**
+ * Cache for built codecs to avoid rebuilding the same type
+ */
+type CodecCache = Map<number, AnyCodec>;
+
+/**
+ * Build a SCALE codec from ink metadata type definition
+ */
+function buildCodecFromType(
+  typeId: number,
+  types: TypeEntry[],
+  cache: CodecCache,
+): AnyCodec {
+  // Check cache first
+  const cached = cache.get(typeId);
+  if (cached) {
+    return cached;
+  }
+
+  const typeEntry = types.find((t) => t.id === typeId);
+  if (!typeEntry) {
+    throw new Error(`Type ${typeId} not found in metadata`);
+  }
+
+  const def = typeEntry.type.def;
+  const path = typeEntry.type.path;
+
+  // Handle primitive types
+  if (def.primitive) {
+    const codec = buildPrimitiveCodec(def.primitive);
+    cache.set(typeId, codec);
+    return codec;
+  }
+
+  // Handle special path types (AccountId, Hash, etc.)
+  if (path && path.length > 0) {
+    const specialCodec = buildSpecialTypeCodec(path, typeEntry, types, cache);
+    if (specialCodec) {
+      cache.set(typeId, specialCodec);
+      return specialCodec;
+    }
+  }
+
+  // Handle tuple
+  if (def.tuple) {
+    const codec = buildTupleCodec(def.tuple, types, cache);
+    cache.set(typeId, codec);
+    return codec;
+  }
+
+  // Handle sequence (Vec<T>)
+  if (def.sequence) {
+    const innerCodec = buildCodecFromType(def.sequence.type, types, cache);
+    const codec = Vector(innerCodec);
+    cache.set(typeId, codec);
+    return codec;
+  }
+
+  // Handle array [T; N]
+  if (def.array) {
+    const innerCodec = buildCodecFromType(def.array.type, types, cache);
+    // For fixed-size byte arrays, use Bytes
+    if (def.array.type === findPrimitiveTypeId(types, "u8")) {
+      const codec = Bytes(def.array.len);
+      cache.set(typeId, codec);
+      return codec;
+    }
+    // For other arrays, use Vector with fixed length validation
+    const codec = Vector(innerCodec, def.array.len);
+    cache.set(typeId, codec);
+    return codec;
+  }
+
+  // Handle composite (struct)
+  if (def.composite) {
+    const codec = buildCompositeCodec(def.composite, types, cache);
+    cache.set(typeId, codec);
+    return codec;
+  }
+
+  // Handle variant (enum)
+  if (def.variant) {
+    const codec = buildVariantCodec(def.variant, path, types, cache);
+    cache.set(typeId, codec);
+    return codec;
+  }
+
+  throw new Error(
+    `Unknown type definition for type ${typeId}: ${JSON.stringify(def)}`,
+  );
+}
+
+/**
+ * Build codec for primitive types
+ */
+function buildPrimitiveCodec(primitive: string): AnyCodec {
+  switch (primitive) {
+    case "u8":
+      return u8;
+    case "u16":
+      return u16;
+    case "u32":
+      return u32;
+    case "u64":
+      return u64;
+    case "u128":
+      return u128;
+    case "i8":
+      return i8;
+    case "i16":
+      return i16;
+    case "i32":
+      return i32;
+    case "i64":
+      return i64;
+    case "i128":
+      return i128;
+    case "bool":
+      return bool;
+    case "str":
+      return str;
+    default:
+      throw new Error(`Unknown primitive type: ${primitive}`);
+  }
+}
+
+/**
+ * Build codec for special types based on path
+ */
+function buildSpecialTypeCodec(
+  path: string[],
+  typeEntry: TypeEntry,
+  types: TypeEntry[],
+  cache: CodecCache,
+): AnyCodec | null {
+  const fullPath = path.join("::");
+
+  // AccountId type
+  if (fullPath.includes("AccountId")) {
+    return AccountId();
+  }
+
+  // Option type
+  if (path[0] === "Option") {
+    const params = typeEntry.type.params;
+    if (params && params.length > 0 && params[0]?.type !== undefined) {
+      const innerCodec = buildCodecFromType(params[0].type, types, cache);
+      return Option(innerCodec);
+    }
+  }
+
+  // Result type - we need special handling
+  if (path[0] === "Result") {
+    const params = typeEntry.type.params;
+    if (params && params.length >= 2) {
+      const okTypeId = params[0]?.type;
+      const errTypeId = params[1]?.type;
+      if (okTypeId !== undefined && errTypeId !== undefined) {
+        const okCodec = buildCodecFromType(okTypeId, types, cache);
+        const errCodec = buildCodecFromType(errTypeId, types, cache);
+        // Build a proper Result variant
+        return Variant(
+          {
+            Ok: okCodec,
+            Err: errCodec,
+          },
+          [0, 1],
+        );
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Build codec for tuple types
+ */
+function buildTupleCodec(
+  tupleTypes: number[],
+  types: TypeEntry[],
+  cache: CodecCache,
+): AnyCodec {
+  if (tupleTypes.length === 0) {
+    return _void;
+  }
+
+  const innerCodecs = tupleTypes.map((t) => buildCodecFromType(t, types, cache));
+
+  // Handle different tuple sizes
+  switch (innerCodecs.length) {
+    case 1:
+      return Tuple(innerCodecs[0]!);
+    case 2:
+      return Tuple(innerCodecs[0]!, innerCodecs[1]!);
+    case 3:
+      return Tuple(innerCodecs[0]!, innerCodecs[1]!, innerCodecs[2]!);
+    case 4:
+      return Tuple(
+        innerCodecs[0]!,
+        innerCodecs[1]!,
+        innerCodecs[2]!,
+        innerCodecs[3]!,
+      );
+    default:
+      // For larger tuples, use dynamic tuple (cast to any)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return (Tuple as any)(...innerCodecs);
+  }
+}
+
+/**
+ * Build codec for composite (struct) types
+ */
+function buildCompositeCodec(
+  composite: NonNullable<TypeDef["composite"]>,
+  types: TypeEntry[],
+  cache: CodecCache,
+): AnyCodec {
+  const fields = composite.fields;
+
+  // Single unnamed field - unwrap it
+  if (fields.length === 1 && !fields[0]?.name) {
+    return buildCodecFromType(fields[0]!.type, types, cache);
+  }
+
+  // Multiple fields - build a struct
+  const structDef: Record<string, AnyCodec> = {};
+  for (const field of fields) {
+    const fieldName = field.name || `field${fields.indexOf(field)}`;
+    structDef[fieldName] = buildCodecFromType(field.type, types, cache);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return Struct(structDef as any);
+}
+
+/**
+ * Build codec for variant (enum) types
+ */
+function buildVariantCodec(
+  variant: NonNullable<TypeDef["variant"]>,
+  path: string[] | undefined,
+  types: TypeEntry[],
+  cache: CodecCache,
+): AnyCodec {
+  const variants = variant.variants;
+
+  // Check if this is a LangError type (ink specific)
+  const isLangError = path?.includes("LangError");
+
+  // Build variant definition
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const variantDef: Record<string, any> = {};
+  const indices: number[] = [];
+
+  // For LangError, add a placeholder for index 0 if missing
+  if (isLangError && !variants.some((v) => v.index === 0)) {
+    variantDef["_Placeholder"] = _void;
+    indices.push(0);
+  }
+
+  for (const v of variants) {
+    let fieldCodec: AnyCodec;
+
+    // Handle variants with no fields or undefined fields
+    const fields = v.fields ?? [];
+
+    if (fields.length === 0) {
+      fieldCodec = _void;
+    } else if (fields.length === 1 && !fields[0]?.name) {
+      // Single unnamed field
+      fieldCodec = buildCodecFromType(fields[0]!.type, types, cache);
+    } else {
+      // Multiple or named fields - build struct
+      const structDef: Record<string, AnyCodec> = {};
+      for (const field of fields) {
+        const fieldName = field.name || `field${fields.indexOf(field)}`;
+        structDef[fieldName] = buildCodecFromType(field.type, types, cache);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      fieldCodec = Struct(structDef as any);
+    }
+
+    variantDef[v.name] = fieldCodec;
+    indices.push(v.index);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return Variant(variantDef as any, indices as any);
+}
+
+/**
+ * Find the type ID for a primitive type
+ */
+function findPrimitiveTypeId(types: TypeEntry[], primitive: string): number {
+  const entry = types.find((t) => t.type.def.primitive === primitive);
+  return entry?.id ?? -1;
+}
+
+/**
+ * Extract the inner type from Result<T, LangError>
+ * Returns the type ID of T
+ */
+function extractResultInnerType(typeEntry: TypeEntry): number | null {
+  const path = typeEntry.type.path;
+  if (!path || path[0] !== "Result") {
+    return null;
+  }
+
+  const params = typeEntry.type.params;
+  if (!params || params.length < 1) {
+    return null;
+  }
+
+  return params[0]?.type ?? null;
+}
+
+/**
+ * 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
+ */
+export function buildMessageDecoder(
+  metadata: InkMetadata,
+  messageLabel: string,
+): (data: Uint8Array) => unknown {
+  const types = metadata.types as TypeEntry[];
+  const message = metadata.spec.messages.find((m) => m.label === messageLabel);
+
+  if (!message) {
+    throw new Error(`Message "${messageLabel}" not found in metadata`);
+  }
+
+  const returnTypeId = message.returnType.type;
+  const returnTypeEntry = types.find((t) => t.id === returnTypeId);
+
+  if (!returnTypeEntry) {
+    throw new Error(
+      `Return type ${returnTypeId} not found for message "${messageLabel}"`,
+    );
+  }
+
+  const cache: CodecCache = new Map();
+
+  // Check if it's a Result type and extract inner type
+  const innerTypeId = extractResultInnerType(returnTypeEntry);
+
+  if (innerTypeId !== null) {
+    // Build decoder for the inner type (T in Result<T, LangError>)
+    const innerCodec = buildCodecFromType(innerTypeId, types, cache);
+    return (data: Uint8Array) => innerCodec.dec(data);
+  }
+
+  // Not a Result type, build decoder for the full return type
+  const codec = buildCodecFromType(returnTypeId, types, cache);
+  return (data: Uint8Array) => codec.dec(data);
+}
+
+/**
+ * Build decoders for all messages in the metadata.
+ * Returns a Map of message label -> decoder function.
+ */
+export function buildAllMessageDecoders(
+  metadata: InkMetadata,
+): Map<string, (data: Uint8Array) => unknown> {
+  const decoders = new Map<string, (data: Uint8Array) => unknown>();
+
+  for (const message of metadata.spec.messages as Array<{ label: string }>) {
+    try {
+      const decoder = buildMessageDecoder(metadata, message.label);
+      decoders.set(message.label, decoder);
+    } catch (error) {
+      console.warn(
+        `Failed to build decoder for message "${message.label}":`,
+        error,
+      );
+    }
+  }
+
+  return decoders;
+}
+
+/**
+ * Create a codec registry compatible with ResponseDecoder type
+ */
+export function createCodecRegistry(
+  metadata: InkMetadata,
+): Map<string, { dec: (data: Uint8Array) => unknown }> {
+  const decoders = buildAllMessageDecoders(metadata);
+  const registry = new Map<string, { dec: (data: Uint8Array) => unknown }>();
+
+  for (const [label, decoder] of decoders) {
+    registry.set(label, { dec: decoder });
+  }
+
+  return registry;
+}
+
+/**
+ * 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
+ */
+export function buildEventDecoder(
+  metadata: InkMetadata,
+  eventLabel: string,
+): (data: Uint8Array) => unknown {
+  const types = metadata.types as TypeEntry[];
+  const events = metadata.spec.events as Array<{
+    label: string;
+    args: Array<{
+      label: string;
+      type: { type: number };
+    }>;
+  }>;
+
+  const event = events.find((e) => e.label === eventLabel);
+
+  if (!event) {
+    throw new Error(`Event "${eventLabel}" not found in metadata`);
+  }
+
+  const cache: CodecCache = new Map();
+
+  // Build struct codec from event args
+  const structDef: Record<string, AnyCodec> = {};
+
+  for (const arg of event.args) {
+    const fieldName = arg.label;
+    const fieldCodec = buildCodecFromType(arg.type.type, types, cache);
+    structDef[fieldName] = fieldCodec;
+  }
+
+  // If event has no args, return void decoder
+  if (event.args.length === 0) {
+    return () => undefined;
+  }
+
+  // If event has single unnamed arg, unwrap it
+  if (event.args.length === 1) {
+    const argCodec = structDef[event.args[0]!.label];
+    return (data: Uint8Array) => argCodec!.dec(data);
+  }
+
+  // Multiple args - return struct
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const codec = Struct(structDef as any);
+  return (data: Uint8Array) => codec.dec(data);
+}
+
+/**
+ * Build decoders for all events in the metadata
+ *
+ * @param metadata - The ink contract metadata
+ * @returns Map of event label -> decoder function
+ */
+export function buildAllEventDecoders(
+  metadata: InkMetadata,
+): Map<string, (data: Uint8Array) => unknown> {
+  const decoders = new Map<string, (data: Uint8Array) => unknown>();
+
+  const events = metadata.spec.events as Array<{ label: string }>;
+
+  for (const event of events) {
+    try {
+      const decoder = buildEventDecoder(metadata, event.label);
+      decoders.set(event.label, decoder);
+    } catch (error) {
+      console.warn(`Failed to build decoder for event "${event.label}":`, error);
+    }
+  }
+
+  return decoders;
+}
+
+/**
+ * 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)
+ */
+export function getEventSignature(eventLabel: string): Uint8Array {
+  return blake2b(new TextEncoder().encode(eventLabel), { dkLen: 32 });
+}