npm - @cmts-dev/carmentis-sdk-core - Versions diffs - 1.2.32 → 1.2.34 - Mend

@cmts-dev/carmentis-sdk-core 1.2.32 → 1.2.34

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/dist/type/valibot/provider/abci/AbciResponse.d.ts CHANGED Viewed

@@ -1742,40 +1742,599 @@ export declare const MicroblockProofAbciResponseSchema: v.ObjectSchema<{
     readonly proof: v.ObjectSchema<{
         readonly block: v.ObjectSchema<{
             readonly height: v.NumberSchema<undefined>;
-            readonly vbRadixHash: v.StringSchema<undefined>;
-            readonly tokenRadixHash: v.StringSchema<undefined>;
-            readonly storageHash: v.StringSchema<undefined>;
-            readonly appHash: v.StringSchema<undefined>;
+            readonly vbRadixHash: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly tokenRadixHash: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly storageHash: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly appHash: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
         }, undefined>;
         readonly microblock: v.ObjectSchema<{
-            readonly virtualBlockchainId: v.StringSchema<undefined>;
+            readonly virtualBlockchainId: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
             readonly height: v.NumberSchema<undefined>;
-            readonly hash: v.StringSchema<undefined>;
+            readonly hash: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
         }, undefined>;
         readonly virtualBlockchain: v.ObjectSchema<{
-            readonly serializedState: v.StringSchema<undefined>;
-            readonly merkleWitnesses: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-            readonly radixProof: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+            readonly state: v.VariantSchema<"type", [v.ObjectSchema<{
+                readonly internalState: v.ObjectSchema<{
+                    readonly signatureSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                        readonly typeId: 3;
+                    }>]>;
+                    readonly publicKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                }, undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly lastMicroblockHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly merkleRootHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly type: v.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.ACCOUNT_VIRTUAL_BLOCKCHAIN, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly internalState: v.ObjectSchema<{
+                    readonly accountId: v.InstanceSchema<{
+                        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                        readonly prototype: Uint8Array<ArrayBufferLike>;
+                        readonly BYTES_PER_ELEMENT: number;
+                        of(...items: number[]): Uint8Array<ArrayBuffer>;
+                        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    }, undefined>;
+                    readonly descriptionHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                }, undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly lastMicroblockHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly merkleRootHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly type: v.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.ORGANIZATION_VIRTUAL_BLOCKCHAIN, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly internalState: v.ObjectSchema<{
+                    readonly organizationId: v.InstanceSchema<{
+                        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                        readonly prototype: Uint8Array<ArrayBufferLike>;
+                        readonly BYTES_PER_ELEMENT: number;
+                        of(...items: number[]): Uint8Array<ArrayBuffer>;
+                        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    }, undefined>;
+                    readonly cometbftPublicKeyDeclarationHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                    readonly rpcEndpointHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                    readonly lastKnownApprovalStatus: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                        readonly typeId: 4;
+                    }>]>;
+                }, undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly lastMicroblockHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly merkleRootHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly type: v.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.NODE_VIRTUAL_BLOCKCHAIN, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly internalState: v.ObjectSchema<{
+                    readonly organizationId: v.InstanceSchema<{
+                        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                        readonly prototype: Uint8Array<ArrayBufferLike>;
+                        readonly BYTES_PER_ELEMENT: number;
+                        of(...items: number[]): Uint8Array<ArrayBuffer>;
+                        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    }, undefined>;
+                    readonly descriptionHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                }, undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly lastMicroblockHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly merkleRootHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly type: v.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.APPLICATION_VIRTUAL_BLOCKCHAIN, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly internalState: v.ObjectSchema<{
+                    readonly allowedAdditionalWriters: v.ArraySchema<v.InstanceSchema<{
+                        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                        readonly prototype: Uint8Array<ArrayBufferLike>;
+                        readonly BYTES_PER_ELEMENT: number;
+                        of(...items: number[]): Uint8Array<ArrayBuffer>;
+                        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    }, undefined>, undefined>;
+                    readonly allowedSignatureSchemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                        readonly typeId: 3;
+                    }>]>, undefined>;
+                    readonly allowedPkeSchemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                        readonly typeId: 3;
+                    }>]>, undefined>;
+                    readonly applicationId: v.InstanceSchema<{
+                        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                        readonly prototype: Uint8Array<ArrayBufferLike>;
+                        readonly BYTES_PER_ELEMENT: number;
+                        of(...items: number[]): Uint8Array<ArrayBuffer>;
+                        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    }, undefined>;
+                    readonly channels: v.ArraySchema<v.ObjectSchema<{
+                        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                            size: number;
+                            readonly typeId: 2;
+                        }>]>;
+                        readonly isPrivate: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                            readonly typeId: 4;
+                        }>]>;
+                        readonly creatorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                            readonly typeId: 3;
+                        }>]>;
+                    }, undefined>, undefined>;
+                    readonly actors: v.ArraySchema<v.ObjectSchema<{
+                        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                            size: number;
+                            readonly typeId: 2;
+                        }>]>;
+                        readonly subscribed: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                            readonly typeId: 4;
+                        }>]>;
+                        readonly signatureKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                            readonly typeId: 3;
+                        }>]>;
+                        readonly pkeKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                            readonly typeId: 3;
+                        }>]>;
+                        readonly sharedSecrets: v.ArraySchema<v.ObjectSchema<{
+                            readonly peerActorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                                readonly typeId: 3;
+                            }>]>;
+                            readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        }, undefined>, undefined>;
+                        readonly invitations: v.ArraySchema<v.ObjectSchema<{
+                            readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                                readonly typeId: 3;
+                            }>]>;
+                            readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        }, undefined>, undefined>;
+                    }, undefined>, undefined>;
+                }, undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly lastMicroblockHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly merkleRootHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly type: v.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.APP_LEDGER_VIRTUAL_BLOCKCHAIN, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly internalState: v.ObjectSchema<{
+                    readonly organizationId: v.InstanceSchema<{
+                        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                        readonly prototype: Uint8Array<ArrayBufferLike>;
+                        readonly BYTES_PER_ELEMENT: number;
+                        of(...items: number[]): Uint8Array<ArrayBuffer>;
+                        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    }, undefined>;
+                    readonly currentProtocolVariables: v.ObjectSchema<{
+                        readonly protocolVersionName: v.StringSchema<undefined>;
+                        readonly protocolVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly feesCalculationVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly fixedGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly secp256k1SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly mlDsa65SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly pkmsSecp256k1SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly globalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly applicationLedgerInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly applicationInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly organizationInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly validatorNodeInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly accountInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly protocolInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly minimumNodeStakingAmountInAtomics: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly maximumNodeStakingAmountInAtomics: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly unstakingDelayInDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly maxBlockSizeInBytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly retentionPolicy: v.ArraySchema<v.ObjectSchema<{
+                            readonly retentionRatio: v.NumberSchema<undefined>;
+                            readonly maximumNumberOfDays: v.NumberSchema<undefined>;
+                            readonly dayDivisor: v.NumberSchema<undefined>;
+                        }, undefined>, undefined>;
+                        readonly abciVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly maxMicroblocksPerBlock: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    }, undefined>;
+                    readonly protocolUpdates: v.ArraySchema<v.ObjectSchema<{
+                        readonly protocolVersion: v.NumberSchema<undefined>;
+                        readonly protocolVersionName: v.StringSchema<undefined>;
+                        readonly changeLog: v.StringSchema<undefined>;
+                        readonly protocolVariables: v.ObjectSchema<{
+                            readonly protocolVersionName: v.StringSchema<undefined>;
+                            readonly protocolVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly feesCalculationVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly fixedGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                            readonly secp256k1SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                            readonly mlDsa65SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                            readonly pkmsSecp256k1SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                            readonly globalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly applicationLedgerInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly applicationInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly organizationInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly validatorNodeInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly accountInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly protocolInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly minimumNodeStakingAmountInAtomics: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly maximumNodeStakingAmountInAtomics: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly unstakingDelayInDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                            readonly maxBlockSizeInBytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly retentionPolicy: v.ArraySchema<v.ObjectSchema<{
+                                readonly retentionRatio: v.NumberSchema<undefined>;
+                                readonly maximumNumberOfDays: v.NumberSchema<undefined>;
+                                readonly dayDivisor: v.NumberSchema<undefined>;
+                            }, undefined>, undefined>;
+                            readonly abciVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly maxMicroblocksPerBlock: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        }, undefined>;
+                    }, undefined>, undefined>;
+                }, undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly lastMicroblockHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly merkleRootHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly type: v.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.PROTOCOL_VIRTUAL_BLOCKCHAIN, undefined>;
+            }, undefined>], undefined>;
+            readonly merkleWitnesses: v.ArraySchema<v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>, undefined>;
+            readonly radixProof: v.ArraySchema<v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>;
+}, undefined>;
+export declare const AccountProofAbciResponseSchema: v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_PROOF, undefined>;
+    readonly proof: v.ObjectSchema<{
+        readonly block: v.ObjectSchema<{
+            readonly height: v.NumberSchema<undefined>;
+            readonly vbRadixHash: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly tokenRadixHash: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly storageHash: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly appHash: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
         }, undefined>;
-    }, undefined>;
-}, undefined>;
-export declare const AccountProofAbciResponseSchema: v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_PROOF, undefined>;
-    readonly proof: v.ObjectSchema<{
-        readonly accounts: v.ArraySchema<v.ObjectSchema<{
-            readonly block: v.ObjectSchema<{
-                readonly height: v.NumberSchema<undefined>;
-                readonly vbRadixHash: v.StringSchema<undefined>;
-                readonly tokenRadixHash: v.StringSchema<undefined>;
-                readonly storageHash: v.StringSchema<undefined>;
-                readonly appHash: v.StringSchema<undefined>;
+        readonly account: v.ObjectSchema<{
+            readonly virtualBlockchainId: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly account: v.ObjectSchema<{
-                readonly virtualBlockchainId: v.StringSchema<undefined>;
-                readonly serializedState: v.StringSchema<undefined>;
-                readonly radixProof: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+            readonly state: v.ObjectSchema<{
+                readonly height: v.NumberSchema<undefined>;
+                readonly balance: v.NumberSchema<undefined>;
+                readonly lastHistoryHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly locks: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<import("../../account/Account").LockType.Escrow, undefined>;
+                    readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly parameters: v.ObjectSchema<{
+                        readonly escrowIdentifier: v.InstanceSchema<{
+                            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                            readonly prototype: Uint8Array<ArrayBufferLike>;
+                            readonly BYTES_PER_ELEMENT: number;
+                            of(...items: number[]): Uint8Array<ArrayBuffer>;
+                            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        }, undefined>;
+                        readonly fundEmitterAccountId: v.InstanceSchema<{
+                            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                            readonly prototype: Uint8Array<ArrayBufferLike>;
+                            readonly BYTES_PER_ELEMENT: number;
+                            of(...items: number[]): Uint8Array<ArrayBuffer>;
+                            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        }, undefined>;
+                        readonly transferAuthorizerAccountId: v.InstanceSchema<{
+                            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                            readonly prototype: Uint8Array<ArrayBufferLike>;
+                            readonly BYTES_PER_ELEMENT: number;
+                            of(...items: number[]): Uint8Array<ArrayBuffer>;
+                            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        }, undefined>;
+                        readonly startTimestamp: v.NumberSchema<undefined>;
+                        readonly durationDays: v.NumberSchema<undefined>;
+                    }, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<import("../../account/Account").LockType.Vesting, undefined>;
+                    readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly parameters: v.ObjectSchema<{
+                        readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
+                        readonly cliffStartTimestamp: v.NumberSchema<undefined>;
+                        readonly cliffDurationDays: v.NumberSchema<undefined>;
+                        readonly vestingDurationDays: v.NumberSchema<undefined>;
+                    }, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<import("../../account/Account").LockType.NodeStaking, undefined>;
+                    readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly parameters: v.ObjectSchema<{
+                        readonly validatorNodeId: v.InstanceSchema<{
+                            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                            readonly prototype: Uint8Array<ArrayBufferLike>;
+                            readonly BYTES_PER_ELEMENT: number;
+                            of(...items: number[]): Uint8Array<ArrayBuffer>;
+                            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        }, undefined>;
+                        readonly plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
+                        readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
+                        readonly slashed: v.BooleanSchema<undefined>;
+                        readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
+                        readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
+                    }, undefined>;
+                }, undefined>], undefined>, undefined>;
             }, undefined>;
-        }, undefined>, undefined>;
+            readonly radixProof: v.ArraySchema<v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>, undefined>;
+        }, undefined>;
     }, undefined>;
 }, undefined>;
 export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.ObjectSchema<{
@@ -2493,62 +3052,418 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                     from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                 }, undefined>;
             }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ACTOR_SUBSCRIPTION, undefined>;
-                readonly actorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-                readonly actorType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-                readonly organizationId: v.InstanceSchema<{
-                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
-                    readonly prototype: Uint8Array<ArrayBufferLike>;
-                    readonly BYTES_PER_ELEMENT: number;
-                    of(...items: number[]): Uint8Array<ArrayBuffer>;
-                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
-                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
-                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-                }, undefined>;
-                readonly signatureSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
-                    readonly typeId: number;
-                }>]>;
-                readonly signaturePublicKey: v.InstanceSchema<{
-                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
-                    readonly prototype: Uint8Array<ArrayBufferLike>;
-                    readonly BYTES_PER_ELEMENT: number;
-                    of(...items: number[]): Uint8Array<ArrayBuffer>;
-                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
-                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
-                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-                }, undefined>;
-                readonly pkeSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
-                    readonly typeId: number;
-                }>]>;
-                readonly pkePublicKey: v.InstanceSchema<{
-                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
-                    readonly prototype: Uint8Array<ArrayBufferLike>;
-                    readonly BYTES_PER_ELEMENT: number;
-                    of(...items: number[]): Uint8Array<ArrayBuffer>;
-                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
-                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
-                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ACTOR_SUBSCRIPTION, undefined>;
+                readonly actorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                readonly actorType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                readonly organizationId: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly signatureSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>;
+                readonly signaturePublicKey: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly pkeSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>;
+                readonly pkePublicKey: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_PUBLIC_CHANNEL_DATA, undefined>;
+                readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                readonly data: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_PRIVATE_CHANNEL_DATA, undefined>;
+                readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                readonly merkleRootHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly encryptedData: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_AUTHOR, undefined>;
+                readonly authorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ENDORSEMENT_REQUEST, undefined>;
+                readonly endorserId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+    }, undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_STATE, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly balance: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly lastHistoryHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+    readonly locks: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../../account/Account").LockType.Escrow, undefined>;
+        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+        readonly parameters: v.ObjectSchema<{
+            readonly escrowIdentifier: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly fundEmitterAccountId: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly transferAuthorizerAccountId: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly startTimestamp: v.NumberSchema<undefined>;
+            readonly durationDays: v.NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../../account/Account").LockType.Vesting, undefined>;
+        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+        readonly parameters: v.ObjectSchema<{
+            readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
+            readonly cliffStartTimestamp: v.NumberSchema<undefined>;
+            readonly cliffDurationDays: v.NumberSchema<undefined>;
+            readonly vestingDurationDays: v.NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly type: v.LiteralSchema<import("../../account/Account").LockType.NodeStaking, undefined>;
+        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+        readonly parameters: v.ObjectSchema<{
+            readonly validatorNodeId: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
+            readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
+            readonly slashed: v.BooleanSchema<undefined>;
+            readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
+            readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
+        }, undefined>;
+    }, undefined>], undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_HISTORY, undefined>;
+    readonly list: v.ArraySchema<v.ObjectSchema<{
+        readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly previousHistoryHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+            readonly typeId: 12;
+        }>]>;
+        readonly type: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
+        readonly publicReference: v.StringSchema<undefined>;
+        readonly privateReference: v.StringSchema<undefined>;
+        readonly timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly linkedAccount: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+            readonly typeId: 12;
+        }>]>;
+        readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly chainReference: v.VariantSchema<"type", [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/chainReference/ChainReference").ChainReferenceType.BLOCK, undefined>;
+            readonly height: v.NumberSchema<undefined>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/chainReference/ChainReference").ChainReferenceType.MICROBLOCK, undefined>;
+            readonly microblockHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+                readonly typeId: 12;
+            }>]>;
+        }, undefined>, v.ObjectSchema<{
+            readonly type: v.LiteralSchema<import("../../blockchain/chainReference/ChainReference").ChainReferenceType.SECTION, undefined>;
+            readonly microblockHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+                readonly typeId: 12;
+            }>]>;
+            readonly sectionIndex: v.NumberSchema<undefined>;
+        }, undefined>], undefined>;
+    }, undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_BY_PUBLIC_KEY_HASH, undefined>;
+    readonly accountHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.VALIDATOR_NODE_BY_ADDRESS, undefined>;
+    readonly validatorNodeHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.GENESIS_SNAPSHOT, undefined>;
+    readonly base64EncodedChunks: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.BLOCK_MODIFIED_ACCOUNTS, undefined>;
+    readonly modifiedAccounts: v.ArraySchema<v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_UPDATES, undefined>;
+    readonly list: v.ArraySchema<v.ObjectSchema<{
+        readonly accountHash: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly currentState: v.ObjectSchema<{
+            readonly height: v.NumberSchema<undefined>;
+            readonly balance: v.NumberSchema<undefined>;
+            readonly lastHistoryHash: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly locks: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../account/Account").LockType.Escrow, undefined>;
+                readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                readonly parameters: v.ObjectSchema<{
+                    readonly escrowIdentifier: v.InstanceSchema<{
+                        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                        readonly prototype: Uint8Array<ArrayBufferLike>;
+                        readonly BYTES_PER_ELEMENT: number;
+                        of(...items: number[]): Uint8Array<ArrayBuffer>;
+                        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    }, undefined>;
+                    readonly fundEmitterAccountId: v.InstanceSchema<{
+                        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                        readonly prototype: Uint8Array<ArrayBufferLike>;
+                        readonly BYTES_PER_ELEMENT: number;
+                        of(...items: number[]): Uint8Array<ArrayBuffer>;
+                        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    }, undefined>;
+                    readonly transferAuthorizerAccountId: v.InstanceSchema<{
+                        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                        readonly prototype: Uint8Array<ArrayBufferLike>;
+                        readonly BYTES_PER_ELEMENT: number;
+                        of(...items: number[]): Uint8Array<ArrayBuffer>;
+                        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    }, undefined>;
+                    readonly startTimestamp: v.NumberSchema<undefined>;
+                    readonly durationDays: v.NumberSchema<undefined>;
+                }, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../account/Account").LockType.Vesting, undefined>;
+                readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                readonly parameters: v.ObjectSchema<{
+                    readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly cliffStartTimestamp: v.NumberSchema<undefined>;
+                    readonly cliffDurationDays: v.NumberSchema<undefined>;
+                    readonly vestingDurationDays: v.NumberSchema<undefined>;
                 }, undefined>;
             }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_PUBLIC_CHANNEL_DATA, undefined>;
-                readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-                readonly data: v.InstanceSchema<{
-                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
-                    readonly prototype: Uint8Array<ArrayBufferLike>;
-                    readonly BYTES_PER_ELEMENT: number;
-                    of(...items: number[]): Uint8Array<ArrayBuffer>;
-                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
-                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
-                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                readonly type: v.LiteralSchema<import("../../account/Account").LockType.NodeStaking, undefined>;
+                readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                readonly parameters: v.ObjectSchema<{
+                    readonly validatorNodeId: v.InstanceSchema<{
+                        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                        readonly prototype: Uint8Array<ArrayBufferLike>;
+                        readonly BYTES_PER_ELEMENT: number;
+                        of(...items: number[]): Uint8Array<ArrayBuffer>;
+                        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    }, undefined>;
+                    readonly plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
+                    readonly slashed: v.BooleanSchema<undefined>;
+                    readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
                 }, undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+        readonly historyUpdate: v.ArraySchema<v.ObjectSchema<{
+            readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly previousHistoryHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+                readonly typeId: 12;
+            }>]>;
+            readonly type: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
+            readonly publicReference: v.StringSchema<undefined>;
+            readonly privateReference: v.StringSchema<undefined>;
+            readonly timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly linkedAccount: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+                readonly typeId: 12;
+            }>]>;
+            readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly chainReference: v.VariantSchema<"type", [v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/chainReference/ChainReference").ChainReferenceType.BLOCK, undefined>;
+                readonly height: v.NumberSchema<undefined>;
             }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_PRIVATE_CHANNEL_DATA, undefined>;
-                readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-                readonly merkleRootHash: v.InstanceSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/chainReference/ChainReference").ChainReferenceType.MICROBLOCK, undefined>;
+                readonly microblockHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                     readonly prototype: Uint8Array<ArrayBufferLike>;
                     readonly BYTES_PER_ELEMENT: number;
@@ -2556,9 +3471,13 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                     from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
                     from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                     from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
-                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-                }, undefined>;
-                readonly encryptedData: v.InstanceSchema<{
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+                    readonly typeId: 12;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/chainReference/ChainReference").ChainReferenceType.SECTION, undefined>;
+                readonly microblockHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                     readonly prototype: Uint8Array<ArrayBufferLike>;
                     readonly BYTES_PER_ELEMENT: number;
@@ -2567,25 +3486,16 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                     from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                     from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                     from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-                }, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_AUTHOR, undefined>;
-                readonly authorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-            }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.APP_LEDGER_ENDORSEMENT_REQUEST, undefined>;
-                readonly endorserId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-                readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
-                    size: number;
-                    readonly typeId: 2;
+                }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+                    readonly typeId: 12;
                 }>]>;
-            }, undefined>], undefined>, undefined>;
-        }, undefined>;
+                readonly sectionIndex: v.NumberSchema<undefined>;
+            }, undefined>], undefined>;
+        }, undefined>, undefined>;
     }, undefined>, undefined>;
 }, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_STATE, undefined>;
-    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-    readonly balance: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-    readonly lastHistoryHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.SERIALIAZED_MICROBLOCK_BY_HEIGHT, undefined>;
+    readonly serializedContent: v.InstanceSchema<{
         new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
         readonly prototype: Uint8Array<ArrayBufferLike>;
         readonly BYTES_PER_ELEMENT: number;
@@ -2594,14 +3504,13 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
         from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
         from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
         from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-    }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
-        readonly typeId: 12;
-    }>]>;
-    readonly locks: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<import("../../account/Account").LockType.Escrow, undefined>;
-        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
-        readonly parameters: v.ObjectSchema<{
-            readonly escrowIdentifier: v.InstanceSchema<{
+    }, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.MICROBLOCK_PROOF, undefined>;
+    readonly proof: v.ObjectSchema<{
+        readonly block: v.ObjectSchema<{
+            readonly height: v.NumberSchema<undefined>;
+            readonly vbRadixHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -2611,7 +3520,7 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly fundEmitterAccountId: v.InstanceSchema<{
+            readonly tokenRadixHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -2621,7 +3530,7 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly transferAuthorizerAccountId: v.InstanceSchema<{
+            readonly storageHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -2631,23 +3540,7 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly startTimestamp: v.NumberSchema<undefined>;
-            readonly durationDays: v.NumberSchema<undefined>;
-        }, undefined>;
-    }, undefined>, v.ObjectSchema<{
-        readonly type: v.LiteralSchema<import("../../account/Account").LockType.Vesting, undefined>;
-        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
-        readonly parameters: v.ObjectSchema<{
-            readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
-            readonly cliffStartTimestamp: v.NumberSchema<undefined>;
-            readonly cliffDurationDays: v.NumberSchema<undefined>;
-            readonly vestingDurationDays: v.NumberSchema<undefined>;
-        }, undefined>;
-    }, undefined>, v.ObjectSchema<{
-        readonly type: v.LiteralSchema<import("../../account/Account").LockType.NodeStaking, undefined>;
-        readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
-        readonly parameters: v.ObjectSchema<{
-            readonly validatorNodeId: v.InstanceSchema<{
+            readonly appHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -2657,66 +3550,9 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
-            readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
-            readonly slashed: v.BooleanSchema<undefined>;
-            readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
-            readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
         }, undefined>;
-    }, undefined>], undefined>, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_HISTORY, undefined>;
-    readonly list: v.ArraySchema<v.ObjectSchema<{
-        readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-        readonly previousHistoryHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
-            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
-            readonly prototype: Uint8Array<ArrayBufferLike>;
-            readonly BYTES_PER_ELEMENT: number;
-            of(...items: number[]): Uint8Array<ArrayBuffer>;
-            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
-            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
-            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-        }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
-            readonly typeId: 12;
-        }>]>;
-        readonly type: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
-        readonly publicReference: v.StringSchema<undefined>;
-        readonly privateReference: v.StringSchema<undefined>;
-        readonly timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-        readonly linkedAccount: v.SchemaWithPipe<readonly [v.InstanceSchema<{
-            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
-            readonly prototype: Uint8Array<ArrayBufferLike>;
-            readonly BYTES_PER_ELEMENT: number;
-            of(...items: number[]): Uint8Array<ArrayBuffer>;
-            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
-            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
-            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-        }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
-            readonly typeId: 12;
-        }>]>;
-        readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-        readonly chainReference: v.VariantSchema<"type", [v.ObjectSchema<{
-            readonly type: v.LiteralSchema<import("../../blockchain/chainReference/ChainReference").ChainReferenceType.BLOCK, undefined>;
-            readonly height: v.NumberSchema<undefined>;
-        }, undefined>, v.ObjectSchema<{
-            readonly type: v.LiteralSchema<import("../../blockchain/chainReference/ChainReference").ChainReferenceType.MICROBLOCK, undefined>;
-            readonly microblockHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
-                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
-                readonly prototype: Uint8Array<ArrayBufferLike>;
-                readonly BYTES_PER_ELEMENT: number;
-                of(...items: number[]): Uint8Array<ArrayBuffer>;
-                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
-                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
-                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-            }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
-                readonly typeId: 12;
-            }>]>;
-        }, undefined>, v.ObjectSchema<{
-            readonly type: v.LiteralSchema<import("../../blockchain/chainReference/ChainReference").ChainReferenceType.SECTION, undefined>;
-            readonly microblockHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+        readonly microblock: v.ObjectSchema<{
+            readonly virtualBlockchainId: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -2725,72 +3561,9 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                 from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-            }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
-                readonly typeId: 12;
-            }>]>;
-            readonly sectionIndex: v.NumberSchema<undefined>;
-        }, undefined>], undefined>;
-    }, undefined>, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_BY_PUBLIC_KEY_HASH, undefined>;
-    readonly accountHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
-        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
-        readonly prototype: Uint8Array<ArrayBufferLike>;
-        readonly BYTES_PER_ELEMENT: number;
-        of(...items: number[]): Uint8Array<ArrayBuffer>;
-        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
-        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
-        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-    }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
-        readonly typeId: 12;
-    }>]>;
-}, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.VALIDATOR_NODE_BY_ADDRESS, undefined>;
-    readonly validatorNodeHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
-        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
-        readonly prototype: Uint8Array<ArrayBufferLike>;
-        readonly BYTES_PER_ELEMENT: number;
-        of(...items: number[]): Uint8Array<ArrayBuffer>;
-        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
-        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
-        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-    }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
-        readonly typeId: 12;
-    }>]>;
-}, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.GENESIS_SNAPSHOT, undefined>;
-    readonly base64EncodedChunks: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.BLOCK_MODIFIED_ACCOUNTS, undefined>;
-    readonly modifiedAccounts: v.ArraySchema<v.InstanceSchema<{
-        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
-        readonly prototype: Uint8Array<ArrayBufferLike>;
-        readonly BYTES_PER_ELEMENT: number;
-        of(...items: number[]): Uint8Array<ArrayBuffer>;
-        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
-        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
-        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-    }, undefined>, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_UPDATES, undefined>;
-    readonly list: v.ArraySchema<v.ObjectSchema<{
-        readonly accountHash: v.InstanceSchema<{
-            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
-            readonly prototype: Uint8Array<ArrayBufferLike>;
-            readonly BYTES_PER_ELEMENT: number;
-            of(...items: number[]): Uint8Array<ArrayBuffer>;
-            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
-            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
-            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-        }, undefined>;
-        readonly currentState: v.ObjectSchema<{
+            }, undefined>;
             readonly height: v.NumberSchema<undefined>;
-            readonly balance: v.NumberSchema<undefined>;
-            readonly lastHistoryHash: v.InstanceSchema<{
+            readonly hash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -2800,11 +3573,131 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
             }, undefined>;
-            readonly locks: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../account/Account").LockType.Escrow, undefined>;
-                readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
-                readonly parameters: v.ObjectSchema<{
-                    readonly escrowIdentifier: v.InstanceSchema<{
+        }, undefined>;
+        readonly virtualBlockchain: v.ObjectSchema<{
+            readonly state: v.VariantSchema<"type", [v.ObjectSchema<{
+                readonly internalState: v.ObjectSchema<{
+                    readonly signatureSchemeId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                        readonly typeId: 3;
+                    }>]>;
+                    readonly publicKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                }, undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly lastMicroblockHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly merkleRootHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly type: v.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.ACCOUNT_VIRTUAL_BLOCKCHAIN, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly internalState: v.ObjectSchema<{
+                    readonly accountId: v.InstanceSchema<{
+                        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                        readonly prototype: Uint8Array<ArrayBufferLike>;
+                        readonly BYTES_PER_ELEMENT: number;
+                        of(...items: number[]): Uint8Array<ArrayBuffer>;
+                        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    }, undefined>;
+                    readonly descriptionHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                }, undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly lastMicroblockHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly merkleRootHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly type: v.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.ORGANIZATION_VIRTUAL_BLOCKCHAIN, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly internalState: v.ObjectSchema<{
+                    readonly organizationId: v.InstanceSchema<{
+                        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                        readonly prototype: Uint8Array<ArrayBufferLike>;
+                        readonly BYTES_PER_ELEMENT: number;
+                        of(...items: number[]): Uint8Array<ArrayBuffer>;
+                        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    }, undefined>;
+                    readonly cometbftPublicKeyDeclarationHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                    readonly rpcEndpointHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                    readonly lastKnownApprovalStatus: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                        readonly typeId: 4;
+                    }>]>;
+                }, undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly lastMicroblockHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly merkleRootHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly type: v.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.NODE_VIRTUAL_BLOCKCHAIN, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly internalState: v.ObjectSchema<{
+                    readonly organizationId: v.InstanceSchema<{
                         new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                         readonly prototype: Uint8Array<ArrayBufferLike>;
                         readonly BYTES_PER_ELEMENT: number;
@@ -2814,7 +3707,38 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                         from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                         from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                     }, undefined>;
-                    readonly fundEmitterAccountId: v.InstanceSchema<{
+                    readonly descriptionHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                }, undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly lastMicroblockHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly merkleRootHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly type: v.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.APPLICATION_VIRTUAL_BLOCKCHAIN, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly internalState: v.ObjectSchema<{
+                    readonly allowedAdditionalWriters: v.ArraySchema<v.InstanceSchema<{
                         new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                         readonly prototype: Uint8Array<ArrayBufferLike>;
                         readonly BYTES_PER_ELEMENT: number;
@@ -2823,8 +3747,14 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                         from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                         from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                         from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-                    }, undefined>;
-                    readonly transferAuthorizerAccountId: v.InstanceSchema<{
+                    }, undefined>, undefined>;
+                    readonly allowedSignatureSchemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                        readonly typeId: 3;
+                    }>]>, undefined>;
+                    readonly allowedPkeSchemeIds: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                        readonly typeId: 3;
+                    }>]>, undefined>;
+                    readonly applicationId: v.InstanceSchema<{
                         new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                         readonly prototype: Uint8Array<ArrayBufferLike>;
                         readonly BYTES_PER_ELEMENT: number;
@@ -2834,23 +3764,76 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                         from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                         from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                     }, undefined>;
-                    readonly startTimestamp: v.NumberSchema<undefined>;
-                    readonly durationDays: v.NumberSchema<undefined>;
+                    readonly channels: v.ArraySchema<v.ObjectSchema<{
+                        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                            size: number;
+                            readonly typeId: 2;
+                        }>]>;
+                        readonly isPrivate: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                            readonly typeId: 4;
+                        }>]>;
+                        readonly creatorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                            readonly typeId: 3;
+                        }>]>;
+                    }, undefined>, undefined>;
+                    readonly actors: v.ArraySchema<v.ObjectSchema<{
+                        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                            size: number;
+                            readonly typeId: 2;
+                        }>]>;
+                        readonly subscribed: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                            readonly typeId: 4;
+                        }>]>;
+                        readonly signatureKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                            readonly typeId: 3;
+                        }>]>;
+                        readonly pkeKeyHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                            readonly typeId: 3;
+                        }>]>;
+                        readonly sharedSecrets: v.ArraySchema<v.ObjectSchema<{
+                            readonly peerActorId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                                readonly typeId: 3;
+                            }>]>;
+                            readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        }, undefined>, undefined>;
+                        readonly invitations: v.ArraySchema<v.ObjectSchema<{
+                            readonly channelId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                                readonly typeId: 3;
+                            }>]>;
+                            readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        }, undefined>, undefined>;
+                    }, undefined>, undefined>;
                 }, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../account/Account").LockType.Vesting, undefined>;
-                readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
-                readonly parameters: v.ObjectSchema<{
-                    readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
-                    readonly cliffStartTimestamp: v.NumberSchema<undefined>;
-                    readonly cliffDurationDays: v.NumberSchema<undefined>;
-                    readonly vestingDurationDays: v.NumberSchema<undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly lastMicroblockHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly merkleRootHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                 }, undefined>;
+                readonly type: v.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.APP_LEDGER_VIRTUAL_BLOCKCHAIN, undefined>;
             }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../account/Account").LockType.NodeStaking, undefined>;
-                readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
-                readonly parameters: v.ObjectSchema<{
-                    readonly validatorNodeId: v.InstanceSchema<{
+                readonly internalState: v.ObjectSchema<{
+                    readonly organizationId: v.InstanceSchema<{
                         new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                         readonly prototype: Uint8Array<ArrayBufferLike>;
                         readonly BYTES_PER_ELEMENT: number;
@@ -2860,17 +3843,122 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                         from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                         from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                     }, undefined>;
-                    readonly plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
-                    readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
-                    readonly slashed: v.BooleanSchema<undefined>;
-                    readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
-                    readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
+                    readonly currentProtocolVariables: v.ObjectSchema<{
+                        readonly protocolVersionName: v.StringSchema<undefined>;
+                        readonly protocolVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly feesCalculationVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly fixedGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly secp256k1SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly mlDsa65SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly pkmsSecp256k1SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly globalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly applicationLedgerInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly applicationInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly organizationInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly validatorNodeInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly accountInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly protocolInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly minimumNodeStakingAmountInAtomics: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly maximumNodeStakingAmountInAtomics: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly unstakingDelayInDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                        readonly maxBlockSizeInBytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly retentionPolicy: v.ArraySchema<v.ObjectSchema<{
+                            readonly retentionRatio: v.NumberSchema<undefined>;
+                            readonly maximumNumberOfDays: v.NumberSchema<undefined>;
+                            readonly dayDivisor: v.NumberSchema<undefined>;
+                        }, undefined>, undefined>;
+                        readonly abciVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        readonly maxMicroblocksPerBlock: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                    }, undefined>;
+                    readonly protocolUpdates: v.ArraySchema<v.ObjectSchema<{
+                        readonly protocolVersion: v.NumberSchema<undefined>;
+                        readonly protocolVersionName: v.StringSchema<undefined>;
+                        readonly changeLog: v.StringSchema<undefined>;
+                        readonly protocolVariables: v.ObjectSchema<{
+                            readonly protocolVersionName: v.StringSchema<undefined>;
+                            readonly protocolVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly feesCalculationVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly fixedGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                            readonly secp256k1SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                            readonly mlDsa65SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                            readonly pkmsSecp256k1SignatureGasCost: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                            readonly globalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly applicationLedgerInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly applicationInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly organizationInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly validatorNodeInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly accountInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly protocolInternalStateUpdaterVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly minimumNodeStakingAmountInAtomics: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly maximumNodeStakingAmountInAtomics: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly unstakingDelayInDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+                            readonly maxBlockSizeInBytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly retentionPolicy: v.ArraySchema<v.ObjectSchema<{
+                                readonly retentionRatio: v.NumberSchema<undefined>;
+                                readonly maximumNumberOfDays: v.NumberSchema<undefined>;
+                                readonly dayDivisor: v.NumberSchema<undefined>;
+                            }, undefined>, undefined>;
+                            readonly abciVersion: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                            readonly maxMicroblocksPerBlock: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+                        }, undefined>;
+                    }, undefined>, undefined>;
                 }, undefined>;
-            }, undefined>], undefined>, undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly lastMicroblockHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly merkleRootHash: v.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly type: v.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.PROTOCOL_VIRTUAL_BLOCKCHAIN, undefined>;
+            }, undefined>], undefined>;
+            readonly merkleWitnesses: v.ArraySchema<v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>, undefined>;
+            readonly radixProof: v.ArraySchema<v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>, undefined>;
         }, undefined>;
-        readonly historyUpdate: v.ArraySchema<v.ObjectSchema<{
-            readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-            readonly previousHistoryHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+    }, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_PROOF, undefined>;
+    readonly proof: v.ObjectSchema<{
+        readonly block: v.ObjectSchema<{
+            readonly height: v.NumberSchema<undefined>;
+            readonly vbRadixHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -2879,14 +3967,8 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                 from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-            }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
-                readonly typeId: 12;
-            }>]>;
-            readonly type: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
-            readonly publicReference: v.StringSchema<undefined>;
-            readonly privateReference: v.StringSchema<undefined>;
-            readonly timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-            readonly linkedAccount: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+            }, undefined>;
+            readonly tokenRadixHash: v.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                 readonly prototype: Uint8Array<ArrayBufferLike>;
                 readonly BYTES_PER_ELEMENT: number;
@@ -2895,16 +3977,43 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                 from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                 from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-            }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
-                readonly typeId: 12;
-            }>]>;
-            readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-            readonly chainReference: v.VariantSchema<"type", [v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/chainReference/ChainReference").ChainReferenceType.BLOCK, undefined>;
+            }, undefined>;
+            readonly storageHash: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly appHash: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+        }, undefined>;
+        readonly account: v.ObjectSchema<{
+            readonly virtualBlockchainId: v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly state: v.ObjectSchema<{
                 readonly height: v.NumberSchema<undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/chainReference/ChainReference").ChainReferenceType.MICROBLOCK, undefined>;
-                readonly microblockHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+                readonly balance: v.NumberSchema<undefined>;
+                readonly lastHistoryHash: v.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                     readonly prototype: Uint8Array<ArrayBufferLike>;
                     readonly BYTES_PER_ELEMENT: number;
@@ -2913,77 +4022,86 @@ export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.Obje
                     from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
                     from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
                     from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-                }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
-                    readonly typeId: 12;
-                }>]>;
-            }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/chainReference/ChainReference").ChainReferenceType.SECTION, undefined>;
-                readonly microblockHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
-                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
-                    readonly prototype: Uint8Array<ArrayBufferLike>;
-                    readonly BYTES_PER_ELEMENT: number;
-                    of(...items: number[]): Uint8Array<ArrayBuffer>;
-                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
-                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
-                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-                }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
-                    readonly typeId: 12;
-                }>]>;
-                readonly sectionIndex: v.NumberSchema<undefined>;
-            }, undefined>], undefined>;
-        }, undefined>, undefined>;
-    }, undefined>, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.SERIALIAZED_MICROBLOCK_BY_HEIGHT, undefined>;
-    readonly serializedContent: v.InstanceSchema<{
-        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
-        readonly prototype: Uint8Array<ArrayBufferLike>;
-        readonly BYTES_PER_ELEMENT: number;
-        of(...items: number[]): Uint8Array<ArrayBuffer>;
-        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
-        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
-        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
-    }, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.MICROBLOCK_PROOF, undefined>;
-    readonly proof: v.ObjectSchema<{
-        readonly block: v.ObjectSchema<{
-            readonly height: v.NumberSchema<undefined>;
-            readonly vbRadixHash: v.StringSchema<undefined>;
-            readonly tokenRadixHash: v.StringSchema<undefined>;
-            readonly storageHash: v.StringSchema<undefined>;
-            readonly appHash: v.StringSchema<undefined>;
-        }, undefined>;
-        readonly microblock: v.ObjectSchema<{
-            readonly virtualBlockchainId: v.StringSchema<undefined>;
-            readonly height: v.NumberSchema<undefined>;
-            readonly hash: v.StringSchema<undefined>;
-        }, undefined>;
-        readonly virtualBlockchain: v.ObjectSchema<{
-            readonly serializedState: v.StringSchema<undefined>;
-            readonly merkleWitnesses: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-            readonly radixProof: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>;
-    }, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.ACCOUNT_PROOF, undefined>;
-    readonly proof: v.ObjectSchema<{
-        readonly accounts: v.ArraySchema<v.ObjectSchema<{
-            readonly block: v.ObjectSchema<{
-                readonly height: v.NumberSchema<undefined>;
-                readonly vbRadixHash: v.StringSchema<undefined>;
-                readonly tokenRadixHash: v.StringSchema<undefined>;
-                readonly storageHash: v.StringSchema<undefined>;
-                readonly appHash: v.StringSchema<undefined>;
-            }, undefined>;
-            readonly account: v.ObjectSchema<{
-                readonly virtualBlockchainId: v.StringSchema<undefined>;
-                readonly serializedState: v.StringSchema<undefined>;
-                readonly radixProof: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>;
+                readonly locks: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<import("../../account/Account").LockType.Escrow, undefined>;
+                    readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly parameters: v.ObjectSchema<{
+                        readonly escrowIdentifier: v.InstanceSchema<{
+                            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                            readonly prototype: Uint8Array<ArrayBufferLike>;
+                            readonly BYTES_PER_ELEMENT: number;
+                            of(...items: number[]): Uint8Array<ArrayBuffer>;
+                            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        }, undefined>;
+                        readonly fundEmitterAccountId: v.InstanceSchema<{
+                            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                            readonly prototype: Uint8Array<ArrayBufferLike>;
+                            readonly BYTES_PER_ELEMENT: number;
+                            of(...items: number[]): Uint8Array<ArrayBuffer>;
+                            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        }, undefined>;
+                        readonly transferAuthorizerAccountId: v.InstanceSchema<{
+                            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                            readonly prototype: Uint8Array<ArrayBufferLike>;
+                            readonly BYTES_PER_ELEMENT: number;
+                            of(...items: number[]): Uint8Array<ArrayBuffer>;
+                            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        }, undefined>;
+                        readonly startTimestamp: v.NumberSchema<undefined>;
+                        readonly durationDays: v.NumberSchema<undefined>;
+                    }, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<import("../../account/Account").LockType.Vesting, undefined>;
+                    readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly parameters: v.ObjectSchema<{
+                        readonly initialVestedAmountInAtomics: v.NumberSchema<undefined>;
+                        readonly cliffStartTimestamp: v.NumberSchema<undefined>;
+                        readonly cliffDurationDays: v.NumberSchema<undefined>;
+                        readonly vestingDurationDays: v.NumberSchema<undefined>;
+                    }, undefined>;
+                }, undefined>, v.ObjectSchema<{
+                    readonly type: v.LiteralSchema<import("../../account/Account").LockType.NodeStaking, undefined>;
+                    readonly lockedAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly parameters: v.ObjectSchema<{
+                        readonly validatorNodeId: v.InstanceSchema<{
+                            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                            readonly prototype: Uint8Array<ArrayBufferLike>;
+                            readonly BYTES_PER_ELEMENT: number;
+                            of(...items: number[]): Uint8Array<ArrayBuffer>;
+                            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                        }, undefined>;
+                        readonly plannedUnlockAmountInAtomics: v.NumberSchema<undefined>;
+                        readonly plannedUnlockTimestamp: v.NumberSchema<undefined>;
+                        readonly slashed: v.BooleanSchema<undefined>;
+                        readonly plannedSlashingAmountInAtomics: v.NumberSchema<undefined>;
+                        readonly plannedSlashingTimestamp: v.NumberSchema<undefined>;
+                    }, undefined>;
+                }, undefined>], undefined>, undefined>;
             }, undefined>;
-        }, undefined>, undefined>;
+            readonly radixProof: v.ArraySchema<v.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>, undefined>;
+        }, undefined>;
     }, undefined>;
 }, undefined>], undefined>;
 export type AbciResponse = v.InferOutput<typeof AbciResponseSchema>;