@d9-network/spec 0.2.0 → 1.0.0

package/dist/index.d.cts

@@ -1,20 +1,16 @@
-import * as polkadot_api0 from "polkadot-api";
-import { ApisFromDef, Binary, ConstFromPalletsDef, CreateClientOptions, Enum, ErrorsFromPalletsDef, EventsFromPalletsDef, FixedSizeArray, FixedSizeBinary, GetEnum, HexString, HexString as HexString$1, PlainDescriptor, PolkadotClient, PolkadotSigner, PolkadotSigner as PolkadotSigner$1, QueryFromPalletsDef, ResultPayload, SS58String, SS58String as SS58String$1, StorageDescriptor, TxCallData, TxDescriptor, TxFromPalletsDef, ViewFnsFromPalletsDef } from "polkadot-api";
+import { ApisFromDef, Binary, ConstFromPalletsDef, Enum, ErrorsFromPalletsDef, EventsFromPalletsDef, FixedSizeArray, FixedSizeBinary, GetEnum, HexString, HexString as HexString$1, PlainDescriptor, PolkadotSigner, PolkadotSigner as PolkadotSigner$1, QueryFromPalletsDef, ResultPayload, SS58String, SS58String as SS58String$1, StorageDescriptor, TxCallData, TxDescriptor, TxFromPalletsDef, ViewFnsFromPalletsDef } from "polkadot-api";
 import { InkDescriptors } from "polkadot-api/ink";
-import { Event, InkCallableDescriptor, InkDescriptors as InkDescriptors$1, InkMetadata, InkStorageDescriptor } from "@polkadot-api/ink-contracts";
-import { Observable } from "rxjs";
-import { getWsProvider } from "polkadot-api/ws-provider";
 import { KeyPair } from "@polkadot-labs/hdkd-helpers";
 
 //#region rolldown:runtime
 //#endregion
 //#region ../../node_modules/.bun/@polkadot-api+descriptors@file+packages+spec+.papi+descriptors+ec2463ed5a666297/node_modules/@polkadot-api/descriptors/dist/common-types.d.ts
-type AnonymousEnum$9<T$1 extends {}> = T$1 & {
+type AnonymousEnum$9<T extends {}> = T & {
   __anonymous: true;
 };
-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 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 Ic5m5lp1oioo8r = Array<FixedSizeBinary<32>>;
 type Ihfphjolmsqq1 = (SS58String$1) | undefined;
 type Idrurqd6ddlmr3 = {
@@ -3376,12 +3372,12 @@ type I1q6j2f64t5q87 = {
 };
 //#endregion
 //#region ../../node_modules/.bun/@polkadot-api+descriptors@file+packages+spec+.papi+descriptors+ec2463ed5a666297/node_modules/@polkadot-api/descriptors/dist/d9.d.ts
-type AnonymousEnum$8<T$1 extends {}> = T$1 & {
+type AnonymousEnum$8<T extends {}> = T & {
   __anonymous: true;
 };
-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 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 IStorage = {
   Aura: {
     /**
@@ -6713,12 +6709,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+ec2463ed5a666297/node_modules/@polkadot-api/descriptors/dist/contracts/nodeReward.d.ts
-type AnonymousEnum$7<T$1 extends {}> = T$1 & {
+type AnonymousEnum$7<T extends {}> = T & {
   __anonymous: true;
 };
-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 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 T0$7 = ResultPayload<undefined, Anonymize$7<T1$7>>;
 type T1$7 = Enum<{
   "CouldNotReadInput": undefined;
@@ -6880,12 +6876,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+ec2463ed5a666297/node_modules/@polkadot-api/descriptors/dist/contracts/merchantMining.d.ts
-type AnonymousEnum$6<T$1 extends {}> = T$1 & {
+type AnonymousEnum$6<T extends {}> = T & {
   __anonymous: true;
 };
-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 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 T0$6 = ResultPayload<undefined, Anonymize$6<T1$6>>;
 type T1$6 = Enum<{
   "CouldNotReadInput": undefined;
@@ -7138,12 +7134,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+ec2463ed5a666297/node_modules/@polkadot-api/descriptors/dist/contracts/usdt.d.ts
-type AnonymousEnum$5<T$1 extends {}> = T$1 & {
+type AnonymousEnum$5<T extends {}> = T & {
   __anonymous: true;
 };
-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 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 T0$5 = Enum<{
   "CouldNotReadInput": undefined;
 }>;
@@ -7278,12 +7274,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+ec2463ed5a666297/node_modules/@polkadot-api/descriptors/dist/contracts/burnManager.d.ts
-type AnonymousEnum$4<T$1 extends {}> = T$1 & {
+type AnonymousEnum$4<T extends {}> = T & {
   __anonymous: true;
 };
-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 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 T0$4 = Array<SS58String$1>;
 type T1$4 = ResultPayload<undefined, Anonymize$4<T2$4>>;
 type T2$4 = Enum<{
@@ -7456,12 +7452,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+ec2463ed5a666297/node_modules/@polkadot-api/descriptors/dist/contracts/crossChainTransfer.d.ts
-type AnonymousEnum$3<T$1 extends {}> = T$1 & {
+type AnonymousEnum$3<T extends {}> = T & {
   __anonymous: true;
 };
-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 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 T5$2 = Array<SS58String$1>;
 type T0$3 = ResultPayload<undefined, Anonymize$3<T1$3>>;
 type T1$3 = Enum<{
@@ -7700,12 +7696,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+ec2463ed5a666297/node_modules/@polkadot-api/descriptors/dist/contracts/marketMaker.d.ts
-type AnonymousEnum$2<T$1 extends {}> = T$1 & {
+type AnonymousEnum$2<T extends {}> = T & {
   __anonymous: true;
 };
-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 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 T0$2 = ResultPayload<undefined, Anonymize$2<T1$2>>;
 type T1$2 = Enum<{
   "CouldNotReadInput": undefined;
@@ -7904,12 +7900,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+ec2463ed5a666297/node_modules/@polkadot-api/descriptors/dist/contracts/burnMining.d.ts
-type AnonymousEnum$1<T$1 extends {}> = T$1 & {
+type AnonymousEnum$1<T extends {}> = T & {
   __anonymous: true;
 };
-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 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 T0$1 = ResultPayload<undefined, Anonymize$1<T1$1>>;
 type T1$1 = Enum<{
   "CouldNotReadInput": undefined;
@@ -8083,12 +8079,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+ec2463ed5a666297/node_modules/@polkadot-api/descriptors/dist/contracts/miningPool.d.ts
-type AnonymousEnum<T$1 extends {}> = T$1 & {
+type AnonymousEnum<T extends {}> = T & {
   __anonymous: true;
 };
-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 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 T0 = ResultPayload<undefined, Anonymize<T1>>;
 type T1 = Enum<{
   "CouldNotReadInput": undefined;
@@ -8247,7 +8243,35 @@ type WhitelistEntriesByChain = Partial<{
   d9: WhitelistEntry[];
 }>;
 //#endregion
-//#region ../ink/dist/index.d.mts
+//#region src/constants.d.ts
+/**
+ * D9 Network constants
+ */
+/**
+ * D9 SS58 address prefix.
+ *
+ * SS58 is the address format used by Substrate-based chains. Each chain has a unique
+ * prefix that determines the address format and ensures addresses are network-specific.
+ *
+ * D9 uses prefix 9, which produces addresses starting with 'c' or 'd'.
+ *
+ * This prefix is automatically applied to all AccountId encoding/decoding operations
+ * in the SDK, including:
+ * - Contract call parameter encoding
+ * - Result decoding
+ * - Event parsing
+ *
+ * @see https://github.com/paritytech/ss58-registry for the full SS58 registry
+ */
+declare const D9_SS58_PREFIX = 9;
+/** D9 token decimals */
+declare const D9_DECIMALS = 12;
+/** D9 token symbol */
+declare const D9_SYMBOL = "D9";
+/** USDT token decimals */
+declare const USDT_DECIMALS = 2;
+/** USDT token symbol */
+declare const USDT_SYMBOL = "USDT";
 //#endregion
 //#region src/errors.d.ts
 /**
@@ -8280,880 +8304,77 @@ declare class ContractError extends Error {
 /**
  * Error thrown when contract metadata is missing or invalid
  */
-
-//#endregion
-//#region src/event-types.d.ts
-/**
- * Raw event data from chain
- */
-interface RawContractEvent {
-  /** Block number where event was emitted */
-  blockNumber: number;
-  /** Block hash */
-  blockHash: string;
-  /** Event index in block */
-  eventIndex: number;
-  /** Contract address that emitted the event */
-  contractAddress: SS58String$1;
-  /** Event data (SCALE encoded) */
-  data: Uint8Array;
-  /** Event topics (indexed fields) */
-  topics: Uint8Array[];
-}
-/**
- * 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 with generic data type.
- * For full type safety with discriminated unions, use TypedContractEvent instead.
- */
-interface DecodedContractEvent<T$1 = unknown> {
-  /** Event label from metadata (e.g., "Transfer", "Approval") */
-  label: string;
-  /** Decoded event data */
-  data: T$1;
-  /** Original raw event */
-  raw: RawContractEvent;
-}
-/**
- * Event filter options
- */
-interface EventFilterOptions {
-  /** Contract address to filter by */
-  contractAddress?: SS58String$1;
-  /** Event labels to include (e.g., ["Transfer", "Approval"]) */
-  eventLabels?: string[];
-  /** From block number (inclusive) */
-  fromBlock?: number;
-  /** 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
- */
-interface EventSubscriptionOptions {
-  /** Contract address to subscribe to */
-  contractAddress: SS58String$1;
-  /** Event labels to subscribe to (undefined = all events) */
-  eventLabels?: string[];
-  /** Include historical events from this block */
-  fromBlock?: number;
-  /**
-   * Function to fetch System.Events at a given block hash
-   * This is required because PolkadotClient doesn't expose typed API directly
-   *
-   * @example
-   * ```ts
-   * const options = {
-   *   contractAddress: usdtAddress,
-   *   getEvents: async (blockHash) => {
-   *     return await api.query.System.Events.getValue({ at: blockHash });
-   *   }
-   * };
-   * ```
-   */
-  getEvents: (blockHash: string) => Promise<unknown[]>;
-}
-//#endregion
-//#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;
-}
-/**
- * Contract message builder interface
- *
- * @typeParam M - The InkCallableDescriptor type (message definitions)
- */
-
-/**
- * Query options for read operations (dry-run)
- */
-interface QueryOptions<Args = unknown> {
-  /** The origin account for the call */
-  origin: SS58String$1;
-  /** Arguments to pass to the contract message */
-  args?: Args;
-  /** Value to transfer with the call */
-  value?: bigint;
-  /** AbortSignal for cancellation */
-  signal?: AbortSignal;
-  /** Timeout in milliseconds */
-  timeout?: number;
-  /** Block hash to query at (default: finalized) */
-  at?: string;
-}
-/**
- * Send options for write operations
- */
-interface SendOptions<Args = unknown> {
-  /** The origin account for the call */
-  origin: SS58String$1;
-  /** Arguments to pass to the contract message */
-  args?: Args;
-  /** Value to transfer with the call */
-  value?: bigint;
-  /** Gas limit (optional, will be estimated if not provided) */
-  gasLimit?: {
-    refTime: bigint;
-    proofSize: bigint;
-  };
-  /** Storage deposit limit */
-  storageDepositLimit?: bigint;
-}
-/**
- * Sendable transaction that can be signed and submitted
- */
-interface SendableTransaction<T$1> {
-  /** Sign and submit the transaction */
-  signAndSubmit(signer: PolkadotSigner$1): Promise<TxResult<T$1>>;
-  /** Get the encoded call data */
-  getEncodedData(): Uint8Array;
-}
-/**
- * Transaction result
- */
-interface TxResult<T$1> {
-  /** Whether the transaction was successful */
-  ok: boolean;
-  /** Transaction hash */
-  txHash: string;
-  /** Block information where tx was included */
-  block: {
-    hash: string;
-    number: number;
-  };
-  /** Decoded return value (if any) */
-  result?: T$1;
-  /** Events emitted by the transaction */
-  events: unknown[];
-  /** Dispatch error if failed */
-  dispatchError?: unknown;
-}
-/**
- * Successful query result value
- */
-interface QuerySuccessValue<T$1> {
-  /** The decoded response from the contract */
-  value: T$1;
-  /** Events that would be emitted */
-  events: unknown[];
-  /** Gas consumed during dry-run */
-  gasConsumed: {
-    refTime: bigint;
-    proofSize: bigint;
-  };
-  /** Gas required for execution */
-  gasRequired: {
-    refTime: bigint;
-    proofSize: bigint;
-  };
-  /** Storage deposit required */
-  storageDeposit: bigint;
-  /** Create a sendable transaction from this query result */
-  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$1> = ({
-  success: true;
-} & QuerySuccessValue<T$1>) | {
-  success: false;
-  error: ContractError;
-};
-/**
- * Storage query interface
- */
-interface ContractStorage {
-  /** Get the root storage value */
-  getRoot(): Promise<{
-    success: true;
-    value: unknown;
-  } | {
-    success: false;
-    value: ContractError;
-  }>;
-  /** Get a nested storage value by path */
-  getNested(path: string, ...keys: unknown[]): Promise<{
-    success: true;
-    value: unknown;
-  } | {
-    success: false;
-    value: ContractError;
-  }>;
-}
-/**
- * Type helper to extract message args type
- */
-type MessageArgs<M$1 extends InkCallableDescriptor, K$1 extends keyof M$1> = M$1[K$1]["message"];
-/**
- * ink! LangError type pattern
- * papi generates LangError variants with { type: string; value?: unknown }
- */
-type InkLangError = {
-  type: string;
-  value?: unknown;
-};
-/**
- * ink! MessageResult type pattern (Result<T, LangError>)
- * papi generates this as { success: true; value: T } | { success: false; value: LangError }
- */
-type InkMessageResult<T$1> = {
-  success: true;
-  value: T$1;
-} | {
-  success: false;
-  value: unknown;
-};
-/**
- * Type helper to unwrap ink! MessageResult (Result<T, LangError>)
- * 1. Extract T from { success: true; value: T } | { success: false; value: ... }
- * 2. Exclude LangError variants from 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, E extends Event = Event> {
-  /** Contract address */
-  readonly address: SS58String$1;
-  /** Contract metadata */
-  readonly metadata: InkMetadata;
-  /**
-   * Query a contract message (dry-run)
-   * @param method - The message label (e.g., "PSP22::balance_of")
-   * @param options - Query options including origin and args
-   */
-  query<K$1 extends keyof M$1 & string>(method: K$1, options: QueryOptions<MessageArgs<M$1, K$1>>): Promise<QueryResult<MessageResponse<M$1, K$1>>>;
-  /**
-   * Create a sendable transaction for a contract message
-   * @param method - The message label (e.g., "PSP22::transfer")
-   * @param options - Send options including origin and args
-   */
-  send<K$1 extends keyof M$1 & string>(method: K$1, options: SendOptions<MessageArgs<M$1, K$1>>): SendableTransaction<MessageResponse<M$1, K$1>>;
-  /**
-   * Get storage query interface
-   */
-  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[]): 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<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
- */
-
-/**
- * D9 Ink SDK interface
- */
-interface D9InkSdk {
-  /**
-   * Get a contract instance for interacting with a deployed contract
-   * @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, E>;
+declare class MetadataError extends ContractError {
+  constructor(message: string, details?: unknown);
 }
 /**
- * Type helper to extract D9InkContract type from an InkDescriptors
- */
-
-//#endregion
-//#region src/rpc-types.d.ts
-/**
- * Block header structure
+ * Error thrown when encoding call data fails
  */
-interface BlockHeader {
-  parentHash: HexString$1;
-  number: HexString$1;
-  stateRoot: HexString$1;
-  extrinsicsRoot: HexString$1;
-  digest: {
-    logs: HexString$1[];
-  };
+declare class EncodeError extends ContractError {
+  constructor(label: string, message: string, details?: unknown);
 }
 /**
- * System health information
+ * Error thrown when decoding response fails
  */
-interface SystemHealth {
-  peers: number;
-  isSyncing: boolean;
-  shouldHavePeers: boolean;
+declare class DecodeError extends ContractError {
+  constructor(label: string, message: string, details?: unknown);
 }
 /**
- * Runtime version information
+ * Error thrown for network/RPC errors
  */
-interface RuntimeVersion {
-  specName: string;
-  implName: string;
-  authoringVersion: number;
-  specVersion: number;
-  implVersion: number;
-  apis: [HexString$1, number][];
-  transactionVersion: number;
-  stateVersion: number;
+declare class NetworkError extends ContractError {
+  constructor(message: string, cause?: Error, details?: unknown);
 }
 /**
- * Storage change set
+ * Error thrown when contract returns an error result
  */
-interface StorageChangeSet {
-  block: HexString$1;
-  changes: [HexString$1, HexString$1 | null][];
+declare class ContractExecutionError extends ContractError {
+  readonly errorValue: unknown;
+  constructor(label: string, errorValue: unknown);
 }
 /**
- * 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.
+ * Error thrown for Ink LangError
  */
-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;
-  }];
+declare class LangError extends ContractError {
+  readonly variant: number;
+  constructor(label: string, variant: number);
 }
 /**
- * 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]);
- * ```
+ * Error thrown when request times out
  */
-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>;
+declare class TimeoutError extends ContractError {
+  readonly timeoutMs: number;
+  constructor(label: string, timeoutMs: number);
 }
-//#endregion
-//#region src/sdk.d.ts
 /**
- * Options for creating D9 Ink SDK
+ * Error thrown when request is aborted
  */
-
-/**
- * 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;
+declare class AbortedError extends ContractError {
+  constructor(label: string, reason?: string);
 }
 /**
- * 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
-/**
- * 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
+ * Error thrown for signer-related issues
  */
-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(descriptor: InkDescriptors$1<S, M$1, C, E>, contractAddress: SS58String$1);
-  /**
-   * 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): TypedContractEvent<E> | null;
-  /**
-   * 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);
-   * }
-   * ```
-   */
-  filterByType<L$1 extends string>(chainEvents: unknown[], label: L$1): Array<TypedContractEvent<E> & {
-    type: L$1;
-  }>;
-  /**
-   * Get the contract address as SS58 string
-   */
-  private getContractAddress;
-  /**
-   * Extract ContractEmitted event from chain event structure
-   * Based on polkadot-api event format
-   */
-  private extractContractEmittedEvent;
-  /**
-   * Compare two Uint8Arrays for equality
-   */
-  private bytesEqual;
+declare class SignerError extends ContractError {
+  constructor(message: string, details?: unknown);
 }
 /**
- * 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 descriptor - Contract descriptor
- * @param options - Subscription options
- * @returns Observable stream of type-safe contract events
+ * Error thrown when transaction submission fails
  */
-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[];
-  };
+declare class TransactionError extends ContractError {
+  readonly txHash?: string | undefined;
+  constructor(label: string, message: string, txHash?: string | undefined, details?: unknown);
 }
 /**
- * Convenience helper to create a Transfer event stream for PSP22 tokens
- *
- * @param client - Polkadot API client
- * @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<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
- *
- * This monitors System.Transfer events instead of contract events
- *
- * @param client - Polkadot API client
- * @param getEvents - Function to fetch System.Events at a block hash
- * @param watchAddress - Address to monitor for transfers
- * @returns Observable stream of native transfer events
- */
-declare function createNativeTransferStream(client: PolkadotClient, getEvents: (blockHash: string) => Promise<unknown[]>, watchAddress: SS58String$1): Observable<{
-  from: SS58String$1;
-  to: SS58String$1;
-  amount: bigint;
-  blockNumber: number;
-  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
+ * Type guard to check if an error is a ContractError
  */
-//#endregion
-//#region src/client.d.ts
-type CreateD9SdkClientOptions = {
-  endpoint: string;
-  wsProvider?: Parameters<typeof getWsProvider>[1];
-  metadata?: CreateClientOptions;
-};
+declare function isContractError(error: unknown): error is ContractError;
 /**
- * Create a D9 SDK client with ink contract support.
- *
- * This client uses state_call + ContractsApi_call for contract interactions
- * instead of ReviveApi, which is not supported on the D9 chain.
- *
- * @example
- * ```ts
- * const d9Client = createD9SdkClient({
- *   endpoint: "wss://archiver.d9network.com:40300",
- * });
- *
- * // Query USDT balance
- * const result = await d9Client.contracts.usdt.query("PSP22::balance_of", {
- *   origin: aliceAddress,
- *   args: { owner: aliceAddress },
- * });
- *
- * if (result.success) {
- *   console.log("Balance:", result.value.response);
- * }
- * ```
+ * Type guard to check for specific error types
  */
-declare function createD9SdkClient(options: CreateD9SdkClientOptions): {
-  client: polkadot_api0.PolkadotClient;
-  api: polkadot_api0.TypedApi<D9>;
-  inkSdk: D9InkSdkWithRpc;
+declare function isErrorType<T extends ContractErrorType>(error: unknown, type: T): error is ContractError & {
+  type: T;
 };
-type D9SdkClientReturn = ReturnType<typeof createD9SdkClient>;
 //#endregion
 //#region src/wallet/hex.d.ts
 declare function isHexString(input: unknown): input is HexString$1;
@@ -9495,5 +8716,5 @@ interface FormatDurationOptions {
  */
 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_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_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 };
+export { AbortedError, ArithmeticError, BLOCKS_PER_DAY, BLOCKS_PER_HOUR, BLOCKS_PER_MINUTE, BLOCKS_PER_WEEK, BalanceStatus, BalancesTypesReasons, ContractError, type ContractErrorType, ContractExecutionError, D9, D9Apis, D9CallData, D9Calls, D9Constants, D9DispatchError, D9Errors, D9Events, D9Extensions, D9Queries, D9ViewFns, D9WhitelistEntry, D9_BLOCK_TIME_MS, D9_DECIMALS, D9_SS58_PREFIX, D9_SYMBOL, D9_TOKEN, DecodeError, DigestItem, DispatchClass, EncodeError, FormatBalanceOptions, FormatDurationOptions, GrandpaEquivocation, GrandpaEvent, GrandpaStoredState, type HexString, LangError, MetadataError, MultiAddress, NetworkError, Phase, type PolkadotSigner, type SS58String, SessionEvent, SignerError, Sr25519Keypair, TimeoutError, TokenConfig, TransactionError, TransactionPaymentEvent, TransactionPaymentReleases, TransactionalError, USDT_DECIMALS, USDT_SYMBOL, USDT_TOKEN, WalletAccount, WhitelistEntriesByChain, WhitelistEntry, addressesEqual, blocksToMs, blocksUntil, bytesToHex, index_d_exports as contracts, createAccountFromMnemonic, createAccountFromPrivateKey, createSr25519SignerFromKeypair, _allDescriptors as d9, estimateBlockAtTime, estimateTimeAtBlock, formatBalance, formatBlockDuration, formatTokenAmount, generateMnemonic, getAddressPrefix, getMetadata, hexToBytes, isContractError, isErrorType, isHexString, isValidAddress, isValidAddressForNetwork, isValidD9Address, mnemonicToMiniSecret, msToBlocks, parseAmount, sr25519AddressFromKeypair, sr25519AddressFromSecretKeyHex, sr25519DeriveFromMiniSecret, sr25519KeypairFromMiniSecret, ss58DecodePublicKey, ss58Reencode, toD9Address, toNetworkAddress, validateMnemonic };
 //# sourceMappingURL=index.d.cts.map