@d9-network/spec 0.0.12 → 0.0.13

package/dist/index.d.cts

@@ -9,12 +9,12 @@ import { KeyPair } from "@polkadot-labs/hdkd-helpers";
 //#region rolldown:runtime
 //#endregion
 //#region ../../node_modules/.bun/@polkadot-api+descriptors@file+packages+spec+.papi+descriptors+14313b0e56f5ab4e/node_modules/@polkadot-api/descriptors/dist/common-types.d.ts
-type AnonymousEnum$9<T extends {}> = T & {
+type AnonymousEnum$9<T$1 extends {}> = T$1 & {
   __anonymous: true;
 };
-type MyTuple$9<T> = [T, ...T[]];
-type SeparateUndefined$9<T> = undefined extends T ? undefined | Exclude<T, undefined> : T;
-type Anonymize$9<T> = SeparateUndefined$9<T extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T : T extends AnonymousEnum$9<infer V> ? Enum<V> : T extends MyTuple$9<any> ? { [K in keyof T]: T[K] } : T extends [] ? [] : T extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T> : FixedSizeArray<L, T> : { [K in keyof T & string]: T[K] }>;
+type MyTuple$9<T$1> = [T$1, ...T$1[]];
+type SeparateUndefined$9<T$1> = undefined extends T$1 ? undefined | Exclude<T$1, undefined> : T$1;
+type Anonymize$9<T$1> = SeparateUndefined$9<T$1 extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T$1 extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T$1 : T$1 extends AnonymousEnum$9<infer V> ? Enum<V> : T$1 extends MyTuple$9<any> ? { [K in keyof T$1]: T$1[K] } : T$1 extends [] ? [] : T$1 extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T$1> : FixedSizeArray<L, T$1> : { [K in keyof T$1 & string]: T$1[K] }>;
 type Ic5m5lp1oioo8r = Array<FixedSizeBinary<32>>;
 type Ihfphjolmsqq1 = (SS58String$1) | undefined;
 type Idrurqd6ddlmr3 = {
@@ -3376,12 +3376,12 @@ type I1q6j2f64t5q87 = {
 };
 //#endregion
 //#region ../../node_modules/.bun/@polkadot-api+descriptors@file+packages+spec+.papi+descriptors+14313b0e56f5ab4e/node_modules/@polkadot-api/descriptors/dist/d9.d.ts
-type AnonymousEnum$8<T extends {}> = T & {
+type AnonymousEnum$8<T$1 extends {}> = T$1 & {
   __anonymous: true;
 };
-type MyTuple$8<T> = [T, ...T[]];
-type SeparateUndefined$8<T> = undefined extends T ? undefined | Exclude<T, undefined> : T;
-type Anonymize$8<T> = SeparateUndefined$8<T extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T : T extends AnonymousEnum$8<infer V> ? Enum<V> : T extends MyTuple$8<any> ? { [K in keyof T]: T[K] } : T extends [] ? [] : T extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T> : FixedSizeArray<L, T> : { [K in keyof T & string]: T[K] }>;
+type MyTuple$8<T$1> = [T$1, ...T$1[]];
+type SeparateUndefined$8<T$1> = undefined extends T$1 ? undefined | Exclude<T$1, undefined> : T$1;
+type Anonymize$8<T$1> = SeparateUndefined$8<T$1 extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T$1 extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T$1 : T$1 extends AnonymousEnum$8<infer V> ? Enum<V> : T$1 extends MyTuple$8<any> ? { [K in keyof T$1]: T$1[K] } : T$1 extends [] ? [] : T$1 extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T$1> : FixedSizeArray<L, T$1> : { [K in keyof T$1 & string]: T$1[K] }>;
 type IStorage = {
   Aura: {
     /**
@@ -6713,12 +6713,12 @@ type PalletKey = `*.${({ [K in keyof AllInteractions]: K extends 'apis' ? never
 type NestedKey<D extends Record<string, string[]>> = "*" | { [P in keyof D & string]: `${P}.*` | `${P}.${D[P][number]}` }[keyof D & string];
 //#endregion
 //#region ../../node_modules/.bun/@polkadot-api+descriptors@file+packages+spec+.papi+descriptors+14313b0e56f5ab4e/node_modules/@polkadot-api/descriptors/dist/contracts/nodeReward.d.ts
-type AnonymousEnum$7<T extends {}> = T & {
+type AnonymousEnum$7<T$1 extends {}> = T$1 & {
   __anonymous: true;
 };
-type MyTuple$7<T> = [T, ...T[]];
-type SeparateUndefined$7<T> = undefined extends T ? undefined | Exclude<T, undefined> : T;
-type Anonymize$7<T> = SeparateUndefined$7<T extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T : T extends AnonymousEnum$7<infer V> ? Enum<V> : T extends MyTuple$7<any> ? { [K in keyof T]: T[K] } : T extends [] ? [] : T extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T> : FixedSizeArray<L, T> : { [K in keyof T & string]: T[K] }>;
+type MyTuple$7<T$1> = [T$1, ...T$1[]];
+type SeparateUndefined$7<T$1> = undefined extends T$1 ? undefined | Exclude<T$1, undefined> : T$1;
+type Anonymize$7<T$1> = SeparateUndefined$7<T$1 extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T$1 extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T$1 : T$1 extends AnonymousEnum$7<infer V> ? Enum<V> : T$1 extends MyTuple$7<any> ? { [K in keyof T$1]: T$1[K] } : T$1 extends [] ? [] : T$1 extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T$1> : FixedSizeArray<L, T$1> : { [K in keyof T$1 & string]: T$1[K] }>;
 type T0$7 = ResultPayload<undefined, Anonymize$7<T1$7>>;
 type T1$7 = Enum<{
   "CouldNotReadInput": undefined;
@@ -6880,12 +6880,12 @@ type EventDescriptor$7 = Enum<{
 declare const descriptor$7: InkDescriptors<StorageDescriptor$8, MessagesDescriptor$7, ConstructorsDescriptor$7, EventDescriptor$7>;
 //#endregion
 //#region ../../node_modules/.bun/@polkadot-api+descriptors@file+packages+spec+.papi+descriptors+14313b0e56f5ab4e/node_modules/@polkadot-api/descriptors/dist/contracts/merchantMining.d.ts
-type AnonymousEnum$6<T extends {}> = T & {
+type AnonymousEnum$6<T$1 extends {}> = T$1 & {
   __anonymous: true;
 };
-type MyTuple$6<T> = [T, ...T[]];
-type SeparateUndefined$6<T> = undefined extends T ? undefined | Exclude<T, undefined> : T;
-type Anonymize$6<T> = SeparateUndefined$6<T extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T : T extends AnonymousEnum$6<infer V> ? Enum<V> : T extends MyTuple$6<any> ? { [K in keyof T]: T[K] } : T extends [] ? [] : T extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T> : FixedSizeArray<L, T> : { [K in keyof T & string]: T[K] }>;
+type MyTuple$6<T$1> = [T$1, ...T$1[]];
+type SeparateUndefined$6<T$1> = undefined extends T$1 ? undefined | Exclude<T$1, undefined> : T$1;
+type Anonymize$6<T$1> = SeparateUndefined$6<T$1 extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T$1 extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T$1 : T$1 extends AnonymousEnum$6<infer V> ? Enum<V> : T$1 extends MyTuple$6<any> ? { [K in keyof T$1]: T$1[K] } : T$1 extends [] ? [] : T$1 extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T$1> : FixedSizeArray<L, T$1> : { [K in keyof T$1 & string]: T$1[K] }>;
 type T0$6 = ResultPayload<undefined, Anonymize$6<T1$6>>;
 type T1$6 = Enum<{
   "CouldNotReadInput": undefined;
@@ -7138,12 +7138,12 @@ type EventDescriptor$6 = Enum<{
 declare const descriptor$6: InkDescriptors<StorageDescriptor$7, MessagesDescriptor$6, ConstructorsDescriptor$6, EventDescriptor$6>;
 //#endregion
 //#region ../../node_modules/.bun/@polkadot-api+descriptors@file+packages+spec+.papi+descriptors+14313b0e56f5ab4e/node_modules/@polkadot-api/descriptors/dist/contracts/usdt.d.ts
-type AnonymousEnum$5<T extends {}> = T & {
+type AnonymousEnum$5<T$1 extends {}> = T$1 & {
   __anonymous: true;
 };
-type MyTuple$5<T> = [T, ...T[]];
-type SeparateUndefined$5<T> = undefined extends T ? undefined | Exclude<T, undefined> : T;
-type Anonymize$5<T> = SeparateUndefined$5<T extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T : T extends AnonymousEnum$5<infer V> ? Enum<V> : T extends MyTuple$5<any> ? { [K in keyof T]: T[K] } : T extends [] ? [] : T extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T> : FixedSizeArray<L, T> : { [K in keyof T & string]: T[K] }>;
+type MyTuple$5<T$1> = [T$1, ...T$1[]];
+type SeparateUndefined$5<T$1> = undefined extends T$1 ? undefined | Exclude<T$1, undefined> : T$1;
+type Anonymize$5<T$1> = SeparateUndefined$5<T$1 extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T$1 extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T$1 : T$1 extends AnonymousEnum$5<infer V> ? Enum<V> : T$1 extends MyTuple$5<any> ? { [K in keyof T$1]: T$1[K] } : T$1 extends [] ? [] : T$1 extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T$1> : FixedSizeArray<L, T$1> : { [K in keyof T$1 & string]: T$1[K] }>;
 type T0$5 = Enum<{
   "CouldNotReadInput": undefined;
 }>;
@@ -7278,12 +7278,12 @@ type EventDescriptor$5 = Enum<{
 declare const descriptor$5: InkDescriptors<StorageDescriptor$6, MessagesDescriptor$5, ConstructorsDescriptor$5, EventDescriptor$5>;
 //#endregion
 //#region ../../node_modules/.bun/@polkadot-api+descriptors@file+packages+spec+.papi+descriptors+14313b0e56f5ab4e/node_modules/@polkadot-api/descriptors/dist/contracts/burnManager.d.ts
-type AnonymousEnum$4<T extends {}> = T & {
+type AnonymousEnum$4<T$1 extends {}> = T$1 & {
   __anonymous: true;
 };
-type MyTuple$4<T> = [T, ...T[]];
-type SeparateUndefined$4<T> = undefined extends T ? undefined | Exclude<T, undefined> : T;
-type Anonymize$4<T> = SeparateUndefined$4<T extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T : T extends AnonymousEnum$4<infer V> ? Enum<V> : T extends MyTuple$4<any> ? { [K in keyof T]: T[K] } : T extends [] ? [] : T extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T> : FixedSizeArray<L, T> : { [K in keyof T & string]: T[K] }>;
+type MyTuple$4<T$1> = [T$1, ...T$1[]];
+type SeparateUndefined$4<T$1> = undefined extends T$1 ? undefined | Exclude<T$1, undefined> : T$1;
+type Anonymize$4<T$1> = SeparateUndefined$4<T$1 extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T$1 extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T$1 : T$1 extends AnonymousEnum$4<infer V> ? Enum<V> : T$1 extends MyTuple$4<any> ? { [K in keyof T$1]: T$1[K] } : T$1 extends [] ? [] : T$1 extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T$1> : FixedSizeArray<L, T$1> : { [K in keyof T$1 & string]: T$1[K] }>;
 type T0$4 = Array<SS58String$1>;
 type T1$4 = ResultPayload<undefined, Anonymize$4<T2$4>>;
 type T2$4 = Enum<{
@@ -7456,12 +7456,12 @@ type EventDescriptor$4 = Enum<{
 declare const descriptor$4: InkDescriptors<StorageDescriptor$5, MessagesDescriptor$4, ConstructorsDescriptor$4, EventDescriptor$4>;
 //#endregion
 //#region ../../node_modules/.bun/@polkadot-api+descriptors@file+packages+spec+.papi+descriptors+14313b0e56f5ab4e/node_modules/@polkadot-api/descriptors/dist/contracts/crossChainTransfer.d.ts
-type AnonymousEnum$3<T extends {}> = T & {
+type AnonymousEnum$3<T$1 extends {}> = T$1 & {
   __anonymous: true;
 };
-type MyTuple$3<T> = [T, ...T[]];
-type SeparateUndefined$3<T> = undefined extends T ? undefined | Exclude<T, undefined> : T;
-type Anonymize$3<T> = SeparateUndefined$3<T extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T : T extends AnonymousEnum$3<infer V> ? Enum<V> : T extends MyTuple$3<any> ? { [K in keyof T]: T[K] } : T extends [] ? [] : T extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T> : FixedSizeArray<L, T> : { [K in keyof T & string]: T[K] }>;
+type MyTuple$3<T$1> = [T$1, ...T$1[]];
+type SeparateUndefined$3<T$1> = undefined extends T$1 ? undefined | Exclude<T$1, undefined> : T$1;
+type Anonymize$3<T$1> = SeparateUndefined$3<T$1 extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T$1 extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T$1 : T$1 extends AnonymousEnum$3<infer V> ? Enum<V> : T$1 extends MyTuple$3<any> ? { [K in keyof T$1]: T$1[K] } : T$1 extends [] ? [] : T$1 extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T$1> : FixedSizeArray<L, T$1> : { [K in keyof T$1 & string]: T$1[K] }>;
 type T5$2 = Array<SS58String$1>;
 type T0$3 = ResultPayload<undefined, Anonymize$3<T1$3>>;
 type T1$3 = Enum<{
@@ -7700,12 +7700,12 @@ type EventDescriptor$3 = Enum<{
 declare const descriptor$3: InkDescriptors<StorageDescriptor$4, MessagesDescriptor$3, ConstructorsDescriptor$3, EventDescriptor$3>;
 //#endregion
 //#region ../../node_modules/.bun/@polkadot-api+descriptors@file+packages+spec+.papi+descriptors+14313b0e56f5ab4e/node_modules/@polkadot-api/descriptors/dist/contracts/marketMaker.d.ts
-type AnonymousEnum$2<T extends {}> = T & {
+type AnonymousEnum$2<T$1 extends {}> = T$1 & {
   __anonymous: true;
 };
-type MyTuple$2<T> = [T, ...T[]];
-type SeparateUndefined$2<T> = undefined extends T ? undefined | Exclude<T, undefined> : T;
-type Anonymize$2<T> = SeparateUndefined$2<T extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T : T extends AnonymousEnum$2<infer V> ? Enum<V> : T extends MyTuple$2<any> ? { [K in keyof T]: T[K] } : T extends [] ? [] : T extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T> : FixedSizeArray<L, T> : { [K in keyof T & string]: T[K] }>;
+type MyTuple$2<T$1> = [T$1, ...T$1[]];
+type SeparateUndefined$2<T$1> = undefined extends T$1 ? undefined | Exclude<T$1, undefined> : T$1;
+type Anonymize$2<T$1> = SeparateUndefined$2<T$1 extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T$1 extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T$1 : T$1 extends AnonymousEnum$2<infer V> ? Enum<V> : T$1 extends MyTuple$2<any> ? { [K in keyof T$1]: T$1[K] } : T$1 extends [] ? [] : T$1 extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T$1> : FixedSizeArray<L, T$1> : { [K in keyof T$1 & string]: T$1[K] }>;
 type T0$2 = ResultPayload<undefined, Anonymize$2<T1$2>>;
 type T1$2 = Enum<{
   "CouldNotReadInput": undefined;
@@ -7904,12 +7904,12 @@ type EventDescriptor$2 = Enum<{
 declare const descriptor$2: InkDescriptors<StorageDescriptor$3, MessagesDescriptor$2, ConstructorsDescriptor$2, EventDescriptor$2>;
 //#endregion
 //#region ../../node_modules/.bun/@polkadot-api+descriptors@file+packages+spec+.papi+descriptors+14313b0e56f5ab4e/node_modules/@polkadot-api/descriptors/dist/contracts/burnMining.d.ts
-type AnonymousEnum$1<T extends {}> = T & {
+type AnonymousEnum$1<T$1 extends {}> = T$1 & {
   __anonymous: true;
 };
-type MyTuple$1<T> = [T, ...T[]];
-type SeparateUndefined$1<T> = undefined extends T ? undefined | Exclude<T, undefined> : T;
-type Anonymize$1<T> = SeparateUndefined$1<T extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T : T extends AnonymousEnum$1<infer V> ? Enum<V> : T extends MyTuple$1<any> ? { [K in keyof T]: T[K] } : T extends [] ? [] : T extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T> : FixedSizeArray<L, T> : { [K in keyof T & string]: T[K] }>;
+type MyTuple$1<T$1> = [T$1, ...T$1[]];
+type SeparateUndefined$1<T$1> = undefined extends T$1 ? undefined | Exclude<T$1, undefined> : T$1;
+type Anonymize$1<T$1> = SeparateUndefined$1<T$1 extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T$1 extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T$1 : T$1 extends AnonymousEnum$1<infer V> ? Enum<V> : T$1 extends MyTuple$1<any> ? { [K in keyof T$1]: T$1[K] } : T$1 extends [] ? [] : T$1 extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T$1> : FixedSizeArray<L, T$1> : { [K in keyof T$1 & string]: T$1[K] }>;
 type T0$1 = ResultPayload<undefined, Anonymize$1<T1$1>>;
 type T1$1 = Enum<{
   "CouldNotReadInput": undefined;
@@ -8083,12 +8083,12 @@ type EventDescriptor$1 = Enum<{}>;
 declare const descriptor$1: InkDescriptors<StorageDescriptor$2, MessagesDescriptor$1, ConstructorsDescriptor$1, EventDescriptor$1>;
 //#endregion
 //#region ../../node_modules/.bun/@polkadot-api+descriptors@file+packages+spec+.papi+descriptors+14313b0e56f5ab4e/node_modules/@polkadot-api/descriptors/dist/contracts/miningPool.d.ts
-type AnonymousEnum<T extends {}> = T & {
+type AnonymousEnum<T$1 extends {}> = T$1 & {
   __anonymous: true;
 };
-type MyTuple<T> = [T, ...T[]];
-type SeparateUndefined<T> = undefined extends T ? undefined | Exclude<T, undefined> : T;
-type Anonymize<T> = SeparateUndefined<T extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T : T extends AnonymousEnum<infer V> ? Enum<V> : T extends MyTuple<any> ? { [K in keyof T]: T[K] } : T extends [] ? [] : T extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T> : FixedSizeArray<L, T> : { [K in keyof T & string]: T[K] }>;
+type MyTuple<T$1> = [T$1, ...T$1[]];
+type SeparateUndefined<T$1> = undefined extends T$1 ? undefined | Exclude<T$1, undefined> : T$1;
+type Anonymize<T$1> = SeparateUndefined<T$1 extends FixedSizeBinary<infer L> ? number extends L ? Binary : FixedSizeBinary<L> : T$1 extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T$1 : T$1 extends AnonymousEnum<infer V> ? Enum<V> : T$1 extends MyTuple<any> ? { [K in keyof T$1]: T$1[K] } : T$1 extends [] ? [] : T$1 extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T$1> : FixedSizeArray<L, T$1> : { [K in keyof T$1 & string]: T$1[K] }>;
 type T0 = ResultPayload<undefined, Anonymize<T1>>;
 type T1 = Enum<{
   "CouldNotReadInput": undefined;
@@ -8300,13 +8300,37 @@ interface RawContractEvent {
   topics: Uint8Array[];
 }
 /**
- * Decoded contract event
+ * Extract the definition object from an Enum type or InkEvent type
+ * e.g. ExtractEnumDef<Enum<{A: X, B: Y}>> = {A: X, B: Y}
+ *
+ * For non-Enum types (e.g., InkEvent { type: string; value: unknown }),
+ * returns a generic event definition.
+ */
+
+/**
+ * Type-safe contract event with discriminated union
+ * Enables type narrowing: `if (event.type === "Transfer") { event.value.from }`
+ */
+type TypedContractEvent<E extends Event> = E extends Enum<infer T> ? { [K in keyof T & string]: {
+  /** Event type (discriminant for type narrowing) */
+  type: K;
+  /** Decoded event data (type-safe based on event type) */
+  value: T[K];
+  /** Original raw event */
+  raw: RawContractEvent;
+} }[keyof T & string] : {
+  type: string;
+  value: unknown;
+  raw: RawContractEvent;
+};
+/**
+ * Decoded contract event (legacy, use TypedContractEvent for type safety)
  */
-interface DecodedContractEvent<T = unknown> {
+interface DecodedContractEvent<T$1 = unknown> {
   /** Event label from metadata (e.g., "Transfer", "Approval") */
   label: string;
   /** Decoded event data */
-  data: T;
+  data: T$1;
   /** Original raw event */
   raw: RawContractEvent;
 }
@@ -8323,6 +8347,20 @@ interface EventFilterOptions {
   /** To block number (inclusive) */
   toBlock?: number;
 }
+/**
+ * Type-safe event filter options with literal event labels
+ * Provides compile-time validation of event label names
+ *
+ * @typeParam E - The event type representing all possible events
+ *
+ * @example
+ * ```ts
+ * const options: TypedEventFilterOptions<typeof contracts.usdt.__types.event> = {
+ *   eventLabels: ["Transfer", "Approval"], // Must be valid event names
+ * };
+ * ```
+ */
+
 /**
  * Event subscription options
  */
@@ -8350,9 +8388,76 @@ interface EventSubscriptionOptions {
   getEvents: (blockHash: string) => Promise<unknown[]>;
 }
 //#endregion
-//#region src/types.d.ts
+//#region src/call-types.d.ts
+/**
+ * Raw call data from a transaction
+ */
+
+/**
+ * Extract message labels as a union type from InkCallableDescriptor
+ * e.g. ExtractMessageLabels<Messages> = "PSP22::transfer" | "PSP22::balance_of" | ...
+ */
+type ExtractMessageLabels<M$1 extends InkCallableDescriptor> = keyof M$1 & string;
+/**
+ * Type-safe parsed contract call with discriminated union
+ * Enables type narrowing: `if (call.type === "PSP22::transfer") { call.args.to }`
+ */
+
+//#endregion
+//#region src/message-builder.d.ts
+/**
+ * Message attributes from metadata
+ */
+interface MessageAttributes {
+  /** Whether the message mutates state */
+  mutates: boolean;
+  /** Whether the message is payable */
+  payable: boolean;
+  /** Whether this is the default message */
+  default: boolean;
+}
+/**
+ * Type-safe message interface with encode/decode methods
+ *
+ * @typeParam M - The InkCallableDescriptor type (message definitions)
+ * @typeParam L - The specific message label
+ */
+interface TypedMessage<M$1 extends InkCallableDescriptor, L$1 extends keyof M$1 & string> {
+  /**
+   * Encode message arguments to Binary
+   *
+   * @param args - The message arguments (fully typed)
+   * @returns Encoded call data as Binary
+   *
+   * @example
+   * ```ts
+   * const transfer = builder.message("PSP22::transfer");
+   * const encoded = transfer.encode({
+   *   to: recipientAddress,
+   *   value: 1000n,
+   *   data: new Uint8Array(),
+   * });
+   * ```
+   */
+  encode: {} extends M$1[L$1]["message"] ? (args?: M$1[L$1]["message"]) => Binary : (args: M$1[L$1]["message"]) => Binary;
+  /**
+   * Decode response to typed value
+   *
+   * @param response - The response data
+   * @returns Decoded response value
+   */
+  decode: (response: Binary | Uint8Array) => M$1[L$1]["response"];
+  /** Message attributes (mutates, payable, default) */
+  attributes: MessageAttributes;
+  /** 4-byte selector */
+  selector: Uint8Array;
+  /** Message label */
+  label: L$1;
+}
 /**
- * Decoder type for response decoding
+ * Contract message builder interface
+ *
+ * @typeParam M - The InkCallableDescriptor type (message definitions)
  */
 
 /**
@@ -8393,16 +8498,16 @@ interface SendOptions<Args = unknown> {
 /**
  * Sendable transaction that can be signed and submitted
  */
-interface SendableTransaction<T> {
+interface SendableTransaction<T$1> {
   /** Sign and submit the transaction */
-  signAndSubmit(signer: PolkadotSigner$1): Promise<TxResult<T>>;
+  signAndSubmit(signer: PolkadotSigner$1): Promise<TxResult<T$1>>;
   /** Get the encoded call data */
   getEncodedData(): Uint8Array;
 }
 /**
  * Transaction result
  */
-interface TxResult<T> {
+interface TxResult<T$1> {
   /** Whether the transaction was successful */
   ok: boolean;
   /** Transaction hash */
@@ -8413,7 +8518,7 @@ interface TxResult<T> {
     number: number;
   };
   /** Decoded return value (if any) */
-  result?: T;
+  result?: T$1;
   /** Events emitted by the transaction */
   events: unknown[];
   /** Dispatch error if failed */
@@ -8422,9 +8527,9 @@ interface TxResult<T> {
 /**
  * Successful query result value
  */
-interface QuerySuccessValue<T> {
+interface QuerySuccessValue<T$1> {
   /** The decoded response from the contract */
-  value: T;
+  value: T$1;
   /** Events that would be emitted */
   events: unknown[];
   /** Gas consumed during dry-run */
@@ -8440,16 +8545,16 @@ interface QuerySuccessValue<T> {
   /** Storage deposit required */
   storageDeposit: bigint;
   /** Create a sendable transaction from this query result */
-  send(): SendableTransaction<T>;
+  send(): SendableTransaction<T$1>;
 }
 /**
  * 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> = ({
+type QueryResult<T$1> = ({
   success: true;
-} & QuerySuccessValue<T>) | {
+} & QuerySuccessValue<T$1>) | {
   success: false;
   error: ContractError;
 };
@@ -8490,9 +8595,9 @@ type InkLangError = {
  * ink! MessageResult type pattern (Result<T, LangError>)
  * papi generates this as { success: true; value: T } | { success: false; value: LangError }
  */
-type InkMessageResult<T> = {
+type InkMessageResult<T$1> = {
   success: true;
-  value: T;
+  value: T$1;
 } | {
   success: false;
   value: unknown;
@@ -8502,15 +8607,18 @@ type InkMessageResult<T> = {
  * 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 UnwrapMessageResult<T$1> = T$1 extends InkMessageResult<infer U> ? Exclude<U, InkLangError> : T$1;
 /**
  * Type helper to extract message response type (with MessageResult unwrapped)
  */
 type MessageResponse<M$1 extends InkCallableDescriptor, K$1 extends keyof M$1> = UnwrapMessageResult<M$1[K$1]["response"]>;
 /**
  * D9 Ink Contract interface
+ *
+ * @typeParam M - The callable descriptor type (message definitions)
+ * @typeParam E - The event type for type-safe event filtering
  */
-interface D9InkContract<M$1 extends InkCallableDescriptor> {
+interface D9InkContract<M$1 extends InkCallableDescriptor, E extends Event = Event> {
   /** Contract address */
   readonly address: SS58String$1;
   /** Contract metadata */
@@ -8533,13 +8641,69 @@ interface D9InkContract<M$1 extends InkCallableDescriptor> {
   getStorage(): ContractStorage;
   /**
    * Filter events from a transaction result to only include this contract's events
+   * Returns type-safe events that can be narrowed using `event.type`
+   *
+   * @example
+   * ```ts
+   * const events = contract.filterEvents(txResult.events);
+   * for (const event of events) {
+   *   if (event.type === "Transfer") {
+   *     console.log(event.value.from, event.value.to, event.value.value);
+   *   }
+   * }
+   * ```
    */
-  filterEvents(events: unknown[]): DecodedContractEvent[];
+  filterEvents(events: unknown[]): TypedContractEvent<E>[];
   /**
    * 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>;
+  subscribeToEvents(options?: Omit<EventSubscriptionOptions, "contractAddress">): Observable<TypedContractEvent<E>>;
+  /**
+   * Get a type-safe message builder for a specific message
+   *
+   * Provides a polkadot-api compatible API for encoding and decoding
+   * contract messages with full TypeScript type inference.
+   *
+   * @param label - The message label (e.g., "PSP22::transfer")
+   * @returns Typed message interface with encode/decode methods
+   *
+   * @example
+   * ```ts
+   * const transfer = contract.message("PSP22::transfer");
+   *
+   * // Encode with full type checking on args
+   * const encoded = transfer.encode({
+   *   to: recipientAddress,
+   *   value: 1000000n,
+   *   data: new Uint8Array(),
+   * });
+   *
+   * // Decode response with full type inference
+   * const decoded = transfer.decode(responseBytes);
+   * ```
+   */
+  message<L$1 extends ExtractMessageLabels<M$1>>(label: L$1): TypedMessage<M$1, L$1>;
+  /**
+   * Filter events by specific type with proper type narrowing
+   *
+   * @param events - Array of chain events to filter
+   * @param label - The event label to filter by
+   * @returns Array of events narrowed to the specific type
+   *
+   * @example
+   * ```ts
+   * const transfers = contract.filterEventsByType(txResult.events, "Transfer");
+   *
+   * for (const t of transfers) {
+   *   // t.value is fully typed as Transfer event data
+   *   console.log(t.value.from, "->", t.value.to, ":", t.value.value);
+   * }
+   * ```
+   */
+  filterEventsByType<L$1 extends string>(events: unknown[], label: L$1): Array<TypedContractEvent<E> & {
+    type: L$1;
+  }>;
 }
 /**
  * D9 Ink SDK options
@@ -8554,29 +8718,284 @@ interface D9InkSdk {
    * @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$1<S, M$1, C, E>, address: SS58String$1): D9InkContract<M$1>;
+  getContract<S extends InkStorageDescriptor, M$1 extends InkCallableDescriptor, C extends InkCallableDescriptor, E extends Event>(descriptor: InkDescriptors$1<S, M$1, C, E>, address: SS58String$1): D9InkContract<M$1, E>;
 }
+/**
+ * Type helper to extract D9InkContract type from an InkDescriptors
+ */
+
+//#endregion
+//#region src/rpc-types.d.ts
+/**
+ * Block header structure
+ */
+interface BlockHeader {
+  parentHash: HexString$1;
+  number: HexString$1;
+  stateRoot: HexString$1;
+  extrinsicsRoot: HexString$1;
+  digest: {
+    logs: HexString$1[];
+  };
+}
+/**
+ * System health information
+ */
+interface SystemHealth {
+  peers: number;
+  isSyncing: boolean;
+  shouldHavePeers: boolean;
+}
+/**
+ * Runtime version information
+ */
+interface RuntimeVersion {
+  specName: string;
+  implName: string;
+  authoringVersion: number;
+  specVersion: number;
+  implVersion: number;
+  apis: [HexString$1, number][];
+  transactionVersion: number;
+  stateVersion: number;
+}
+/**
+ * Storage change set
+ */
+interface StorageChangeSet {
+  block: HexString$1;
+  changes: [HexString$1, HexString$1 | null][];
+}
+/**
+ * RPC method signatures: method name -> [params tuple, return type]
+ *
+ * This interface maps known Substrate RPC methods to their parameter and return types.
+ * Methods not in this list will fall back to unknown types.
+ */
+interface SubstrateRpcMethods {
+  chain_getBlockHash: [[blockNumber?: number], HexString$1 | null];
+  chain_getHeader: [[hash?: HexString$1], BlockHeader | null];
+  chain_getBlock: [[hash?: HexString$1], {
+    block: {
+      header: BlockHeader;
+      extrinsics: HexString$1[];
+    };
+    justifications: unknown;
+  } | null];
+  chain_getFinalizedHead: [[], HexString$1];
+  state_call: [[method: string, data: HexString$1, at?: HexString$1], HexString$1];
+  state_getStorage: [[key: HexString$1, at?: HexString$1], HexString$1 | null];
+  state_getStorageAt: [[key: HexString$1, at: HexString$1], HexString$1 | null];
+  state_getStorageHash: [[key: HexString$1, at?: HexString$1], HexString$1 | null];
+  state_getStorageSize: [[key: HexString$1, at?: HexString$1], number | null];
+  state_getMetadata: [[at?: HexString$1], HexString$1];
+  state_getRuntimeVersion: [[at?: HexString$1], RuntimeVersion];
+  state_queryStorageAt: [[keys: HexString$1[], at?: HexString$1], StorageChangeSet[]];
+  system_chain: [[], string];
+  system_name: [[], string];
+  system_version: [[], string];
+  system_health: [[], SystemHealth];
+  system_properties: [[], Record<string, unknown>];
+  system_peers: [[], {
+    peerId: string;
+    roles: string;
+    bestHash: HexString$1;
+    bestNumber: number;
+  }[]];
+  system_chainType: [[], string];
+  author_submitExtrinsic: [[extrinsic: HexString$1], HexString$1];
+  author_pendingExtrinsics: [[], HexString$1[]];
+  author_removeExtrinsic: [[bytesOrHash: (HexString$1 | {
+    Hash: HexString$1;
+  })[]], number];
+  payment_queryInfo: [[extrinsic: HexString$1, at?: HexString$1], {
+    weight: {
+      refTime: number;
+      proofSize: number;
+    };
+    class: string;
+    partialFee: string;
+  }];
+  payment_queryFeeDetails: [[extrinsic: HexString$1, at?: HexString$1], {
+    inclusionFee: {
+      baseFee: string;
+      lenFee: string;
+      adjustedWeightFee: string;
+    } | null;
+  }];
+}
+/**
+ * Known RPC method names (for autocomplete)
+ */
+type KnownRpcMethod = keyof SubstrateRpcMethods;
+/**
+ * Extract parameter types for a known RPC method
+ */
+type RpcParams<M$1 extends KnownRpcMethod> = SubstrateRpcMethods[M$1][0];
+/**
+ * Extract return type for a known RPC method
+ */
+type RpcReturn<M$1 extends KnownRpcMethod> = SubstrateRpcMethods[M$1][1];
+/**
+ * Type-safe RPC request interface
+ *
+ * Provides full type inference for known RPC methods while allowing
+ * arbitrary method calls with explicit type parameters.
+ *
+ * @example
+ * ```ts
+ * // Known method: types are inferred
+ * const hash = await rpc("chain_getBlockHash", [12345]);
+ * // hash: HexString | null
+ *
+ * // Unknown method: provide explicit types
+ * const result = await rpc<MyType>("custom_method", [arg1, arg2]);
+ * ```
+ */
+interface TypedRpcRequest {
+  /**
+   * Call a known RPC method with full type inference
+   */
+  <M$1 extends KnownRpcMethod>(method: M$1, params: RpcParams<M$1>): Promise<RpcReturn<M$1>>;
+  /**
+   * Call an unknown RPC method with explicit type parameters
+   */
+  <Reply = unknown, Params extends unknown[] = unknown[]>(method: string, params: Params): Promise<Reply>;
+}
+//#endregion
+//#region src/sdk.d.ts
+/**
+ * Options for creating D9 Ink SDK
+ */
+
+/**
+ * Extended D9 Ink SDK interface with typed RPC access
+ */
+interface D9InkSdkWithRpc extends D9InkSdk {
+  /**
+   * Type-safe RPC request function
+   *
+   * Provides autocomplete for known Substrate RPC methods and type inference
+   * for parameters and return values.
+   *
+   * @example
+   * ```ts
+   * // Known method with full type inference
+   * const hash = await sdk.rpc("chain_getBlockHash", [12345]);
+   * // hash: HexString | null
+   *
+   * // Custom method with explicit types
+   * const custom = await sdk.rpc<MyType>("custom_method", [arg]);
+   * ```
+   */
+  rpc: TypedRpcRequest;
+}
+/**
+ * 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 with typed RPC access
+ */
+
 //#endregion
 //#region src/events.d.ts
 /**
- * Event parser for a specific contract
+ * Type-safe event parser for a specific contract
+ *
+ * @typeParam S - The storage descriptor type
+ * @typeParam M - The messages descriptor type
+ * @typeParam C - The constructors descriptor type
+ * @typeParam E - The event type representing all possible events for this contract
  */
-declare class ContractEventParser {
+declare class ContractEventParser<S extends InkStorageDescriptor = InkStorageDescriptor, M$1 extends InkCallableDescriptor = InkCallableDescriptor, C extends InkCallableDescriptor = InkCallableDescriptor, E extends Event = Event> {
   private eventDecoders;
   private eventSignatures;
   private contractAddressBytes;
   private contractAddress;
   private metadata;
-  constructor(metadata: InkMetadata, contractAddress: SS58String$1);
+  constructor(descriptor: InkDescriptors$1<S, M$1, C, E>, contractAddress: SS58String$1);
   /**
-   * Parse a raw chain event into a contract event (if it matches)
+   * Parse a raw chain event into a type-safe contract event (if it matches)
    * Returns null if the event is not from this contract or cannot be parsed
+   *
+   * @example
+   * ```ts
+   * const event = parser.parseEvent(chainEvent);
+   * if (event?.type === "Transfer") {
+   *   // event.value is now typed as { from: SS58String; to: SS58String; value: bigint }
+   *   console.log(event.value.from);
+   * }
+   * ```
    */
-  parseEvent(chainEvent: unknown): DecodedContractEvent | null;
+  parseEvent(chainEvent: unknown): TypedContractEvent<E> | null;
   /**
-   * Filter a batch of events
+   * Filter a batch of events and return type-safe results
+   *
+   * @param chainEvents - Array of chain events to filter
+   * @param options - Optional filter criteria
+   * @returns Array of type-safe contract events
    */
-  filterEvents(chainEvents: unknown[], options?: EventFilterOptions): DecodedContractEvent[];
+  filterEvents(chainEvents: unknown[], options?: EventFilterOptions): TypedContractEvent<E>[];
+  /**
+   * Filter events by specific type with proper type narrowing
+   *
+   * This method provides better type safety than filterEvents with eventLabels
+   * because TypeScript can narrow the return type to only the specified event type.
+   *
+   * @param chainEvents - Array of chain events to filter
+   * @param label - The event label to filter by
+   * @returns Array of events narrowed to the specific type
+   *
+   * @example
+   * ```ts
+   * const transfers = parser.filterByType(events, "Transfer");
+   *
+   * for (const t of transfers) {
+   *   // t.value is fully typed as Transfer event data
+   *   console.log(t.value.from, "->", t.value.to, ":", t.value.value);
+   * }
+   * ```
+   */
+  filterByType<L$1 extends string>(chainEvents: unknown[], label: L$1): Array<TypedContractEvent<E> & {
+    type: L$1;
+  }>;
   /**
    * Get the contract address as SS58 string
    */
@@ -8595,32 +9014,73 @@ declare class ContractEventParser {
    */
   private static buildEventSignatureMap;
 }
+/**
+ * Type guard for narrowing event types
+ *
+ * Use this function when you have a `TypedContractEvent` and need to
+ * narrow it to a specific event type. This is useful when the type
+ * information is lost (e.g., after serialization or in generic functions).
+ *
+ * @typeParam E - The Enum type representing all possible events
+ * @typeParam L - The specific event label to check
+ * @param event - The event to check
+ * @param label - The event label to match
+ * @returns True if the event type matches the label
+ *
+ * @example
+ * ```ts
+ * const event = parser.parseEvent(chainEvent);
+ *
+ * if (event && isEventType(event, "Transfer")) {
+ *   // TypeScript knows event.value is Transfer event data
+ *   console.log(event.value.from);
+ *   console.log(event.value.to);
+ *   console.log(event.value.value);
+ * }
+ * ```
+ */
+
 //#endregion
 //#region src/subscriptions.d.ts
 /**
  * Create an observable stream of contract events
  *
  * @param client - Polkadot API client
- * @param metadata - Contract metadata
+ * @param descriptor - Contract descriptor
  * @param options - Subscription options
- * @returns Observable stream of decoded contract events
+ * @returns Observable stream of type-safe contract events
  */
-declare function createContractEventStream(client: PolkadotClient, metadata: InkMetadata, options: EventSubscriptionOptions): Observable<DecodedContractEvent>;
+declare function createContractEventStream<S extends InkStorageDescriptor = InkStorageDescriptor, M$1 extends InkCallableDescriptor = InkCallableDescriptor, C extends InkCallableDescriptor = InkCallableDescriptor, E extends Event = Event>(client: PolkadotClient, descriptor: InkDescriptors$1<S, M$1, C, E>, options: EventSubscriptionOptions): Observable<TypedContractEvent<E>>;
+/**
+ * PSP22 Transfer event type
+ */
+interface PSP22TransferEvent {
+  type: "Transfer";
+  value: {
+    from?: SS58String$1 | null;
+    to?: SS58String$1 | null;
+    value: bigint;
+  };
+  raw: {
+    blockNumber: number;
+    blockHash: string;
+    eventIndex: number;
+    contractAddress: SS58String$1;
+    data: Uint8Array;
+    topics: Uint8Array[];
+  };
+}
 /**
  * Convenience helper to create a Transfer event stream for PSP22 tokens
  *
  * @param client - Polkadot API client
- * @param metadata - PSP22 contract metadata
+ * @param descriptor - PSP22 contract descriptor
  * @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$1, getEvents: (blockHash: string) => Promise<unknown[]>, watchAddress?: SS58String$1): Observable<DecodedContractEvent<{
-  from?: SS58String$1 | null;
-  to?: SS58String$1 | null;
-  value: bigint;
-}>>;
+declare function createPSP22TransferStream<S extends InkStorageDescriptor = InkStorageDescriptor, M$1 extends InkCallableDescriptor = InkCallableDescriptor, C extends InkCallableDescriptor = InkCallableDescriptor, E extends Event = Event>(client: PolkadotClient, descriptor: InkDescriptors$1<S, M$1, C, E>, contractAddress: SS58String$1, getEvents: (blockHash: string) => Promise<unknown[]>, watchAddress?: SS58String$1): Observable<PSP22TransferEvent>;
 /**
  * Create a native token (D9) transfer event stream
  *
@@ -8639,6 +9099,15 @@ declare function createNativeTransferStream(client: PolkadotClient, getEvents: (
   blockHash: string;
 }>;
 //#endregion
+//#region src/calls.d.ts
+/**
+ * Type-safe call parser for a specific contract
+ *
+ * @typeParam S - The storage descriptor type
+ * @typeParam M - The InkCallableDescriptor type (message definitions)
+ * @typeParam C - The constructors descriptor type
+ * @typeParam E - The events Enum type
+ */
 //#endregion
 //#region src/client.d.ts
 type CreateD9SdkClientOptions = {
@@ -8655,7 +9124,7 @@ type CreateD9SdkClientOptions = {
  * @example
  * ```ts
  * const d9Client = createD9SdkClient({
- *   endpoint: "wss://mainnet.d9network.com:40300",
+ *   endpoint: "wss://archiver.d9network.com:40300",
  * });
  *
  * // Query USDT balance
@@ -8672,7 +9141,7 @@ type CreateD9SdkClientOptions = {
 declare function createD9SdkClient(options: CreateD9SdkClientOptions): {
   client: polkadot_api0.PolkadotClient;
   api: polkadot_api0.TypedApi<D9>;
-  inkSdk: D9InkSdk;
+  inkSdk: D9InkSdkWithRpc;
 };
 type D9SdkClientReturn = ReturnType<typeof createD9SdkClient>;
 //#endregion