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/microblock/MicroblockProof.d.ts ADDED Viewed

@@ -0,0 +1,439 @@
+import * as val from 'valibot';
+export declare const MicroblockProofSchema: val.ObjectSchema<{
+    readonly block: val.ObjectSchema<{
+        readonly height: val.NumberSchema<undefined>;
+        readonly vbRadixHash: val.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: val.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: val.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: val.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: val.ObjectSchema<{
+        readonly virtualBlockchainId: val.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: val.NumberSchema<undefined>;
+        readonly hash: val.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+    }, undefined>;
+    readonly virtualBlockchain: val.ObjectSchema<{
+        readonly state: val.VariantSchema<"type", [val.ObjectSchema<{
+            readonly internalState: val.ObjectSchema<{
+                readonly signatureSchemeId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>;
+                readonly publicKeyHeight: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MinValueAction<number, 0, undefined>]>;
+            }, undefined>;
+            readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly expirationDay: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly lastMicroblockHash: val.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: val.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: val.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.ACCOUNT_VIRTUAL_BLOCKCHAIN, undefined>;
+        }, undefined>, val.ObjectSchema<{
+            readonly internalState: val.ObjectSchema<{
+                readonly accountId: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MinValueAction<number, 0, undefined>]>;
+            }, undefined>;
+            readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly expirationDay: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly lastMicroblockHash: val.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: val.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: val.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.ORGANIZATION_VIRTUAL_BLOCKCHAIN, undefined>;
+        }, undefined>, val.ObjectSchema<{
+            readonly internalState: val.ObjectSchema<{
+                readonly organizationId: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MinValueAction<number, 0, undefined>]>;
+                readonly rpcEndpointHeight: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MinValueAction<number, 0, undefined>]>;
+                readonly lastKnownApprovalStatus: val.SchemaWithPipe<readonly [val.BooleanSchema<undefined>, val.MetadataAction<boolean, {
+                    readonly typeId: 4;
+                }>]>;
+            }, undefined>;
+            readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly expirationDay: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly lastMicroblockHash: val.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: val.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: val.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.NODE_VIRTUAL_BLOCKCHAIN, undefined>;
+        }, undefined>, val.ObjectSchema<{
+            readonly internalState: val.ObjectSchema<{
+                readonly organizationId: val.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: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MinValueAction<number, 0, undefined>]>;
+            }, undefined>;
+            readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly expirationDay: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly lastMicroblockHash: val.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: val.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: val.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.APPLICATION_VIRTUAL_BLOCKCHAIN, undefined>;
+        }, undefined>, val.ObjectSchema<{
+            readonly internalState: val.ObjectSchema<{
+                readonly allowedAdditionalWriters: val.ArraySchema<val.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: val.ArraySchema<val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>, undefined>;
+                readonly allowedPkeSchemeIds: val.ArraySchema<val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                    readonly typeId: 3;
+                }>]>, undefined>;
+                readonly applicationId: val.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: val.ArraySchema<val.ObjectSchema<{
+                    readonly name: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+                        size: number;
+                        readonly typeId: 2;
+                    }>]>;
+                    readonly isPrivate: val.SchemaWithPipe<readonly [val.BooleanSchema<undefined>, val.MetadataAction<boolean, {
+                        readonly typeId: 4;
+                    }>]>;
+                    readonly creatorId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                        readonly typeId: 3;
+                    }>]>;
+                }, undefined>, undefined>;
+                readonly actors: val.ArraySchema<val.ObjectSchema<{
+                    readonly name: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+                        size: number;
+                        readonly typeId: 2;
+                    }>]>;
+                    readonly subscribed: val.SchemaWithPipe<readonly [val.BooleanSchema<undefined>, val.MetadataAction<boolean, {
+                        readonly typeId: 4;
+                    }>]>;
+                    readonly signatureKeyHeight: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                        readonly typeId: 3;
+                    }>]>;
+                    readonly pkeKeyHeight: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                        readonly typeId: 3;
+                    }>]>;
+                    readonly sharedSecrets: val.ArraySchema<val.ObjectSchema<{
+                        readonly peerActorId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                            readonly typeId: 3;
+                        }>]>;
+                        readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MinValueAction<number, 0, undefined>]>;
+                    }, undefined>, undefined>;
+                    readonly invitations: val.ArraySchema<val.ObjectSchema<{
+                        readonly channelId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                            readonly typeId: 3;
+                        }>]>;
+                        readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MinValueAction<number, 0, undefined>]>;
+                    }, undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>;
+            readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly expirationDay: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly lastMicroblockHash: val.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: val.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: val.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.APP_LEDGER_VIRTUAL_BLOCKCHAIN, undefined>;
+        }, undefined>, val.ObjectSchema<{
+            readonly internalState: val.ObjectSchema<{
+                readonly organizationId: val.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: val.ObjectSchema<{
+                    readonly protocolVersionName: val.StringSchema<undefined>;
+                    readonly protocolVersion: val.NumberSchema<undefined>;
+                    readonly feesCalculationVersion: val.NumberSchema<undefined>;
+                    readonly globalStateUpdaterVersion: val.NumberSchema<undefined>;
+                    readonly applicationLedgerInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+                    readonly applicationInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+                    readonly organizationInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+                    readonly validatorNodeInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+                    readonly accountInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+                    readonly protocolInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+                    readonly minimumNodeStakingAmountInAtomics: val.NumberSchema<undefined>;
+                    readonly maximumNodeStakingAmountInAtomics: val.NumberSchema<undefined>;
+                    readonly unstakingDelayInDays: val.NumberSchema<undefined>;
+                    readonly maxBlockSizeInBytes: val.NumberSchema<undefined>;
+                    readonly retentionPolicy: val.ArraySchema<val.ObjectSchema<{
+                        readonly retentionRatio: val.NumberSchema<undefined>;
+                        readonly maximumNumberOfDays: val.NumberSchema<undefined>;
+                        readonly dayDivisor: val.NumberSchema<undefined>;
+                    }, undefined>, undefined>;
+                    readonly abciVersion: val.NumberSchema<undefined>;
+                }, undefined>;
+                readonly protocolUpdates: val.ArraySchema<val.ObjectSchema<{
+                    readonly protocolVersion: val.NumberSchema<undefined>;
+                    readonly protocolVersionName: val.StringSchema<undefined>;
+                    readonly changeLog: val.StringSchema<undefined>;
+                    readonly protocolVariables: val.ObjectSchema<{
+                        readonly protocolVersionName: val.StringSchema<undefined>;
+                        readonly protocolVersion: val.NumberSchema<undefined>;
+                        readonly feesCalculationVersion: val.NumberSchema<undefined>;
+                        readonly globalStateUpdaterVersion: val.NumberSchema<undefined>;
+                        readonly applicationLedgerInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+                        readonly applicationInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+                        readonly organizationInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+                        readonly validatorNodeInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+                        readonly accountInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+                        readonly protocolInternalStateUpdaterVersion: val.NumberSchema<undefined>;
+                        readonly minimumNodeStakingAmountInAtomics: val.NumberSchema<undefined>;
+                        readonly maximumNodeStakingAmountInAtomics: val.NumberSchema<undefined>;
+                        readonly unstakingDelayInDays: val.NumberSchema<undefined>;
+                        readonly maxBlockSizeInBytes: val.NumberSchema<undefined>;
+                        readonly retentionPolicy: val.ArraySchema<val.ObjectSchema<{
+                            readonly retentionRatio: val.NumberSchema<undefined>;
+                            readonly maximumNumberOfDays: val.NumberSchema<undefined>;
+                            readonly dayDivisor: val.NumberSchema<undefined>;
+                        }, undefined>, undefined>;
+                        readonly abciVersion: val.NumberSchema<undefined>;
+                    }, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>;
+            readonly height: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly expirationDay: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.MetadataAction<number, {
+                readonly typeId: 3;
+            }>]>;
+            readonly lastMicroblockHash: val.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: val.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: val.LiteralSchema<import("../../../VirtualBlockchainType").VirtualBlockchainType.PROTOCOL_VIRTUAL_BLOCKCHAIN, undefined>;
+        }, undefined>], undefined>;
+        readonly merkleWitnesses: val.ArraySchema<val.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: val.ArraySchema<val.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+export type MicroblockProof = val.InferOutput<typeof MicroblockProofSchema>;
+//# sourceMappingURL=MicroblockProof.d.ts.map

package/dist/type/valibot/blockchain/microblock/MicroblockProof.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"MicroblockProof.d.ts","sourceRoot":"","sources":["../../../../../src/type/valibot/blockchain/microblock/MicroblockProof.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,SAAS,CAAC;AAI/B,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAqBhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

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

	@@ -1 +1 @@
1	- {"version":3,"file":"internalStates.d.ts","sourceRoot":"","sources":["../../../../../src/type/valibot/blockchain/virtualBlockchain/internalStates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,SAAS,CAAC;~~AAS~~/B,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAI9C,CAAC;AACH,MAAM,MAAM,6BAA6B,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,mCAAmC,CAAC,CAAC;~~AAMxG~~,eAAO,MAAM,2CAA2C;;;;;aAGtD,CAAC;AACH,MAAM,MAAM,4BAA4B,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,2CAA2C,CAAC,CAAC;~~AAM~~/G,eAAO,MAAM,uCAAuC;;;;;;;;;;;;aAGlD,CAAC;AACH,MAAM,MAAM,iCAAiC,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,uCAAuC,CAAC,CAAC;~~AAMhH~~,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;aAKnD,CAAC;AACH,MAAM,MAAM,kCAAkC,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,wCAAwC,CAAC,CAAC;~~AAMlH~~,eAAO,MAAM,sCAAsC;;;;;;;;;;;;aAGjD,CAAC;AACH,MAAM,MAAM,gCAAgC,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,sCAAsC,CAAC,CAAC;~~AAM9G~~,eAAO,MAAM,8BAA8B;;;;;;;;;;;aAIzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAE9F,eAAO,MAAM,2CAA2C;;;;;aAGtD,CAAC;AACH,MAAM,MAAM,qCAAqC,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,2CAA2C,CAAC,CAAC;AAExH;;;;GAIG;AACH,eAAO,MAAM,wCAAwC;;;;;aAGnD,CAAC;AACH,MAAM,MAAM,kCAAkC,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,wCAAwC,CAAC,CAAC;AAElH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;aAOvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAE1F;;GAEG;AACH,eAAO,MAAM,0CAA0C;IACnD;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAOL,CAAC;AACH,MAAM,MAAM,oCAAoC,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,0CAA0C,CAAC,CAAC"}
1	+ {"version":3,"file":"internalStates.d.ts","sourceRoot":"","sources":["../../../../../src/type/valibot/blockchain/virtualBlockchain/internalStates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,SAAS,CAAC;AAM/B,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAI9C,CAAC;AACH,MAAM,MAAM,6BAA6B,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAGxG,eAAO,MAAM,2CAA2C;;;;;aAGtD,CAAC;AACH,MAAM,MAAM,4BAA4B,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,2CAA2C,CAAC,CAAC;AAG/G,eAAO,MAAM,uCAAuC;;;;;;;;;;;;aAGlD,CAAC;AACH,MAAM,MAAM,iCAAiC,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,uCAAuC,CAAC,CAAC;AAGhH,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;aAKnD,CAAC;AACH,MAAM,MAAM,kCAAkC,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,wCAAwC,CAAC,CAAC;AAGlH,eAAO,MAAM,sCAAsC;;;;;;;;;;;;aAGjD,CAAC;AACH,MAAM,MAAM,gCAAgC,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,sCAAsC,CAAC,CAAC;AAG9G,eAAO,MAAM,8BAA8B;;;;;;;;;;;aAIzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAE9F,eAAO,MAAM,2CAA2C;;;;;aAGtD,CAAC;AACH,MAAM,MAAM,qCAAqC,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,2CAA2C,CAAC,CAAC;AAExH;;;;GAIG;AACH,eAAO,MAAM,wCAAwC;;;;;aAGnD,CAAC;AACH,MAAM,MAAM,kCAAkC,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,wCAAwC,CAAC,CAAC;AAElH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;aAOvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAE1F;;GAEG;AACH,eAAO,MAAM,0CAA0C;IACnD;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAOL,CAAC;AACH,MAAM,MAAM,oCAAoC,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,0CAA0C,CAAC,CAAC"}