npm - @xyo-network/xl1-rpc - Versions diffs - 1.10.2 → 1.12.0 - Mend

@xyo-network/xl1-rpc 1.10.2 → 1.12.0

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

package/dist/neutral/types/schema/XyoProviderRpcSchemas.d.ts CHANGED Viewed

@@ -1,4 +1,298 @@
-import type { XyoProviderRpcMethodName } from '../XyoProviderRpc.ts';
-import type { RpcSchemaMap } from './RpcSchemaMap.ts';
-export declare const XyoProviderRpcSchemas: RpcSchemaMap<XyoProviderRpcMethodName>;
+import { z } from 'zod';
+export declare const XyoProviderRpcSchemas: {
+    xyoProvider_send: {
+        params: {
+            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                readonly __hex: true;
+            }>, {
+                readonly __address: true;
+            }>, string>>, z.ZodArray<z.ZodObject<{
+                schema: z.ZodString;
+            }, z.core.$catchall<z.ZodAny>>>, z.ZodArray<z.ZodObject<{
+                schema: z.ZodString;
+            }, z.core.$catchall<z.ZodAny>>>, z.ZodNumber, z.ZodNumber, z.ZodPipe<z.ZodObject<{
+                base: z.ZodBigInt;
+                gasLimit: z.ZodBigInt;
+                gasPrice: z.ZodBigInt;
+                priority: z.ZodBigInt;
+            }, z.core.$strip>, z.ZodTransform<{
+                base: import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>;
+                gasLimit: import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>;
+                gasPrice: import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>;
+                priority: import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>;
+            }, {
+                base: bigint;
+                gasLimit: bigint;
+                gasPrice: bigint;
+                priority: bigint;
+            }>>, z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                readonly __hex: true;
+            }>, {
+                readonly __address: true;
+            }>, string>>>], null>;
+            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                readonly __hex: true;
+            }>, {
+                readonly __address: true;
+            }>, string>>, z.ZodArray<z.ZodObject<{
+                schema: z.ZodString;
+            }, z.core.$catchall<z.ZodAny>>>, z.ZodArray<z.ZodObject<{
+                schema: z.ZodString;
+            }, z.core.$catchall<z.ZodAny>>>, z.ZodNumber, z.ZodNumber, z.ZodPipe<z.ZodObject<{
+                base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>;
+                gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>;
+                gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>;
+                priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>;
+            }, z.core.$strip>, z.ZodTransform<{
+                base: bigint;
+                gasLimit: bigint;
+                gasPrice: bigint;
+                priority: bigint;
+            }, {
+                base: import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>;
+                gasLimit: import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>;
+                gasPrice: import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>;
+                priority: import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>;
+            }>>, z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                readonly __hex: true;
+            }>, {
+                readonly __address: true;
+            }>, string>>>], null>;
+        };
+        result: {
+            to: z.ZodObject<{
+                schema: z.ZodLiteral<"network.xyo.boundwitness">;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                payload_hashes: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                payload_schemas: z.ZodArray<z.ZodString>;
+                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                $sourceQuery: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>, z.ZodNull]>>;
+                _hash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _dataHash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+                nbf: z.ZodNumber;
+                exp: z.ZodNumber;
+                fees: z.ZodObject<{
+                    base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                }, z.core.$strip>;
+                chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+                from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+                script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>;
+            from: z.ZodObject<{
+                schema: z.ZodLiteral<"network.xyo.boundwitness">;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                payload_hashes: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                payload_schemas: z.ZodArray<z.ZodString>;
+                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                $sourceQuery: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>, z.ZodNull]>>;
+                _hash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _dataHash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+                nbf: z.ZodNumber;
+                exp: z.ZodNumber;
+                fees: z.ZodObject<{
+                    base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                }, z.core.$strip>;
+                chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+                from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+                script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>;
+        };
+    };
+};
 //# sourceMappingURL=XyoProviderRpcSchemas.d.ts.map

package/dist/neutral/types/schema/XyoProviderRpcSchemas.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"XyoProviderRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoProviderRpcSchemas.ts"],"names":[],"mappings":"~~AAEA~~,OAAO,~~KAAK,~~EAAE,~~wBAAwB~~,EAAE,MAAM,~~sBAAsB,CAAA;AAKpE,OAAO,~~KAAK,~~EAAE,YAAY,EAAE,MAAM,mBAAmB,~~CAAA;~~AAErD~~,eAAO,MAAM,qBAAqB,~~EAAE,YAAY,CAAC,wBAAwB,CA2BxE,~~CAAA"}
1	+ {"version":3,"file":"XyoProviderRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoProviderRpcSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AASvB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BgB,CAAA"}

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

@@ -1,4 +1,232 @@
-import type { XyoRunnerRpcMethodName } from '../XyoRunnerRpc.ts';
-import type { RpcSchemaMap } from './RpcSchemaMap.ts';
-export declare const XyoRunnerRpcSchemas: RpcSchemaMap<XyoRunnerRpcMethodName>;
+import { z } from 'zod';
+export declare const XyoRunnerRpcSchemas: {
+    xyoRunner_broadcastTransaction: {
+        params: {
+            to: z.ZodTuple<[z.ZodTuple<[z.ZodObject<{
+                schema: z.ZodLiteral<"network.xyo.boundwitness">;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                payload_hashes: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                payload_schemas: z.ZodArray<z.ZodString>;
+                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                $sourceQuery: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>, z.ZodNull]>>;
+                _hash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _dataHash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+                nbf: z.ZodNumber;
+                exp: z.ZodNumber;
+                fees: z.ZodObject<{
+                    base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                }, z.core.$strip>;
+                chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+                from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+                script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                schema: z.ZodString;
+            }, z.core.$catchall<z.ZodAny>>>], null>], null>;
+            from: z.ZodTuple<[z.ZodTuple<[z.ZodObject<{
+                schema: z.ZodLiteral<"network.xyo.boundwitness">;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                payload_hashes: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                payload_schemas: z.ZodArray<z.ZodString>;
+                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                $sourceQuery: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>, z.ZodNull]>>;
+                _hash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _dataHash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+                nbf: z.ZodNumber;
+                exp: z.ZodNumber;
+                fees: z.ZodObject<{
+                    base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                }, z.core.$strip>;
+                chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+                from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+                script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                schema: z.ZodString;
+            }, z.core.$catchall<z.ZodAny>>>], null>], null>;
+        };
+        result: {
+            to: z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                readonly __hex: true;
+            }>, {
+                readonly __hash: true;
+            }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                readonly __hex: true;
+            }>, {
+                readonly __hash: true;
+            }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                readonly __hex: true;
+            }>, {
+                readonly __hash: true;
+            }>>>;
+            from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                readonly __hex: true;
+            }>, {
+                readonly __hash: true;
+            }>, string>>;
+        };
+    };
+};
 //# sourceMappingURL=XyoRunnerRpcSchemas.d.ts.map

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

	@@ -1 +1 @@
1	- {"version":3,"file":"XyoRunnerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoRunnerRpcSchemas.ts"],"names":[],"mappings":"~~AAEA~~,OAAO,~~KAAK,~~EAAE,~~sBAAsB~~,EAAE,MAAM,~~oBAAoB,CAAA;AAMhE,OAAO,~~KAAK,~~EAAE,YAAY,EAAE,MAAM,mBAAmB,~~CAAA;~~AAErD~~,eAAO,MAAM,mBAAmB,~~EAAE,YAAY,CAAC,sBAAsB,CAWpE,~~CAAA"}
1	+ {"version":3,"file":"XyoRunnerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoRunnerRpcSchemas.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWgB,CAAA"}