@d9-network/spec 0.0.12 → 0.0.14

package/dist/index.d.mts

@@ -9,12 +9,12 @@ import { Observable } from "rxjs";
 //#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
 /**
- * Decoder type for response decoding
+ * 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;
+}
+/**
+ * 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,296 @@ 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
+   * Extract event label from ASCII-encoded topic (D9 chain format)
+   *
+   * D9 chain uses a format where:
+   * - First byte is 0x00 (null)
+   * - Remaining 31 bytes are ASCII characters of `ContractName::EventLabel`
+   * - Total is exactly 32 bytes (truncated/padded as needed)
+   *
+   * @param topic - The 32-byte topic from the event
+   * @returns The extracted event label, or null if not in ASCII format
+   */
+  private extractEventLabelFromAsciiTopic;
+  /**
+   * 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): 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);
+   * }
+   * ```
    */
-  filterEvents(chainEvents: unknown[], options?: EventFilterOptions): DecodedContractEvent[];
+  filterByType<L$1 extends string>(chainEvents: unknown[], label: L$1): Array<TypedContractEvent<E> & {
+    type: L$1;
+  }>;
   /**
    * Get the contract address as SS58 string
    */
@@ -8590,37 +9021,74 @@ declare class ContractEventParser {
    * Compare two Uint8Arrays for equality
    */
   private bytesEqual;
-  /**
-   * Build event signature map from metadata
-   */
-  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 +9107,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 +9132,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 +9149,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
@@ -8722,5 +9199,304 @@ declare function createAccountFromPrivateKey(options: {
   keyType: "sr25519" | "ed25519" | "secp256k1";
 }): WalletAccount;
 //#endregion
-export { ArithmeticError, BalanceStatus, BalancesTypesReasons, ContractEventParser, CreateD9SdkClientOptions, D9, D9Apis, D9CallData, D9Calls, D9Constants, D9DispatchError, D9Errors, D9Events, D9Extensions, D9Queries, D9SdkClientReturn, D9ViewFns, D9WhitelistEntry, type DecodedContractEvent, DigestItem, DispatchClass, type EventFilterOptions, type EventSubscriptionOptions, GrandpaEquivocation, GrandpaEvent, GrandpaStoredState, type HexString, MultiAddress, Phase, type PolkadotSigner, type RawContractEvent, type SS58String, SessionEvent, Sr25519Keypair, TransactionPaymentEvent, TransactionPaymentReleases, TransactionalError, WalletAccount, WhitelistEntriesByChain, WhitelistEntry, bytesToHex, index_d_exports as contracts, createAccountFromMnemonic, createAccountFromPrivateKey, createContractEventStream, createD9SdkClient, createNativeTransferStream, createPSP22TransferStream, createSr25519SignerFromKeypair, _allDescriptors as d9, generateMnemonic, getMetadata, hexToBytes, isHexString, mnemonicToMiniSecret, sr25519AddressFromKeypair, sr25519AddressFromSecretKeyHex, sr25519DeriveFromMiniSecret, sr25519KeypairFromMiniSecret, ss58DecodePublicKey, ss58Reencode, validateMnemonic };
+//#region src/wallet/validation.d.ts
+/**
+ * Check if a value is a valid SS58 address
+ *
+ * @param address - The value to check
+ * @returns True if the value is a valid SS58 address
+ *
+ * @example
+ * ```typescript
+ * isValidAddress("5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY"); // true
+ * isValidAddress("invalid"); // false
+ * isValidAddress(null); // false
+ * ```
+ */
+declare function isValidAddress(address: unknown): address is SS58String$1;
+/**
+ * Check if a value is a valid D9 address (SS58 prefix 9)
+ *
+ * @param address - The value to check
+ * @returns True if the value is a valid D9 address
+ *
+ * @example
+ * ```typescript
+ * isValidD9Address("XYZd9..."); // true (if valid D9 prefix)
+ * isValidD9Address("5GrwvaEF..."); // false (Polkadot prefix)
+ * ```
+ */
+declare function isValidD9Address(address: unknown): address is SS58String$1;
+/**
+ * Check if a value is a valid address for a specific network
+ *
+ * @param address - The value to check
+ * @param expectedPrefix - The expected SS58 prefix
+ * @returns True if the value is a valid address with the expected prefix
+ *
+ * @example
+ * ```typescript
+ * isValidAddressForNetwork(address, 0); // Polkadot
+ * isValidAddressForNetwork(address, 2); // Kusama
+ * isValidAddressForNetwork(address, 9); // D9
+ * ```
+ */
+declare function isValidAddressForNetwork(address: unknown, expectedPrefix: number): address is SS58String$1;
+/**
+ * Get the SS58 prefix of an address
+ *
+ * @param address - The SS58 address
+ * @returns The SS58 prefix
+ * @throws Error if the address is invalid
+ *
+ * @example
+ * ```typescript
+ * getAddressPrefix("5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY"); // 42 (Substrate generic)
+ * ```
+ */
+declare function getAddressPrefix(address: SS58String$1): number;
+/**
+ * Compare two addresses for equality (same public key)
+ *
+ * Addresses with different SS58 prefixes can represent the same account.
+ * This function compares the underlying public keys.
+ *
+ * @param a - First address
+ * @param b - Second address
+ * @returns True if both addresses represent the same public key
+ *
+ * @example
+ * ```typescript
+ * // Same account, different network formats
+ * const polkadotAddr = "15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5";
+ * const genericAddr = "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY";
+ * addressesEqual(polkadotAddr, genericAddr); // true
+ * ```
+ */
+declare function addressesEqual(a: SS58String$1, b: SS58String$1): boolean;
+/**
+ * Convert an address to a specific SS58 format
+ *
+ * @param address - The SS58 address
+ * @param targetPrefix - The target SS58 prefix
+ * @returns The address encoded with the target prefix
+ * @throws Error if the address is invalid
+ *
+ * @example
+ * ```typescript
+ * const d9Address = toNetworkAddress("5GrwvaEF...", 9);
+ * ```
+ */
+declare function toNetworkAddress(address: SS58String$1, targetPrefix: number): SS58String$1;
+/**
+ * Convert an address to D9 format
+ *
+ * @param address - The SS58 address
+ * @returns The address encoded with D9 prefix (9)
+ *
+ * @example
+ * ```typescript
+ * const d9Address = toD9Address("5GrwvaEF...");
+ * ```
+ */
+declare function toD9Address(address: SS58String$1): SS58String$1;
+//#endregion
+//#region src/utils/balance.d.ts
+/**
+ * Balance formatting utilities for D9 blockchain
+ */
+declare const D9_DECIMALS = 12;
+declare const D9_SYMBOL = "D9";
+declare const D9_SS58_PREFIX = 9;
+declare const USDT_DECIMALS = 2;
+declare const USDT_SYMBOL = "USDT";
+/**
+ * Token configuration for formatting
+ */
+interface TokenConfig {
+  decimals: number;
+  symbol: string;
+}
+/**
+ * Pre-configured D9 token
+ */
+declare const D9_TOKEN: TokenConfig;
+/**
+ * Pre-configured USDT token
+ */
+declare const USDT_TOKEN: TokenConfig;
+/**
+ * Options for formatting balance
+ */
+interface FormatBalanceOptions {
+  /** Number of decimal places (default: token's decimals) */
+  decimals?: number;
+  /** Maximum decimal places to display (default: 4) */
+  maxDecimals?: number;
+  /** Whether to trim trailing zeros (default: true) */
+  trimTrailingZeros?: boolean;
+  /** Thousands separator (default: none) */
+  thousandsSeparator?: string;
+}
+/**
+ * Format a raw planck value to a human-readable balance string
+ *
+ * @param planck - The raw balance in planck units (smallest unit)
+ * @param options - Formatting options
+ * @returns Formatted balance string
+ *
+ * @example
+ * ```typescript
+ * formatBalance(1_500_000_000_000n, { decimals: 12 }); // "1.5"
+ * formatBalance(1_500_000_000_000n, { decimals: 12, maxDecimals: 2 }); // "1.50"
+ * formatBalance(1_000_000_000_000_000n, { decimals: 12, thousandsSeparator: "," }); // "1,000"
+ * ```
+ */
+declare function formatBalance(planck: bigint, options?: FormatBalanceOptions): string;
+/**
+ * Parse a human-readable amount string to planck units
+ *
+ * @param amount - The amount as a string or number
+ * @param options - Parse options
+ * @returns The amount in planck units (bigint)
+ *
+ * @example
+ * ```typescript
+ * parseAmount("1.5", { decimals: 12 }); // 1_500_000_000_000n
+ * parseAmount(1.5, { decimals: 12 }); // 1_500_000_000_000n
+ * parseAmount("1,000.50", { decimals: 12 }); // 1_000_500_000_000_000n
+ * ```
+ */
+declare function parseAmount(amount: string | number, options?: {
+  decimals?: number;
+}): bigint;
+/**
+ * Format a token amount with symbol
+ *
+ * @param planck - The raw balance in planck units
+ * @param token - Token configuration
+ * @param options - Additional formatting options
+ * @returns Formatted string with token symbol
+ *
+ * @example
+ * ```typescript
+ * formatTokenAmount(1_500_000_000_000n, D9_TOKEN); // "1.5 D9"
+ * formatTokenAmount(1000n, USDT_TOKEN); // "10 USDT"
+ * ```
+ */
+declare function formatTokenAmount(planck: bigint, token: TokenConfig, options?: Omit<FormatBalanceOptions, "decimals">): string;
+//#endregion
+//#region src/utils/time.d.ts
+/**
+ * Block time utilities for D9 blockchain
+ */
+declare const D9_BLOCK_TIME_MS = 3000;
+declare const BLOCKS_PER_MINUTE = 20;
+declare const BLOCKS_PER_HOUR = 1200;
+declare const BLOCKS_PER_DAY = 28800;
+declare const BLOCKS_PER_WEEK = 201600;
+/**
+ * Convert milliseconds to blocks
+ *
+ * @param ms - Duration in milliseconds
+ * @returns Number of blocks (rounded down)
+ *
+ * @example
+ * ```typescript
+ * msToBlocks(60_000); // 20 blocks (1 minute)
+ * msToBlocks(3_600_000); // 1200 blocks (1 hour)
+ * ```
+ */
+declare function msToBlocks(ms: number): number;
+/**
+ * Convert blocks to milliseconds
+ *
+ * @param blocks - Number of blocks
+ * @returns Duration in milliseconds
+ *
+ * @example
+ * ```typescript
+ * blocksToMs(20); // 60_000 (1 minute)
+ * blocksToMs(1200); // 3_600_000 (1 hour)
+ * ```
+ */
+declare function blocksToMs(blocks: number): number;
+/**
+ * Estimate the block number at a target time
+ *
+ * @param targetTime - The target time to estimate block for
+ * @param currentBlock - The current block number
+ * @param currentTime - The current time (default: now)
+ * @returns Estimated block number at target time
+ *
+ * @example
+ * ```typescript
+ * const targetBlock = estimateBlockAtTime(
+ *   new Date(Date.now() + 3_600_000), // 1 hour from now
+ *   1000, // current block
+ * ); // ~2200
+ * ```
+ */
+declare function estimateBlockAtTime(targetTime: Date, currentBlock: number, currentTime?: Date): number;
+/**
+ * Estimate the time at a target block
+ *
+ * @param targetBlock - The target block number
+ * @param currentBlock - The current block number
+ * @param currentTime - The current time (default: now)
+ * @returns Estimated time at target block
+ *
+ * @example
+ * ```typescript
+ * const unlockTime = estimateTimeAtBlock(
+ *   2200, // target block
+ *   1000, // current block
+ * ); // ~1 hour from now
+ * ```
+ */
+declare function estimateTimeAtBlock(targetBlock: number, currentBlock: number, currentTime?: Date): Date;
+/**
+ * Calculate the number of blocks until a target time
+ *
+ * @param targetTime - The target time
+ * @param currentBlock - The current block number
+ * @param currentTime - The current time (default: now)
+ * @returns Number of blocks until target time (negative if in the past)
+ *
+ * @example
+ * ```typescript
+ * const blocksRemaining = blocksUntil(unlockTime, currentBlock);
+ * if (blocksRemaining > 0) {
+ *   console.log(`${blocksRemaining} blocks until unlock`);
+ * }
+ * ```
+ */
+declare function blocksUntil(targetTime: Date, currentBlock: number, currentTime?: Date): number;
+/**
+ * Format options for duration display
+ */
+interface FormatDurationOptions {
+  /** Whether to show short units (d, h, m, s) or long (days, hours, minutes, seconds) */
+  short?: boolean;
+  /** Maximum number of units to display (default: 2) */
+  maxUnits?: number;
+}
+/**
+ * Format a block duration as a human-readable string
+ *
+ * @param blocks - Number of blocks
+ * @param options - Formatting options
+ * @returns Human-readable duration string
+ *
+ * @example
+ * ```typescript
+ * formatBlockDuration(20); // "1 minute"
+ * formatBlockDuration(1200); // "1 hour"
+ * formatBlockDuration(BLOCKS_PER_DAY); // "1 day"
+ * formatBlockDuration(30000, { short: true }); // "1d 1h"
+ * ```
+ */
+declare function formatBlockDuration(blocks: number, options?: FormatDurationOptions): string;
+//#endregion
+export { ArithmeticError, BLOCKS_PER_DAY, BLOCKS_PER_HOUR, BLOCKS_PER_MINUTE, BLOCKS_PER_WEEK, BalanceStatus, BalancesTypesReasons, ContractEventParser, CreateD9SdkClientOptions, D9, D9Apis, D9CallData, D9Calls, D9Constants, D9DispatchError, D9Errors, D9Events, D9Extensions, D9Queries, D9SdkClientReturn, D9ViewFns, D9WhitelistEntry, D9_BLOCK_TIME_MS, D9_DECIMALS, D9_SS58_PREFIX, D9_SYMBOL, D9_TOKEN, type DecodedContractEvent, DigestItem, DispatchClass, type EventFilterOptions, type EventSubscriptionOptions, FormatBalanceOptions, FormatDurationOptions, GrandpaEquivocation, GrandpaEvent, GrandpaStoredState, type HexString, MultiAddress, Phase, type PolkadotSigner, type RawContractEvent, type SS58String, SessionEvent, Sr25519Keypair, TokenConfig, TransactionPaymentEvent, TransactionPaymentReleases, TransactionalError, USDT_DECIMALS, USDT_SYMBOL, USDT_TOKEN, WalletAccount, WhitelistEntriesByChain, WhitelistEntry, addressesEqual, blocksToMs, blocksUntil, bytesToHex, index_d_exports as contracts, createAccountFromMnemonic, createAccountFromPrivateKey, createContractEventStream, createD9SdkClient, createNativeTransferStream, createPSP22TransferStream, createSr25519SignerFromKeypair, _allDescriptors as d9, estimateBlockAtTime, estimateTimeAtBlock, formatBalance, formatBlockDuration, formatTokenAmount, generateMnemonic, getAddressPrefix, getMetadata, hexToBytes, isHexString, isValidAddress, isValidAddressForNetwork, isValidD9Address, mnemonicToMiniSecret, msToBlocks, parseAmount, sr25519AddressFromKeypair, sr25519AddressFromSecretKeyHex, sr25519DeriveFromMiniSecret, sr25519KeypairFromMiniSecret, ss58DecodePublicKey, ss58Reencode, toD9Address, toNetworkAddress, validateMnemonic };
 //# sourceMappingURL=index.d.mts.map