npm - @cmts-dev/carmentis-sdk-core - Versions diffs - 1.2.14 → 1.2.15 - Mend

@cmts-dev/carmentis-sdk-core 1.2.14 → 1.2.15

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 (55) hide show

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

@@ -17,7 +17,9 @@ export declare enum AbciResponseType {
     GENESIS_SNAPSHOT = 28,
     RAW_BLOCK_CONTENT = 30,
     BLOCK_MODIFIED_ACCOUNTS = 32,
-    ACCOUNT_UPDATES = 34
+    ACCOUNT_UPDATES = 34,
+    SERIALIAZED_MICROBLOCK_BY_HEIGHT = 38,
+    MICROBLOCK_PROOF = 40
 }
 export declare const ErrorAbciResponseSchema: v.ObjectSchema<{
     readonly responseType: v.LiteralSchema<AbciResponseType.ERROR, undefined>;
@@ -170,16 +172,6 @@ export declare const VirtualBlockchainUpdateAbciResponseSchema: v.ObjectSchema<{
         from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
         from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
     }, undefined>;
-    readonly serializedHeaders: 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>;
 export declare const MicroblockInformationAbciResponseSchema: v.ObjectSchema<{
     readonly virtualBlockchainId: v.InstanceSchema<{
@@ -1790,31 +1782,9 @@ export declare const AccountUpdatesAbciResponseSchema: v.ObjectSchema<{
         }, undefined>, undefined>;
     }, undefined>, undefined>;
 }, undefined>;
-export declare const AbciResponseSchema: v.VariantSchema<"responseType", [v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.ERROR, undefined>;
-    readonly error: v.StringSchema<undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.CHAIN_INFORMATION, undefined>;
-    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-    readonly lastBlockTimestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-    readonly microblockCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-    readonly objectCounts: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.BLOCK_INFORMATION, undefined>;
-    readonly hash: 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 timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-    readonly proposerAddress: v.InstanceSchema<{
+export declare const SerializedMicroblockByHeightAbciResponseSchema: 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;
@@ -1824,269 +1794,91 @@ 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 applicationStateHashes: v.ObjectSchema<{
-        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 radixHash: 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>;
+export declare const MicroblockProofAbciResponseSchema: 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;
+                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>;
-    readonly size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-    readonly microblockCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-}, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.BLOCK_CONTENT, undefined>;
-    readonly microblocks: v.ArraySchema<v.ObjectSchema<{
-        readonly hash: 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 vbId: 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 vbType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
-        readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-        readonly size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-        readonly sectionCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-    }, undefined>, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.RAW_BLOCK_CONTENT, undefined>;
-    readonly partIndex: v.NumberSchema<undefined>;
-    readonly numberOfParts: v.NumberSchema<undefined>;
-    readonly serializedMicroblocks: 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.VIRTUAL_BLOCKCHAIN_STATE, undefined>;
-    readonly serializedVirtualBlockchainState: 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.VIRTUAL_BLOCKCHAIN_UPDATE, undefined>;
-    readonly exists: v.BooleanSchema<undefined>;
-    readonly changed: v.BooleanSchema<undefined>;
-    readonly serializedVirtualBlockchainState: 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 serializedHeaders: 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 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 virtualBlockchainType: v.NumberSchema<undefined>;
-    readonly header: v.ObjectSchema<{
-        readonly magicString: v.LiteralSchema<"CMTS", undefined>;
-        readonly protocolVersion: v.NumberSchema<undefined>;
-        readonly microblockType: v.NumberSchema<undefined>;
-        readonly height: v.NumberSchema<undefined>;
-        readonly previousHash: 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 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;
+                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.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 timestamp: v.NumberSchema<undefined>;
-        readonly gas: v.NumberSchema<undefined>;
-        readonly gasPrice: v.NumberSchema<undefined>;
-        readonly bodyHash: 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 feesPayerAccount: 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 responseType: v.LiteralSchema<AbciResponseType.MICROBLOCK_INFORMATION, undefined>;
-}, undefined>, 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 virtualBlockchainType: v.NumberSchema<undefined>;
-    readonly header: v.ObjectSchema<{
-        readonly magicString: v.LiteralSchema<"CMTS", undefined>;
-        readonly protocolVersion: v.NumberSchema<undefined>;
-        readonly microblockType: v.NumberSchema<undefined>;
-        readonly height: v.NumberSchema<undefined>;
-        readonly previousHash: 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 timestamp: v.NumberSchema<undefined>;
-        readonly gas: v.NumberSchema<undefined>;
-        readonly gasPrice: v.NumberSchema<undefined>;
-        readonly bodyHash: 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 feesPayerAccount: 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 responseType: v.LiteralSchema<AbciResponseType.MICROBLOCK_ANCHORING, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly responseType: v.LiteralSchema<AbciResponseType.MICROBLOCK_BODYS, undefined>;
-    readonly list: v.ArraySchema<v.ObjectSchema<{
-        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 microblockBody: v.ObjectSchema<{
-            readonly sections: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.AUXILIARY_SIGNATURE, undefined>;
-                readonly tag: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
-                    size: number;
-                    readonly typeId: 2;
+        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.MinValueAction<number, 0, undefined>]>;
+                }, undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
                 }>]>;
-                readonly signature: v.InstanceSchema<{
+                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;
@@ -2096,12 +1888,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 schemeId: 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;
-                }>]>;
-            }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.SIGNATURE, undefined>;
-                readonly signature: v.InstanceSchema<{
+                readonly merkleRootHash: v.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                     readonly prototype: Uint8Array<ArrayBufferLike>;
                     readonly BYTES_PER_ELEMENT: number;
@@ -2111,12 +1898,28 @@ 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 schemeId: 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 type: v.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.ACCOUNT_VIRTUAL_BLOCKCHAIN, undefined>;
             }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ALLOWED_ADDITIONAL_WRITER, undefined>;
-                readonly allowedWriterAccountId: v.InstanceSchema<{
+                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.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;
@@ -2126,11 +1929,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>;
-            }, undefined>, v.ObjectWithRestSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.CUSTOM, undefined>;
-            }, v.UnknownSchema, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_CREATION, undefined>;
-                readonly organizationId: v.InstanceSchema<{
+                readonly merkleRootHash: v.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                     readonly prototype: Uint8Array<ArrayBufferLike>;
                     readonly BYTES_PER_ELEMENT: number;
@@ -2140,39 +1939,32 @@ 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 type: v.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.ORGANIZATION_VIRTUAL_BLOCKCHAIN, undefined>;
             }, undefined>, 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.NumberSchema<undefined>;
-                    readonly feesCalculationVersion: v.NumberSchema<undefined>;
-                    readonly globalStateUpdaterVersion: v.NumberSchema<undefined>;
-                    readonly applicationLedgerInternalStateUpdaterVersion: v.NumberSchema<undefined>;
-                    readonly applicationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
-                    readonly organizationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
-                    readonly validatorNodeInternalStateUpdaterVersion: v.NumberSchema<undefined>;
-                    readonly accountInternalStateUpdaterVersion: v.NumberSchema<undefined>;
-                    readonly protocolInternalStateUpdaterVersion: v.NumberSchema<undefined>;
-                    readonly minimumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
-                    readonly maximumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
-                    readonly unstakingDelayInDays: v.NumberSchema<undefined>;
-                    readonly maxBlockSizeInBytes: v.NumberSchema<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.NumberSchema<undefined>;
+                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.MinValueAction<number, 0, undefined>]>;
+                    readonly rpcEndpointHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+                    readonly lastKnownApprovalStatus: v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.MetadataAction<boolean, {
+                        readonly typeId: 4;
+                    }>]>;
                 }, undefined>;
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_UPDATE, undefined>;
-            }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_VARIABLES, undefined>;
-                readonly protocolVariables: v.AnySchema;
-            }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_PUBLIC_KEY, undefined>;
-                readonly publicKey: v.InstanceSchema<{
+                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;
@@ -2182,17 +1974,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 schemeId: 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;
-                }>]>;
-            }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_TOKEN_ISSUANCE, undefined>;
-                readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
-                    readonly typeId: 3;
-                }>]>;
-            }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_CREATION, undefined>;
-                readonly sellerAccount: v.InstanceSchema<{
+                readonly merkleRootHash: v.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                     readonly prototype: Uint8Array<ArrayBufferLike>;
                     readonly BYTES_PER_ELEMENT: number;
@@ -2202,12 +1984,28 @@ 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                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.MinValueAction<number, 0, undefined>]>;
+                }, undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                     readonly typeId: 3;
                 }>]>;
-            }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_TRANSFER, undefined>;
-                readonly account: v.InstanceSchema<{
+                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;
@@ -2217,20 +2015,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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
-                    readonly typeId: 3;
-                }>]>;
-                readonly publicReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
-                    size: number;
-                    readonly typeId: 2;
-                }>]>;
-                readonly privateReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
-                    size: number;
-                    readonly typeId: 2;
-                }>]>;
-            }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_VESTING_TRANSFER, undefined>;
-                readonly account: v.InstanceSchema<{
+                readonly merkleRootHash: v.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                     readonly prototype: Uint8Array<ArrayBufferLike>;
                     readonly BYTES_PER_ELEMENT: number;
@@ -2240,26 +2025,675 @@ 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
-                    readonly typeId: 3;
-                }>]>;
-                readonly publicReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
-                    size: number;
-                    readonly typeId: 2;
-                }>]>;
-                readonly privateReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
-                    size: number;
-                    readonly typeId: 2;
-                }>]>;
-                readonly cliffDurationDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                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.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.MinValueAction<number, 0, undefined>]>;
+                        }, undefined>, undefined>;
+                    }, undefined>, undefined>;
+                }, undefined>;
+                readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                     readonly typeId: 3;
                 }>]>;
-                readonly vestingDurationDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                readonly expirationDay: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
                     readonly typeId: 3;
                 }>]>;
-            }, undefined>, v.ObjectSchema<{
-                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_ESCROW_TRANSFER, undefined>;
-                readonly account: v.InstanceSchema<{
+                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.NumberSchema<undefined>;
+                        readonly feesCalculationVersion: v.NumberSchema<undefined>;
+                        readonly globalStateUpdaterVersion: v.NumberSchema<undefined>;
+                        readonly applicationLedgerInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                        readonly applicationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                        readonly organizationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                        readonly validatorNodeInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                        readonly accountInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                        readonly protocolInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                        readonly minimumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                        readonly maximumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                        readonly unstakingDelayInDays: v.NumberSchema<undefined>;
+                        readonly maxBlockSizeInBytes: v.NumberSchema<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.NumberSchema<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.NumberSchema<undefined>;
+                            readonly feesCalculationVersion: v.NumberSchema<undefined>;
+                            readonly globalStateUpdaterVersion: v.NumberSchema<undefined>;
+                            readonly applicationLedgerInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                            readonly applicationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                            readonly organizationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                            readonly validatorNodeInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                            readonly accountInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                            readonly protocolInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                            readonly minimumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                            readonly maximumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                            readonly unstakingDelayInDays: v.NumberSchema<undefined>;
+                            readonly maxBlockSizeInBytes: v.NumberSchema<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.NumberSchema<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 AbciResponseSchema: v.VariantSchema<"responseType", [v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.ERROR, undefined>;
+    readonly error: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.CHAIN_INFORMATION, undefined>;
+    readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly lastBlockTimestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly microblockCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly objectCounts: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.BLOCK_INFORMATION, undefined>;
+    readonly hash: 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 timestamp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly proposerAddress: 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 applicationStateHashes: v.ObjectSchema<{
+        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 radixHash: 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 size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly microblockCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.BLOCK_CONTENT, undefined>;
+    readonly microblocks: v.ArraySchema<v.ObjectSchema<{
+        readonly hash: 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 vbId: 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 vbType: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 255, undefined>]>;
+        readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly sectionCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.RAW_BLOCK_CONTENT, undefined>;
+    readonly partIndex: v.NumberSchema<undefined>;
+    readonly numberOfParts: v.NumberSchema<undefined>;
+    readonly serializedMicroblocks: 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.VIRTUAL_BLOCKCHAIN_STATE, undefined>;
+    readonly serializedVirtualBlockchainState: 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.VIRTUAL_BLOCKCHAIN_UPDATE, undefined>;
+    readonly exists: v.BooleanSchema<undefined>;
+    readonly changed: v.BooleanSchema<undefined>;
+    readonly serializedVirtualBlockchainState: 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 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 virtualBlockchainType: v.NumberSchema<undefined>;
+    readonly header: v.ObjectSchema<{
+        readonly magicString: v.LiteralSchema<"CMTS", undefined>;
+        readonly protocolVersion: v.NumberSchema<undefined>;
+        readonly microblockType: v.NumberSchema<undefined>;
+        readonly height: v.NumberSchema<undefined>;
+        readonly previousHash: 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 timestamp: v.NumberSchema<undefined>;
+        readonly gas: v.NumberSchema<undefined>;
+        readonly gasPrice: v.NumberSchema<undefined>;
+        readonly bodyHash: 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 feesPayerAccount: 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 responseType: v.LiteralSchema<AbciResponseType.MICROBLOCK_INFORMATION, undefined>;
+}, undefined>, 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 virtualBlockchainType: v.NumberSchema<undefined>;
+    readonly header: v.ObjectSchema<{
+        readonly magicString: v.LiteralSchema<"CMTS", undefined>;
+        readonly protocolVersion: v.NumberSchema<undefined>;
+        readonly microblockType: v.NumberSchema<undefined>;
+        readonly height: v.NumberSchema<undefined>;
+        readonly previousHash: 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 timestamp: v.NumberSchema<undefined>;
+        readonly gas: v.NumberSchema<undefined>;
+        readonly gasPrice: v.NumberSchema<undefined>;
+        readonly bodyHash: 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 feesPayerAccount: 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 responseType: v.LiteralSchema<AbciResponseType.MICROBLOCK_ANCHORING, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly responseType: v.LiteralSchema<AbciResponseType.MICROBLOCK_BODYS, undefined>;
+    readonly list: v.ArraySchema<v.ObjectSchema<{
+        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 microblockBody: v.ObjectSchema<{
+            readonly sections: v.ArraySchema<v.VariantSchema<"type", [v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.AUXILIARY_SIGNATURE, undefined>;
+                readonly tag: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly signature: 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 schemeId: 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;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.SIGNATURE, undefined>;
+                readonly signature: 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 schemeId: 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;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ALLOWED_ADDITIONAL_WRITER, undefined>;
+                readonly allowedWriterAccountId: 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.ObjectWithRestSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.CUSTOM, undefined>;
+            }, v.UnknownSchema, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_CREATION, 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>;
+            }, undefined>, 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.NumberSchema<undefined>;
+                    readonly feesCalculationVersion: v.NumberSchema<undefined>;
+                    readonly globalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly applicationLedgerInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly applicationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly organizationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly validatorNodeInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly accountInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly protocolInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                    readonly minimumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly maximumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                    readonly unstakingDelayInDays: v.NumberSchema<undefined>;
+                    readonly maxBlockSizeInBytes: v.NumberSchema<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.NumberSchema<undefined>;
+                }, undefined>;
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_UPDATE, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.PROTOCOL_VARIABLES, undefined>;
+                readonly protocolVariables: v.AnySchema;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_PUBLIC_KEY, undefined>;
+                readonly publicKey: 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 schemeId: 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;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_TOKEN_ISSUANCE, undefined>;
+                readonly amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_CREATION, undefined>;
+                readonly sellerAccount: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_TRANSFER, undefined>;
+                readonly account: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly publicReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly privateReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_VESTING_TRANSFER, undefined>;
+                readonly account: 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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly publicReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly privateReference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CustomSchema<string, `Expected size is ${number} bytes`>, v.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly cliffDurationDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly vestingDurationDays: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+            }, undefined>, v.ObjectSchema<{
+                readonly type: v.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.ACCOUNT_ESCROW_TRANSFER, undefined>;
+                readonly account: v.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
                     readonly prototype: Uint8Array<ArrayBufferLike>;
                     readonly BYTES_PER_ELEMENT: number;
@@ -2841,10 +3275,201 @@ 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 currentState: v.ObjectSchema<{
+        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("../../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.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>, 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.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.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 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;
@@ -2854,11 +3479,45 @@ 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.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;
@@ -2868,7 +3527,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.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;
@@ -2878,7 +3568,42 @@ 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 cometbftPublicKeyDeclarationHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>;
+                    readonly rpcEndpointHeight: v.SchemaWithPipe<readonly [v.NumberSchema<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;
@@ -2888,23 +3613,133 @@ 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 descriptionHeight: v.SchemaWithPipe<readonly [v.NumberSchema<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 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 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.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.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 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;
@@ -2914,33 +3749,85 @@ 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.NumberSchema<undefined>;
+                        readonly feesCalculationVersion: v.NumberSchema<undefined>;
+                        readonly globalStateUpdaterVersion: v.NumberSchema<undefined>;
+                        readonly applicationLedgerInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                        readonly applicationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                        readonly organizationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                        readonly validatorNodeInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                        readonly accountInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                        readonly protocolInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                        readonly minimumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                        readonly maximumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                        readonly unstakingDelayInDays: v.NumberSchema<undefined>;
+                        readonly maxBlockSizeInBytes: v.NumberSchema<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.NumberSchema<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.NumberSchema<undefined>;
+                            readonly feesCalculationVersion: v.NumberSchema<undefined>;
+                            readonly globalStateUpdaterVersion: v.NumberSchema<undefined>;
+                            readonly applicationLedgerInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                            readonly applicationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                            readonly organizationInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                            readonly validatorNodeInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                            readonly accountInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                            readonly protocolInternalStateUpdaterVersion: v.NumberSchema<undefined>;
+                            readonly minimumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                            readonly maximumNodeStakingAmountInAtomics: v.NumberSchema<undefined>;
+                            readonly unstakingDelayInDays: v.NumberSchema<undefined>;
+                            readonly maxBlockSizeInBytes: v.NumberSchema<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.NumberSchema<undefined>;
+                        }, undefined>;
+                    }, undefined>, 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<{
+                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;
@@ -2949,11 +3836,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 amount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
-            readonly chainReference: v.InstanceSchema<{
+            }, 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;
@@ -2962,9 +3846,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>;
-        }, undefined>, undefined>;
-    }, undefined>, undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>;
 }, undefined>], undefined>;
 export type AbciResponse = v.InferOutput<typeof AbciResponseSchema>;
 export type ErrorAbciResponse = v.InferOutput<typeof ErrorAbciResponseSchema>;
@@ -2985,4 +3869,6 @@ export type ObjectListAbciResponse = v.InferOutput<typeof ObjectListAbciResponse
 export type GenesisSnapshotAbciResponse = v.InferOutput<typeof GenesisSnapshotAbciResponseSchema>;
 export type BlockModifiedAccountsAbciResponse = v.InferOutput<typeof BlockModifiedAccountsAbciResponseSchema>;
 export type AccountUpdatesAbciResponse = v.InferOutput<typeof AccountUpdatesAbciResponseSchema>;
+export type SerializedMicroblockByHeightAbciResponse = v.InferOutput<typeof SerializedMicroblockByHeightAbciResponseSchema>;
+export type MicroblockProofAbciResponse = v.InferOutput<typeof MicroblockProofAbciResponseSchema>;
 //# sourceMappingURL=AbciResponse.d.ts.map