@xyo-network/xl1-rpc 1.15.1 → 1.15.3

package/dist/node/types/schema/XyoGatewayRpcSchemas.d.ts

@@ -1,437 +0,0 @@
-import type { Chain } from '@xyo-network/xl1-protocol';
-import * as z from 'zod';
-export declare const ChainConnectionZod: z.ZodObject<{
-    chainId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Chain, Chain>]>>;
-    name: z.ZodString;
-    url: z.ZodString;
-}, z.core.$strip>;
-export declare const CaveatTypesZod: z.ZodEnum<{
-    chain: "chain";
-    expiration: "expiration";
-    filteredResponse: "filteredResponse";
-    rateLimit: "rateLimit";
-}>;
-export declare const CaveatsZod: z.ZodObject<{
-    type: z.ZodEnum<{
-        chain: "chain";
-        expiration: "expiration";
-        filteredResponse: "filteredResponse";
-        rateLimit: "rateLimit";
-    }>;
-    value: z.ZodUnknown;
-}, z.core.$strip>;
-export declare const PermissionZod: z.ZodObject<{
-    capability: z.ZodString;
-    caveats: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            chain: "chain";
-            expiration: "expiration";
-            filteredResponse: "filteredResponse";
-            rateLimit: "rateLimit";
-        }>;
-        value: z.ZodUnknown;
-    }, z.core.$strip>>>;
-    invoker: z.ZodString;
-}, z.core.$strip>;
-export declare const InvokerPermissionZod: z.ZodObject<{
-    capability: z.ZodString;
-    caveats: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            chain: "chain";
-            expiration: "expiration";
-            filteredResponse: "filteredResponse";
-            rateLimit: "rateLimit";
-        }>;
-        value: z.ZodUnknown;
-    }, z.core.$strip>>>;
-    invoker: z.ZodString;
-    date: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type ChainConnection = z.infer<typeof ChainConnectionZod>;
-export declare const XyoGatewayRpcSchemas: {
-    xyoGateway_submitTransaction: {
-        params: {
-            from: z.ZodArray<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<Chain, string>>;
-                from: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
-                script: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
-                schema: z.ZodString;
-            }, z.core.$catchall<z.ZodAny>>>], null>>;
-            to: z.ZodArray<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<Chain, string>>;
-                from: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
-                script: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
-                schema: z.ZodString;
-            }, z.core.$catchall<z.ZodAny>>>], null>>;
-        };
-        result: {
-            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]>>;
-                block: z.ZodNumber;
-                chain: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
-                previous: z.ZodNullable<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>>>;
-                protocol: z.ZodOptional<z.ZodNumber>;
-                step_hashes: z.ZodOptional<z.ZodArray<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>>>>;
-                $epoch: z.ZodNumber;
-            }, z.core.$strip>;
-            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]>>;
-                block: z.ZodNumber;
-                chain: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
-                previous: z.ZodNullable<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>>>;
-                protocol: z.ZodOptional<z.ZodNumber>;
-                step_hashes: z.ZodOptional<z.ZodArray<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>>>>;
-                $epoch: z.ZodNumber;
-            }, z.core.$strip>;
-        };
-    };
-};
-//# sourceMappingURL=XyoGatewayRpcSchemas.d.ts.map

package/dist/node/types/schema/XyoGatewayRpcSchemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"XyoGatewayRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoGatewayRpcSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAA;AACtD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAA;AAEF,eAAO,MAAM,cAAc;;;;;EAAmE,CAAA;AAE9F,eAAO,MAAM,UAAU;;;;;;;;iBAGrB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;iBAIxB,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;iBAAwD,CAAA;AAEzF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EgB,CAAA"}

package/src/provider/client/PermissionsStore/MemoryPermissionsStore.ts

@@ -1,33 +0,0 @@
-import type { Promisable } from '@xylabs/promise'
-import type { InvokerPermission, Permission } from '@xyo-network/xl1-protocol'
-
-import type { PermissionsStore } from './PermissionsStore.ts'
-
-export class MemoryPermissionsStore implements PermissionsStore {
-  private readonly _store: Map<string, InvokerPermission> = new Map()
-
-  getPermissions(): Promisable<InvokerPermission[]> {
-    return [...this._store.values()]
-  }
-
-  requestPermissions(permissions: Permission[]): Promisable<boolean> {
-    const now = Date.now()
-    for (const perm of permissions) {
-      const key = this.getKey(perm)
-      this._store.set(key, { ...perm, date: now })
-    }
-    return true
-  }
-
-  revokePermissions(permissions: Permission[]): Promisable<boolean> {
-    for (const perm of permissions) {
-      const key = this.getKey(perm)
-      this._store.delete(key)
-    }
-    return true
-  }
-
-  private getKey(permission: Permission): string {
-    return `${permission.invoker}::${permission.capability}`
-  }
-}

package/src/provider/client/PermissionsStore/PermissionsStore.ts

@@ -1,8 +0,0 @@
-import type { Promisable } from '@xylabs/promise'
-import type { InvokerPermission, Permission } from '@xyo-network/xl1-protocol'
-
-export interface PermissionsStore {
-  getPermissions(): Promisable<InvokerPermission[]>
-  requestPermissions(permissions: Permission[]): Promisable<boolean>
-  revokePermissions(permissions: Permission[]): Promisable<boolean>
-}

package/src/provider/client/PermissionsStore/getPermissionsStoreFromTransport.ts

@@ -1,12 +0,0 @@
-import { type RpcTransport } from '../../../transport/index.ts'
-import type { XyoGatewayRpcSchemas } from '../../../types/index.ts'
-import type { PermissionsStore } from './PermissionsStore.ts'
-
-export const getPermissionsStoreFromTransport = (_transport: RpcTransport<typeof XyoGatewayRpcSchemas>): PermissionsStore => {
-  throw new Error('Not implemented')
-  // return {
-  //   getPermissions: () => transport.sendRequest('xyoGateway_getPermissions'),
-  //   requestPermissions: (permissions: Permission[]) => transport.sendRequest('xyoGateway_requestPermissions', permissions),
-  //   revokePermissions: (permissions: Permission[]) => transport.sendRequest('xyoGateway_revokePermissions', permissions),
-  // }
-}

package/src/provider/client/PermissionsStore/index.ts

@@ -1,3 +0,0 @@
-export * from './getPermissionsStoreFromTransport.ts'
-export * from './MemoryPermissionsStore.ts'
-export * from './PermissionsStore.ts'

package/src/provider/client/PermissionsStore/spec/MemoryPermissionsStore.spec.ts

@@ -1,78 +0,0 @@
-import type { Permission } from '@xyo-network/xl1-protocol'
-import {
-  beforeEach, describe, expect, it,
-} from 'vitest'
-
-import { MemoryPermissionsStore } from '../MemoryPermissionsStore.ts'
-
-describe('MemoryPermissionsStore', () => {
-  const invoker = 'https://example.com'
-  const capability = 'xyoViewer_chainId'
-  let store: MemoryPermissionsStore
-  const basePermission: Permission = { capability, invoker }
-
-  beforeEach(() => {
-    store = new MemoryPermissionsStore()
-  })
-
-  it('returns an empty list initially', async () => {
-    const permissions = await store.getPermissions()
-    expect(permissions).toEqual([])
-  })
-
-  it('adds and retrieves a permission', async () => {
-    const result = await store.requestPermissions([basePermission])
-    expect(result).toBe(true)
-
-    const permissions = await store.getPermissions()
-    expect(permissions.length).toBe(1)
-    expect(permissions[0].capability).toBe(basePermission.capability)
-    expect(permissions[0].invoker).toBe(basePermission.invoker)
-    expect(typeof permissions[0].date).toBe('number')
-  })
-
-  it('replaces an existing permission with the same key', async () => {
-    const original = { ...basePermission }
-    const updated = { ...basePermission }
-
-    await store.requestPermissions([original])
-    const originalDate = (await store.getPermissions())[0].date
-
-    await new Promise(r => setTimeout(r, 5)) // ensure timestamp difference
-    await store.requestPermissions([updated])
-    const updatedDate = (await store.getPermissions())[0].date
-
-    expect(updatedDate).toBeGreaterThan(originalDate!)
-  })
-
-  it('revokes a previously granted permission', async () => {
-    await store.requestPermissions([basePermission])
-    expect((await store.getPermissions()).length).toBe(1)
-
-    const result = await store.revokePermissions([basePermission])
-    expect(result).toBe(true)
-
-    const permissions = await store.getPermissions()
-    expect(permissions).toEqual([])
-  })
-
-  it('revoking a non-existent permission does nothing and returns true', async () => {
-    const result = await store.revokePermissions([basePermission])
-    expect(result).toBe(true)
-    expect(await store.getPermissions()).toEqual([])
-  })
-
-  it('can handle multiple permissions from different invokers', async () => {
-    const perms: Permission[] = [
-      { invoker: 'https://a.com', capability: 'xyo_1' },
-      { invoker: 'https://b.com', capability: 'xyo_2' },
-      { invoker: 'https://a.com', capability: 'xyo_3' },
-    ]
-
-    await store.requestPermissions(perms)
-    const results = await store.getPermissions()
-
-    expect(results.length).toBe(3)
-    expect(results.map(p => p.capability).toSorted((a, b) => a.localeCompare(b))).toEqual(['xyo_1', 'xyo_2', 'xyo_3'])
-  })
-})