@xyo-network/xl1-rpc 4.0.10 → 4.0.12

package/dist/neutral/types/schema/StepViewerRpcSchemas.d.ts

@@ -1,215 +0,0 @@
-import { z } from 'zod';
-/** StepViewerRpcSchemas constant. */
-export declare const StepViewerRpcSchemas: {
-    randomizer: {
-        params: {
-            to: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodPipe<z.ZodInt, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                step: z.ZodNumber;
-            }, z.core.$strip>], null>;
-            from: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodPipe<z.ZodInt, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                step: z.ZodNumber;
-            }, z.core.$strip>], null>;
-        };
-        result: {
-            to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
-            from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>;
-        };
-    };
-    stake: {
-        params: {
-            to: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodPipe<z.ZodInt, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                step: z.ZodNumber;
-            }, z.core.$strip>], null>;
-            from: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodPipe<z.ZodInt, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                step: z.ZodNumber;
-            }, z.core.$strip>], null>;
-        };
-        result: {
-            to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
-            from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>;
-        };
-    };
-    stakers: {
-        params: {
-            to: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodPipe<z.ZodInt, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                step: z.ZodNumber;
-            }, z.core.$strip>], null>;
-            from: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodPipe<z.ZodInt, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                step: z.ZodNumber;
-            }, z.core.$strip>], null>;
-        };
-        result: {
-            to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
-            from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>;
-        };
-    };
-    weight: {
-        params: {
-            to: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodPipe<z.ZodInt, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                step: z.ZodNumber;
-            }, z.core.$strip>], null>;
-            from: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodPipe<z.ZodInt, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                step: z.ZodNumber;
-            }, z.core.$strip>], null>;
-        };
-        result: {
-            to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, bigint>>;
-            from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<bigint, string>>;
-        };
-    };
-    positionCount: {
-        params: {
-            to: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodPipe<z.ZodInt, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                step: z.ZodNumber;
-            }, z.core.$strip>], null>;
-            from: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodPipe<z.ZodInt, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                step: z.ZodNumber;
-            }, z.core.$strip>], null>;
-        };
-        result: {
-            to: z.ZodNumber;
-            from: z.ZodNumber;
-        };
-    };
-    positions: {
-        params: {
-            to: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodPipe<z.ZodInt, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                step: z.ZodNumber;
-            }, z.core.$strip>], null>;
-            from: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodPipe<z.ZodInt, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                step: z.ZodNumber;
-            }, z.core.$strip>], null>;
-        };
-        result: {
-            to: z.ZodArray<z.ZodPipe<z.ZodObject<{
-                amount: import("zod/mini").ZodMiniBigInt<bigint>;
-                addBlock: z.ZodNumber;
-                id: z.ZodNumber;
-                removeBlock: z.ZodNumber;
-                staked: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>;
-                staker: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>;
-                withdrawBlock: z.ZodNumber;
-            }, z.core.$strip>, z.ZodTransform<{
-                addBlock: number;
-                amount: import("@ariestools/sdk").BrandedHex;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-protocol").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-protocol").XyoQuantAddress;
-                withdrawBlock: number;
-            }, {
-                amount: bigint;
-                addBlock: number;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-protocol").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-protocol").XyoQuantAddress;
-                withdrawBlock: number;
-            }>>>;
-            from: z.ZodArray<z.ZodPipe<z.ZodObject<{
-                addBlock: z.ZodNumber;
-                id: z.ZodNumber;
-                removeBlock: z.ZodNumber;
-                staked: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>;
-                staker: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>;
-                withdrawBlock: z.ZodNumber;
-                amount: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-            }, z.core.$strip>, z.ZodTransform<{
-                addBlock: number;
-                amount: import("@xyo-network/xl1-protocol-lib").AttoXL1;
-                id: import("@xyo-network/xl1-protocol-lib").PositionId;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-protocol").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-protocol").XyoQuantAddress;
-                withdrawBlock: number;
-            }, {
-                addBlock: number;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-protocol").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-protocol").XyoQuantAddress;
-                withdrawBlock: number;
-                amount: import("@ariestools/sdk").BrandedHex;
-            }>>>;
-        };
-    };
-    stakerCount: {
-        params: {
-            to: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodPipe<z.ZodInt, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                step: z.ZodNumber;
-            }, z.core.$strip>], null>;
-            from: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodPipe<z.ZodInt, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                step: z.ZodNumber;
-            }, z.core.$strip>], null>;
-        };
-        result: {
-            to: z.ZodNumber;
-            from: z.ZodNumber;
-        };
-    };
-};
-/** StepViewerRpcSchemas type. */
-export type StepViewerRpcSchemas = typeof StepViewerRpcSchemas;
-//# sourceMappingURL=StepViewerRpcSchemas.d.ts.map

package/dist/neutral/types/schema/StepViewerRpcSchemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StepViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/StepViewerRpcSchemas.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,qCAAqC;AACrC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEa,CAAA;AAE9C,iCAAiC;AACjC,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA"}

package/dist/neutral/types/schema/TimeSyncViewerRpcSchema.d.ts

@@ -1,65 +0,0 @@
-import { z } from 'zod';
-/** TimeSyncViewerRpcSchemas constant. */
-export declare const TimeSyncViewerRpcSchemas: {
-    timeSyncViewer_convertTime: {
-        params: {
-            from: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>, z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>, z.ZodNumber], null>;
-            to: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>, z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>, z.ZodNumber], null>;
-        };
-        result: {
-            from: z.ZodNumber;
-            to: z.ZodNumber;
-        };
-    };
-    timeSyncViewer_currentTime: {
-        params: {
-            from: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>], null>;
-            to: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>], null>;
-        };
-        result: {
-            from: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>, z.ZodNumber], null>;
-            to: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>, z.ZodNumber], null>;
-        };
-    };
-    timeSyncViewer_currentTimeAndHash: {
-        params: {
-            from: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>], null>;
-            to: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>], null>;
-        };
-        result: {
-            from: z.ZodTuple<[z.ZodNumber, z.ZodNullable<z.ZodString>], null>;
-            to: z.ZodTuple<[z.ZodNumber, z.ZodNullable<z.ZodString>], null>;
-        };
-    };
-    timeSyncViewer_currentTimePayload: {
-        params: {
-            from: z.ZodDefault<z.ZodTuple<[], null>>;
-            to: z.ZodDefault<z.ZodTuple<[], null>>;
-        };
-        result: {
-            from: import("zod/mini").ZodMiniObject<{
-                schema: import("zod/mini").ZodMiniLiteral<"network.xyo.time" & {
-                    readonly __schema: true;
-                }>;
-                xl1: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
-                xl1Hash: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
-                ethereum: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
-                ethereumHash: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
-                epoch: import("zod/mini").ZodMiniNumber<number>;
-            }, z.core.$strip>;
-            to: import("zod/mini").ZodMiniObject<{
-                schema: import("zod/mini").ZodMiniLiteral<"network.xyo.time" & {
-                    readonly __schema: true;
-                }>;
-                xl1: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
-                xl1Hash: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
-                ethereum: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
-                ethereumHash: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
-                epoch: import("zod/mini").ZodMiniNumber<number>;
-            }, z.core.$strip>;
-        };
-    };
-};
-/** TimeSyncViewerRpcSchemas type. */
-export type TimeSyncViewerRpcSchemas = typeof TimeSyncViewerRpcSchemas;
-//# sourceMappingURL=TimeSyncViewerRpcSchema.d.ts.map

package/dist/neutral/types/schema/TimeSyncViewerRpcSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TimeSyncViewerRpcSchema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/TimeSyncViewerRpcSchema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,yCAAyC;AACzC,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCgB,CAAA;AAErD,qCAAqC;AACrC,MAAM,MAAM,wBAAwB,GAAG,OAAO,wBAAwB,CAAA"}

package/dist/neutral/types/schema/TransactionViewerRpcSchema.d.ts

@@ -1,105 +0,0 @@
-import { z } from 'zod/mini';
-/**
- * TransactionViewerRpcSchemas constant.
- *
- * Note: schemas for the deprecated TransactionViewerMethods aliases
- * (`transactionByHash`, `transactionByBlockHashAndIndex`,
- * `transactionByBlockNumberAndIndex`) live on XyoViewer
- * (xyoViewer_transactionByHash etc.). The TransactionViewer namespace
- * only exposes the canonical `byHash` method.
- */
-export declare const TransactionViewerRpcSchemas: {
-    transactionViewer_byHash: {
-        params: {
-            to: z.ZodMiniTuple<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>], null>;
-            from: z.ZodMiniTuple<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>], null>;
-        };
-        result: {
-            to: z.ZodMiniNullable<z.ZodMiniTuple<readonly [z.ZodMiniObject<{
-                schema: z.ZodMiniLiteral<"network.xyo.boundwitness" & {
-                    readonly __schema: true;
-                }>;
-                addresses: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-                payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
-                payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>>;
-                previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
-                $destination: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-                $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
-                $signatures: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>>;
-                nbf: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                exp: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                fees: z.ZodMiniObject<{
-                    base: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                    gasLimit: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                    gasPrice: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                    priority: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                }, z.core.$strip>;
-                chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                from: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>;
-                script: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-                _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
-                _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
-            }, z.core.$strip>, z.ZodMiniArray<z.ZodMiniObject<{
-                schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>;
-                _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
-                _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
-            }, z.core.$loose>>], null>>;
-            from: z.ZodMiniNullable<z.ZodMiniTuple<readonly [z.ZodMiniObject<{
-                schema: z.ZodMiniLiteral<"network.xyo.boundwitness" & {
-                    readonly __schema: true;
-                }>;
-                addresses: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-                payload_hashes: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
-                payload_schemas: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>>;
-                previous_hashes: z.ZodMiniArray<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
-                $destination: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-                $sourceQuery: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
-                $signatures: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>>;
-                nbf: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                exp: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                fees: z.ZodMiniObject<{
-                    base: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                    gasLimit: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                    gasPrice: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                    priority: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                }, z.core.$strip>;
-                chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                from: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>;
-                script: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-                _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
-                _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
-            }, z.core.$strip>, z.ZodMiniArray<z.ZodMiniObject<{
-                schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>;
-                _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
-                _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
-            }, z.core.$loose>>], null>>;
-        };
-    };
-};
-/** TransactionViewerRpcSchemas type. */
-export type TransactionViewerRpcSchemas = typeof TransactionViewerRpcSchemas;
-//# sourceMappingURL=TransactionViewerRpcSchema.d.ts.map

package/dist/neutral/types/schema/TransactionViewerRpcSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TransactionViewerRpcSchema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/TransactionViewerRpcSchema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAK5B;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWgB,CAAA;AAExD,wCAAwC;AACxC,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAA"}

package/dist/neutral/types/schema/XyoPermissionsRpcSchemas.d.ts

@@ -1,79 +0,0 @@
-import { z } from 'zod';
-/** XyoPermissionsRpcSchemas constant. */
-export declare const XyoPermissionsRpcSchemas: {
-    xyoPermissions_getPermissions: {
-        params: {
-            to: z.ZodDefault<z.ZodTuple<[], null>>;
-            from: z.ZodDefault<z.ZodTuple<[], null>>;
-        };
-        result: {
-            to: z.ZodArray<z.ZodObject<{
-                parentCapability: z.ZodString;
-                caveats: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    type: z.ZodEnum<{
-                        chain: "chain";
-                        dataLakeAccess: "dataLakeAccess";
-                        expiration: "expiration";
-                        filteredResponse: "filteredResponse";
-                        rateLimit: "rateLimit";
-                        restrictReturnedAccounts: "restrictReturnedAccounts";
-                    }>;
-                    value: z.ZodJSONSchema;
-                }, z.core.$strip>>>;
-                invoker: z.ZodString;
-                date: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-            from: z.ZodArray<z.ZodObject<{
-                parentCapability: z.ZodString;
-                caveats: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    type: z.ZodEnum<{
-                        chain: "chain";
-                        dataLakeAccess: "dataLakeAccess";
-                        expiration: "expiration";
-                        filteredResponse: "filteredResponse";
-                        rateLimit: "rateLimit";
-                        restrictReturnedAccounts: "restrictReturnedAccounts";
-                    }>;
-                    value: z.ZodJSONSchema;
-                }, z.core.$strip>>>;
-                invoker: z.ZodString;
-                date: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-        };
-    };
-    xyoPermissions_requestPermissions: {
-        params: {
-            to: z.ZodTuple<[z.ZodArray<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>], null>;
-            from: z.ZodTuple<[z.ZodArray<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>], null>;
-        };
-        result: {
-            to: z.ZodArray<z.ZodObject<{
-                parentCapability: z.ZodString;
-                date: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-            from: z.ZodArray<z.ZodObject<{
-                parentCapability: z.ZodString;
-                date: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-        };
-    };
-    xyoPermissions_revokePermissions: {
-        params: {
-            to: z.ZodTuple<[z.ZodArray<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>], null>;
-            from: z.ZodTuple<[z.ZodArray<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>], null>;
-        };
-        result: {
-            to: z.ZodArray<z.ZodObject<{
-                parentCapability: z.ZodString;
-                date: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-            from: z.ZodArray<z.ZodObject<{
-                parentCapability: z.ZodString;
-                date: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-        };
-    };
-};
-/** XyoPermissionsRpcSchemas type. */
-export type XyoPermissionsRpcSchemas = typeof XyoPermissionsRpcSchemas;
-//# sourceMappingURL=XyoPermissionsRpcSchemas.d.ts.map

package/dist/neutral/types/schema/XyoPermissionsRpcSchemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"XyoPermissionsRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoPermissionsRpcSchemas.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,yCAAyC;AACzC,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BgB,CAAA;AAErD,qCAAqC;AACrC,MAAM,MAAM,wBAAwB,GAAG,OAAO,wBAAwB,CAAA"}

package/dist/neutral/types/schema/XyoRunnerRpcSchemas.d.ts

@@ -1,89 +0,0 @@
-import { z } from 'zod';
-/** XyoRunnerRpcSchemas constant. */
-export declare const XyoRunnerRpcSchemas: {
-    xyoRunner_broadcastTransaction: {
-        params: {
-            to: z.ZodTuple<[import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniObject<{
-                schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
-                    readonly __schema: true;
-                }>;
-                addresses: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-                payload_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
-                payload_schemas: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>>;
-                previous_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
-                $destination: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-                $sourceQuery: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
-                $signatures: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>>;
-                nbf: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                exp: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                fees: import("zod/mini").ZodMiniObject<{
-                    base: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                    gasLimit: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                    gasPrice: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                    priority: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                }, z.core.$strip>;
-                chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                from: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>;
-                script: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniString<string>>>;
-            }, z.core.$strip>, import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
-                schema: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>;
-            }, z.core.$strict>>], null>], null>;
-            from: z.ZodTuple<[import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniObject<{
-                schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
-                    readonly __schema: true;
-                }>;
-                addresses: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-                payload_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
-                payload_schemas: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>>;
-                previous_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
-                $destination: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-                $sourceQuery: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
-                $signatures: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>>;
-                nbf: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                exp: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                fees: import("zod/mini").ZodMiniObject<{
-                    base: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                    gasLimit: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                    gasPrice: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                    priority: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                }, z.core.$strip>;
-                chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
-                from: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>;
-                script: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniString<string>>>;
-            }, z.core.$strip>, import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
-                schema: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>;
-            }, z.core.$strict>>], null>], null>;
-        };
-        result: {
-            to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>, import("zod/mini").ZodMiniTransform<string, import("@ariestools/sdk").BrandedHash>>;
-            from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
-        };
-    };
-};
-/** XyoRunnerRpcSchemas type. */
-export type XyoRunnerRpcSchemas = typeof XyoRunnerRpcSchemas;
-//# sourceMappingURL=XyoRunnerRpcSchemas.d.ts.map

package/dist/neutral/types/schema/XyoRunnerRpcSchemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"XyoRunnerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoRunnerRpcSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,oCAAoC;AACpC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWgB,CAAA;AAEhD,gCAAgC;AAChC,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAA"}