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/blockchain/virtualBlockchain/virtualBlockchains.d.ts CHANGED Viewed

@@ -17,6 +17,16 @@ export declare const VirtualBlockchainSharedPropertiesSchema: 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 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>;
 }, undefined>;
 export declare const AccountVirtualBlockchainStateSchema: v.ObjectSchema<{
     readonly internalState: v.ObjectSchema<{
@@ -41,6 +51,16 @@ export declare const AccountVirtualBlockchainStateSchema: 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 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<VirtualBlockchainType.ACCOUNT_VIRTUAL_BLOCKCHAIN, undefined>;
 }, undefined>;
 export type AccountVirtualBlockchainState = v.InferOutput<typeof AccountVirtualBlockchainStateSchema>;
@@ -74,6 +94,16 @@ export declare const OrganizationVirtualBlockchainStateSchema: 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 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<VirtualBlockchainType.ORGANIZATION_VIRTUAL_BLOCKCHAIN, undefined>;
 }, undefined>;
 export type OrganizationVirtualBlockchainState = v.InferOutput<typeof OrganizationVirtualBlockchainStateSchema>;
@@ -111,6 +141,16 @@ export declare const ValidatorNodeVirtualBlockchainStateSchema: 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 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<VirtualBlockchainType.NODE_VIRTUAL_BLOCKCHAIN, undefined>;
 }, undefined>;
 export type ValidatorNodeVirtualBlockchainState = v.InferOutput<typeof ValidatorNodeVirtualBlockchainStateSchema>;
@@ -144,6 +184,16 @@ export declare const ApplicationVirtualBlockchainStateSchema: 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 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<VirtualBlockchainType.APPLICATION_VIRTUAL_BLOCKCHAIN, undefined>;
 }, undefined>;
 export type ApplicationVirtualBlockchainState = v.InferOutput<typeof ApplicationVirtualBlockchainStateSchema>;
@@ -231,6 +281,16 @@ export declare const ApplicationLedgerVirtualBlockchainStateSchema: v.ObjectSche
         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<VirtualBlockchainType.APP_LEDGER_VIRTUAL_BLOCKCHAIN, undefined>;
 }, undefined>;
 export type ApplicationLedgerVirtualBlockchainState = v.InferOutput<typeof ApplicationLedgerVirtualBlockchainStateSchema>;
@@ -312,6 +372,16 @@ export declare const ProtocolVirtualBlockchainStateSchema: 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 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<VirtualBlockchainType.PROTOCOL_VIRTUAL_BLOCKCHAIN, undefined>;
 }, undefined>;
 export type ProtocolVirtualBlockchainState = v.InferOutput<typeof ProtocolVirtualBlockchainStateSchema>;
@@ -338,6 +408,16 @@ export declare const VirtualBlockchainStateSchema: v.VariantSchema<"type", [v.Ob
         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<VirtualBlockchainType.ACCOUNT_VIRTUAL_BLOCKCHAIN, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly internalState: v.ObjectSchema<{
@@ -369,6 +449,16 @@ export declare const VirtualBlockchainStateSchema: v.VariantSchema<"type", [v.Ob
         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<VirtualBlockchainType.ORGANIZATION_VIRTUAL_BLOCKCHAIN, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly internalState: v.ObjectSchema<{
@@ -404,6 +494,16 @@ export declare const VirtualBlockchainStateSchema: v.VariantSchema<"type", [v.Ob
         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<VirtualBlockchainType.NODE_VIRTUAL_BLOCKCHAIN, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly internalState: v.ObjectSchema<{
@@ -435,6 +535,16 @@ export declare const VirtualBlockchainStateSchema: v.VariantSchema<"type", [v.Ob
         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<VirtualBlockchainType.APPLICATION_VIRTUAL_BLOCKCHAIN, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly internalState: v.ObjectSchema<{
@@ -520,6 +630,16 @@ export declare const VirtualBlockchainStateSchema: v.VariantSchema<"type", [v.Ob
         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<VirtualBlockchainType.APP_LEDGER_VIRTUAL_BLOCKCHAIN, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly internalState: v.ObjectSchema<{
@@ -599,6 +719,16 @@ export declare const VirtualBlockchainStateSchema: v.VariantSchema<"type", [v.Ob
         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<VirtualBlockchainType.PROTOCOL_VIRTUAL_BLOCKCHAIN, undefined>;
 }, undefined>], undefined>;
 export type VirtualBlockchainState = v.InferOutput<typeof VirtualBlockchainStateSchema>;

package/dist/type/valibot/blockchain/virtualBlockchain/virtualBlockchains.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"virtualBlockchains.d.ts","sourceRoot":"","sources":["../../../../../src/type/valibot/blockchain/virtualBlockchain/virtualBlockchains.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAC,qBAAqB,EAAC,MAAM,gCAAgC,CAAC;AAUrE,eAAO,MAAM,uCAAuC~~;;;;;;;;;;;;;;;;;aAIlD~~,CAAA;AAEF,eAAO,MAAM,mCAAmC~~;;;;;;;;;;;;;;;;;;;;;;;;~~aAI9C,CAAA;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAEtG,eAAO,MAAM,wCAAwC~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~aAInD,CAAA;AACF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wCAAwC,CAAC,CAAC;AAEhH,eAAO,MAAM,yCAAyC~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~aAIpD,CAAA;AACF,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAElH,eAAO,MAAM,uCAAuC~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~aAIlD,CAAA;AACF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,uCAAuC,CAAC,CAAC;AAE9G,eAAO,MAAM,6CAA6C~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~aAIxD,CAAA;AACF,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,6CAA6C,CAAC,CAAC;AAE1H,eAAO,MAAM,oCAAoC~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~aAI/C,CAAA;AACF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAExG,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAUxC,CAAA;AAGD,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAC"}
1	+ {"version":3,"file":"virtualBlockchains.d.ts","sourceRoot":"","sources":["../../../../../src/type/valibot/blockchain/virtualBlockchain/virtualBlockchains.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAC,qBAAqB,EAAC,MAAM,gCAAgC,CAAC;AAUrE,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;aAKlD,CAAA;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAI9C,CAAA;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAEtG,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAInD,CAAA;AACF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wCAAwC,CAAC,CAAC;AAEhH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAIpD,CAAA;AACF,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAElH,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAIlD,CAAA;AACF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,uCAAuC,CAAC,CAAC;AAE9G,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAIxD,CAAA;AACF,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,6CAA6C,CAAC,CAAC;AAE1H,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAI/C,CAAA;AACF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAExG,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAUxC,CAAA;AAGD,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

package/dist/type/valibot/provider/VirtualBlockchainStatus.d.ts CHANGED Viewed

@@ -23,6 +23,16 @@ export declare const VirtualBlockchainStatusSchema: 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 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<{
@@ -54,6 +64,16 @@ export declare const VirtualBlockchainStatusSchema: 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 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<{
@@ -89,6 +109,16 @@ export declare const VirtualBlockchainStatusSchema: 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 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<{
@@ -120,6 +150,16 @@ export declare const VirtualBlockchainStatusSchema: 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 merkleRootHash: v.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
         readonly type: v.LiteralSchema<import("../../VirtualBlockchainType").VirtualBlockchainType.APPLICATION_VIRTUAL_BLOCKCHAIN, undefined>;
     }, undefined>, v.ObjectSchema<{
         readonly internalState: v.ObjectSchema<{
@@ -205,6 +245,16 @@ export declare const VirtualBlockchainStatusSchema: 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 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<{
@@ -284,6 +334,16 @@ export declare const VirtualBlockchainStatusSchema: 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 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 microblockHashes: v.ArraySchema<v.InstanceSchema<{

package/dist/type/valibot/provider/VirtualBlockchainStatus.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"VirtualBlockchainStatus.d.ts","sourceRoot":"","sources":["../../../../src/type/valibot/provider/VirtualBlockchainStatus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAK7B,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAGxC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,6BAA6B,CAAC,CAAC"}
1	+ {"version":3,"file":"VirtualBlockchainStatus.d.ts","sourceRoot":"","sources":["../../../../src/type/valibot/provider/VirtualBlockchainStatus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAK7B,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAGxC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,6BAA6B,CAAC,CAAC"}

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

@@ -16,7 +16,10 @@ export declare enum AbciRequestType {
     GET_GENESIS_SNAPSHOT = 27,
     GET_RAW_BLOCK_CONTENT = 29,
     GET_BLOCK_MODIFIED_ACCOUNTS = 31,
-    GET_ACCOUNT_UPDATES = 33
+    GET_ACCOUNT_UPDATES = 33,
+    GET_MICROBLOCK_INFORMATION_BY_HEIGHT = 35,
+    GET_SERIALIZED_MICROBLOCK_BY_HEIGHT = 37,
+    GET_MICROBLOCK_PROOF = 39
 }
 export declare const GetChainInformationAbciRequestSchema: v.ObjectSchema<{
     readonly requestType: v.LiteralSchema<AbciRequestType.GET_CHAIN_INFORMATION, undefined>;
@@ -58,7 +61,18 @@ export declare const GetVirtualBlockchainUpdateAbciRequestSchema: v.ObjectSchema
     }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
         readonly typeId: 12;
     }>]>;
-    readonly knownHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly knownStateHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
 }, undefined>;
 export declare const GetMicroblockInformationAbciRequestSchema: v.ObjectSchema<{
     readonly requestType: v.LiteralSchema<AbciRequestType.GET_MICROBLOCK_INFORMATION, undefined>;
@@ -217,6 +231,53 @@ export declare const GetAccountUpdatesAbciRequestSchema: v.ObjectSchema<{
         }, undefined>;
     }, undefined>, undefined>;
 }, undefined>;
+export declare const GetMicroblockInformationByHeightAbciRequestSchema: v.ObjectSchema<{
+    readonly requestType: v.LiteralSchema<AbciRequestType.GET_MICROBLOCK_INFORMATION_BY_HEIGHT, undefined>;
+    readonly virtualBlockchainId: 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 height: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const GetSerializedMicroblockByHeightAbciRequestSchema: v.ObjectSchema<{
+    readonly requestType: v.LiteralSchema<AbciRequestType.GET_SERIALIZED_MICROBLOCK_BY_HEIGHT, undefined>;
+    readonly virtualBlockchainId: 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 height: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const GetMicroblockProofAbciRequestSchema: v.ObjectSchema<{
+    readonly requestType: v.LiteralSchema<AbciRequestType.GET_MICROBLOCK_PROOF, 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;
+    }>]>;
+}, undefined>;
 export declare const AbciRequestSchema: v.VariantSchema<"requestType", [v.ObjectSchema<{
     readonly requestType: v.LiteralSchema<AbciRequestType.GET_CHAIN_INFORMATION, undefined>;
 }, undefined>, v.ObjectSchema<{
@@ -253,7 +314,18 @@ export declare const AbciRequestSchema: v.VariantSchema<"requestType", [v.Object
     }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
         readonly typeId: 12;
     }>]>;
-    readonly knownHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly knownStateHash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>, v.CustomSchema<Uint8Array<ArrayBufferLike>, "Expected Uint8Array of 32 bytes">, v.MetadataAction<Uint8Array<ArrayBufferLike>, {
+        readonly typeId: 12;
+    }>]>;
 }, undefined>, v.ObjectSchema<{
     readonly requestType: v.LiteralSchema<AbciRequestType.GET_MICROBLOCK_INFORMATION, undefined>;
     readonly hash: v.SchemaWithPipe<readonly [v.InstanceSchema<{
@@ -399,6 +471,50 @@ export declare const AbciRequestSchema: v.VariantSchema<"requestType", [v.Object
             from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
         }, undefined>;
     }, undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly requestType: v.LiteralSchema<AbciRequestType.GET_MICROBLOCK_INFORMATION_BY_HEIGHT, undefined>;
+    readonly virtualBlockchainId: 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 height: v.NumberSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly requestType: v.LiteralSchema<AbciRequestType.GET_SERIALIZED_MICROBLOCK_BY_HEIGHT, undefined>;
+    readonly virtualBlockchainId: 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 height: v.NumberSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly requestType: v.LiteralSchema<AbciRequestType.GET_MICROBLOCK_PROOF, 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;
+    }>]>;
 }, undefined>], undefined>;
 export type AbciRequest = v.InferOutput<typeof AbciRequestSchema>;
 export type GetChainInformationAbciRequest = v.InferOutput<typeof GetChainInformationAbciRequestSchema>;
@@ -407,6 +523,7 @@ export type GetBlockContentAbciRequest = v.InferOutput<typeof GetBlockContentAbc
 export type GetVirtualBlockchainStateAbciRequest = v.InferOutput<typeof GetVirtualBlockchainStateAbciRequestSchema>;
 export type GetVirtualBlockchainUpdateAbciRequest = v.InferOutput<typeof GetVirtualBlockchainUpdateAbciRequestSchema>;
 export type GetMicroblockInformationAbciRequest = v.InferOutput<typeof GetMicroblockInformationAbciRequestSchema>;
+export type GetMicroblockInformationByHeightAbciRequest = v.InferOutput<typeof GetMicroblockInformationByHeightAbciRequestSchema>;
 export type AwaitMicroblockAnchoringAbciRequest = v.InferOutput<typeof AwaitMicroblockAnchoringAbciRequestSchema>;
 export type GetMicroblockBodysAbciRequest = v.InferOutput<typeof GetMicroblockBodysAbciRequestSchema>;
 export type GetAccountStateAbciRequest = v.InferOutput<typeof GetAccountStateAbciRequestSchema>;
@@ -418,4 +535,6 @@ export type GetGenesisSnapshotAbciRequest = v.InferOutput<typeof GetGenesisSnaps
 export type GetRawBlockContentAbciRequest = v.InferOutput<typeof GetRawBlockContentAbciRequestSchema>;
 export type GetBlockModifiedAccountsAbciRequest = v.InferOutput<typeof GetBlockModifiedAccountsAbciRequestSchema>;
 export type GetAccountUpdatesAbciRequest = v.InferOutput<typeof GetAccountUpdatesAbciRequestSchema>;
+export type GetSerializedMicroblockByHeightAbciRequest = v.InferOutput<typeof GetSerializedMicroblockByHeightAbciRequestSchema>;
+export type GetMicroblockProofAbciRequest = v.InferOutput<typeof GetMicroblockProofAbciRequestSchema>;
 //# sourceMappingURL=AbciRequest.d.ts.map

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

	@@ -1 +1 @@
1	- {"version":3,"file":"AbciRequest.d.ts","sourceRoot":"","sources":["../../../../../src/type/valibot/provider/abci/AbciRequest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAO7B,oBAAY,eAAe;IACvB,qBAAqB,IAAI;IACzB,qBAAqB,IAAI;IACzB,iBAAiB,IAAI;IACrB,4BAA4B,IAAI;IAChC,6BAA6B,IAAI;IACjC,0BAA0B,KAAK;IAC/B,0BAA0B,KAAK;IAC/B,oBAAoB,KAAK;IACzB,iBAAiB,KAAK;IACtB,mBAAmB,KAAK;IACxB,8BAA8B,KAAK;IACnC,6BAA6B,KAAK;IAClC,eAAe,KAAK;IACpB,oBAAoB,KAAK;IACzB,qBAAqB,KAAK;IAC1B,2BAA2B,KAAK;IAChC,mBAAmB,KAAK;~~CAC3B~~;AAOD,eAAO,MAAM,oCAAoC;;aAE/C,CAAC;AAGH,eAAO,MAAM,oCAAoC;;;aAG/C,CAAC;AAGH,eAAO,MAAM,gCAAgC;;;aAG3C,CAAC;AAGH,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;;aAGrD,CAAC;AAGH,eAAO,MAAM,2CAA2C~~;;;;;;;;;;;;;;;~~aAItD,CAAC;AAGH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;aAGpD,CAAC;AAGH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;aAGpD,CAAC;AAGH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;aAG9C,CAAC;AAGH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;aAG3C,CAAC;AAGH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;aAK7C,CAAC;AAGH,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;;aAGrD,CAAC;AAGH,eAAO,MAAM,0CAA0C;;;;;;;;;;;;aAGrD,CAAC;AAGH,eAAO,MAAM,8BAA8B;;;aAGzC,CAAC;AAGH,eAAO,MAAM,mCAAmC;;aAE9C,CAAC;AAGH,eAAO,MAAM,mCAAmC;;;;aAI9C,CAAC;AAEH,eAAO,MAAM,yCAAyC;;;aAGpD,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;aAG7C,CAAC;AAKH,eAAO,MAAM,iBAAiB~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAkB5B~~,CAAC;AAKH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oCAAoC,CAAC,CAAC;AACxG,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oCAAoC,CAAC,CAAC;AACxG,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAChG,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,0CAA0C,CAAC,CAAC;AACpH,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,2CAA2C,CAAC,CAAC;AACtH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAClH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAClH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mCAAmC,CAAC,CAAC;AACtG,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAChG,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kCAAkC,CAAC,CAAC;AACpG,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,0CAA0C,CAAC,CAAC;AACpH,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,0CAA0C,CAAC,CAAC;AACpH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAC5F,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mCAAmC,CAAC,CAAC;AACtG,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mCAAmC,CAAC,CAAC;AACtG,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAClH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kCAAkC,CAAC,CAAC"}
1	+ {"version":3,"file":"AbciRequest.d.ts","sourceRoot":"","sources":["../../../../../src/type/valibot/provider/abci/AbciRequest.ts"],"names":[],"mappings":"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"}