@xyo-network/xl1-rpc 1.15.2 → 1.15.4

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

@@ -1 +1 @@
-{"version":3,"file":"XyoViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoViewerRpcSchemas.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAcxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+MgB,CAAA"}
+{"version":3,"file":"XyoViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoViewerRpcSchemas.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAgBxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAidgB,CAAA"}

package/dist/neutral/types/schema/common/BlockBoundWitness.d.ts

@@ -73,7 +73,7 @@ export declare const BlockBoundWitnessZod: z.ZodObject<{
     }>>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
     block: z.ZodNumber;
-    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, 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>, {
@@ -133,7 +133,7 @@ export declare const BlockBoundWitnessWithStorageMetaZod: z.ZodObject<{
         readonly __hex: true;
     }>, unknown>>, z.ZodNull]>>;
     block: z.ZodNumber;
-    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, 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>, {
@@ -220,7 +220,7 @@ export declare const SignedBlockBoundWitnessZod: z.ZodObject<{
     }>>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
     block: z.ZodNumber;
-    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, 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>, {
@@ -307,7 +307,7 @@ export declare const SignedBlockBoundWitnessWithStorageMetaZod: z.ZodObject<{
     }>>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
     block: z.ZodNumber;
-    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, 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>, {

package/dist/neutral/types/schema/common/Chain.d.ts

@@ -1,4 +1,4 @@
-import type { Chain } from '@xyo-network/xl1-protocol';
+import type { ChainId } from '@xyo-network/xl1-protocol';
 import * as z from 'zod';
-export declare const ChainZod: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
+export declare const ChainZod: z.ZodPipe<z.ZodString, z.ZodTransform<ChainId, string>>;
 //# sourceMappingURL=Chain.d.ts.map

package/dist/neutral/types/schema/common/Chain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Chain.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Chain.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAA;AACtD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,QAAQ,uDAA4F,CAAA"}
+{"version":3,"file":"Chain.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Chain.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AACxD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,QAAQ,yDAAgG,CAAA"}

package/dist/neutral/types/schema/common/HydratedBlock.d.ts

@@ -72,7 +72,7 @@ export declare const HydratedBlockZod: z.ZodTuple<[z.ZodObject<{
     }>>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
     block: z.ZodNumber;
-    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, 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>, {
@@ -134,7 +134,7 @@ export declare const HydratedBlockWithStorageMetaZod: z.ZodTuple<[z.ZodObject<{
         readonly __hex: true;
     }>, unknown>>, z.ZodNull]>>;
     block: z.ZodNumber;
-    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, 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>, {
@@ -250,7 +250,7 @@ export declare const SignedHydratedBlockZod: z.ZodTuple<[z.ZodObject<{
     }>>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
     block: z.ZodNumber;
-    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, 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>, {
@@ -339,7 +339,7 @@ export declare const SignedHydratedBlockToJsonZod: z.ZodTuple<[z.ZodObject<{
     }>>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
     block: z.ZodNumber;
-    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, 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>, {
@@ -428,7 +428,7 @@ export declare const SignedHydratedBlockWithStorageMetaZod: z.ZodTuple<[z.ZodObj
     }>>>>;
     _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
     block: z.ZodNumber;
-    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").Chain, string>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, 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>, {

package/dist/neutral/types/schema/common/HydratedTransaction.d.ts

@@ -95,8 +95,8 @@ export declare const HydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
             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>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
     script: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>, z.ZodArray<z.ZodObject<{
     schema: z.ZodString;
@@ -197,8 +197,8 @@ export declare const UnsignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
             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>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
     script: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>, z.ZodArray<z.ZodObject<{
     schema: z.ZodString;
@@ -299,8 +299,8 @@ export declare const SignedHydratedTransactionZod: z.ZodTuple<[z.ZodObject<{
             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>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
     script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>, z.ZodArray<z.ZodObject<{
     schema: z.ZodString;
@@ -401,8 +401,8 @@ export declare const SignedHydratedTransactionToJsonZod: z.ZodPipe<z.ZodTuple<[z
             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>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
     script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>, z.ZodArray<z.ZodObject<{
     schema: z.ZodString;
@@ -443,8 +443,8 @@ export declare const SignedHydratedTransactionToJsonZod: z.ZodPipe<z.ZodTuple<[z
             readonly __hex: true;
         }>;
     };
-    chain: import("@xyo-network/xl1-protocol").Chain;
-    from: import("@xyo-network/xl1-protocol").Chain;
+    chain: import("@xyo-network/xl1-protocol").ChainId;
+    from: import("@xyo-network/xl1-protocol").ChainId;
     $destination?: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
         readonly __hex: true;
     }>, {
@@ -559,8 +559,8 @@ export declare const JsonToSignedHydratedTransactionZod: z.ZodPipe<z.ZodTuple<[z
             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>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
     script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>, z.ZodArray<z.ZodObject<{
     schema: z.ZodString;
@@ -601,8 +601,8 @@ export declare const JsonToSignedHydratedTransactionZod: z.ZodPipe<z.ZodTuple<[z
             readonly __hex: true;
         }>;
     };
-    chain: import("@xyo-network/xl1-protocol").Chain;
-    from: import("@xyo-network/xl1-protocol").Chain;
+    chain: import("@xyo-network/xl1-protocol").ChainId;
+    from: import("@xyo-network/xl1-protocol").ChainId;
     $destination?: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
         readonly __hex: true;
     }>, {

package/dist/neutral/types/schema/common/Permission.d.ts

@@ -4,6 +4,7 @@ export declare const CaveatTypesZod: z.ZodEnum<{
     expiration: "expiration";
     filteredResponse: "filteredResponse";
     rateLimit: "rateLimit";
+    restrictReturnedAccounts: "restrictReturnedAccounts";
 }>;
 export declare const CaveatsZod: z.ZodObject<{
     type: z.ZodEnum<{
@@ -11,30 +12,33 @@ export declare const CaveatsZod: z.ZodObject<{
         expiration: "expiration";
         filteredResponse: "filteredResponse";
         rateLimit: "rateLimit";
+        restrictReturnedAccounts: "restrictReturnedAccounts";
     }>;
     value: z.ZodJSONSchema;
 }, z.core.$strip>;
 export declare const PermissionZod: z.ZodObject<{
-    capability: z.ZodString;
+    parentCapability: z.ZodString;
     caveats: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             chain: "chain";
             expiration: "expiration";
             filteredResponse: "filteredResponse";
             rateLimit: "rateLimit";
+            restrictReturnedAccounts: "restrictReturnedAccounts";
         }>;
         value: z.ZodJSONSchema;
     }, z.core.$strip>>>;
     invoker: z.ZodString;
 }, z.core.$strip>;
 export declare const InvokerPermissionZod: z.ZodObject<{
-    capability: z.ZodString;
+    parentCapability: z.ZodString;
     caveats: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             chain: "chain";
             expiration: "expiration";
             filteredResponse: "filteredResponse";
             rateLimit: "rateLimit";
+            restrictReturnedAccounts: "restrictReturnedAccounts";
         }>;
         value: z.ZodJSONSchema;
     }, z.core.$strip>>>;
@@ -43,7 +47,7 @@ export declare const InvokerPermissionZod: z.ZodObject<{
 }, z.core.$strip>;
 export declare const PermissionRequestZod: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>;
 export declare const RequestedPermissionZod: z.ZodObject<{
-    capability: z.ZodString;
+    parentCapability: z.ZodString;
     date: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 //# sourceMappingURL=Permission.d.ts.map

package/dist/neutral/types/schema/common/Permission.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Permission.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Permission.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,cAAc;;;;;EAAmE,CAAA;AAE9F,eAAO,MAAM,UAAU;;;;;;;;iBAGrB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;iBAIxB,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;iBAAwD,CAAA;AAEzF,eAAO,MAAM,oBAAoB,8DAAsD,CAAA;AAEvF,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAA"}
+{"version":3,"file":"Permission.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Permission.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,cAAc;;;;;;EAA+F,CAAA;AAE1H,eAAO,MAAM,UAAU;;;;;;;;;iBAGrB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;iBAIxB,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;iBAAwD,CAAA;AAEzF,eAAO,MAAM,oBAAoB,8DAAsD,CAAA;AAEvF,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAA"}

package/dist/neutral/types/schema/common/Stake.d.ts

@@ -1,7 +1,7 @@
 import * as z from 'zod';
 export declare const StakeZod: z.ZodObject<{
-    addBlock: z.ZodNumber;
     amount: z.ZodBigInt;
+    addBlock: z.ZodNumber;
     id: z.ZodNumber;
     removeBlock: z.ZodNumber;
     staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
@@ -17,8 +17,8 @@ export declare const StakeZod: z.ZodObject<{
     withdrawBlock: z.ZodNumber;
 }, z.core.$strip>;
 export declare const StakeToJsonZod: z.ZodPipe<z.ZodObject<{
-    addBlock: z.ZodNumber;
     amount: z.ZodBigInt;
+    addBlock: z.ZodNumber;
     id: z.ZodNumber;
     removeBlock: z.ZodNumber;
     staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
@@ -51,8 +51,8 @@ export declare const StakeToJsonZod: z.ZodPipe<z.ZodObject<{
     }>;
     withdrawBlock: number;
 }, {
-    addBlock: number;
     amount: bigint;
+    addBlock: number;
     id: number;
     removeBlock: number;
     staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
@@ -69,7 +69,6 @@ export declare const StakeToJsonZod: z.ZodPipe<z.ZodObject<{
 }>>;
 export declare const JsonToStakeZod: z.ZodPipe<z.ZodObject<{
     addBlock: z.ZodNumber;
-    amount: z.ZodBigInt;
     id: z.ZodNumber;
     removeBlock: z.ZodNumber;
     staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
@@ -83,6 +82,11 @@ export declare const JsonToStakeZod: z.ZodPipe<z.ZodObject<{
         readonly __address: true;
     }>, string>>;
     withdrawBlock: z.ZodNumber;
+    amount: 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<{
     addBlock: number;
     amount: import("@xyo-network/xl1-protocol").AttoXL1;
@@ -101,7 +105,6 @@ export declare const JsonToStakeZod: z.ZodPipe<z.ZodObject<{
     withdrawBlock: number;
 }, {
     addBlock: number;
-    amount: bigint;
     id: number;
     removeBlock: number;
     staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
@@ -115,5 +118,8 @@ export declare const JsonToStakeZod: z.ZodPipe<z.ZodObject<{
         readonly __address: true;
     }>;
     withdrawBlock: number;
+    amount: import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>;
 }>>;
 //# sourceMappingURL=Stake.d.ts.map

package/dist/neutral/types/schema/common/Stake.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Stake.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Stake.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAOxB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;iBAenB,CAAA;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQxB,CAAA;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQxB,CAAA"}
+{"version":3,"file":"Stake.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Stake.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAOxB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;iBAcnB,CAAA;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQxB,CAAA;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQxB,CAAA"}

package/dist/neutral/types/schema/common/StepContext.d.ts

@@ -0,0 +1,6 @@
+import * as z from 'zod';
+export declare const StepContextZod: z.ZodObject<{
+    block: z.ZodNumber;
+    step: z.ZodNumber;
+}, z.core.$strip>;
+//# sourceMappingURL=StepContext.d.ts.map

package/dist/neutral/types/schema/common/StepContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StepContext.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/StepContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,cAAc;;;iBAGzB,CAAA"}

package/dist/neutral/types/schema/common/TransactionBoundWitness.d.ts

@@ -132,8 +132,8 @@ export declare const TransactionBoundWitnessZod: z.ZodObject<{
             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>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
     script: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export declare const SignedTransactionBoundWitnessZod: z.ZodObject<{
@@ -232,8 +232,8 @@ export declare const SignedTransactionBoundWitnessZod: z.ZodObject<{
             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>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
     script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>;
 //# sourceMappingURL=TransactionBoundWitness.d.ts.map

package/dist/neutral/types/schema/common/Transfer.d.ts

@@ -0,0 +1,33 @@
+import z from 'zod';
+export declare const TransferFieldsZod: z.ZodObject<{
+    epoch: z.ZodNumber;
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>;
+    transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, bigint>>>;
+}, z.z.core.$strip>;
+export declare const TransferZod: z.ZodObject<{
+    schema: z.ZodLiteral<"network.xyo.transfer">;
+    epoch: z.ZodNumber;
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>;
+    transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, bigint>>>;
+}, z.z.core.$strict>;
+//# sourceMappingURL=Transfer.d.ts.map

package/dist/neutral/types/schema/common/Transfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transfer.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Transfer.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;mBAI5B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;oBAA2E,CAAA"}

package/dist/neutral/types/schema/common/index.d.ts

@@ -9,6 +9,8 @@ export * from './Payload.ts';
 export * from './Permission.ts';
 export * from './Sequence.ts';
 export * from './Stake.ts';
+export * from './StepContext.ts';
 export * from './TransactionBoundWitness.ts';
 export * from './TransactionFees.ts';
+export * from './Transfer.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/types/schema/common/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,kBAAkB,CAAA;AAChC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA"}

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

@@ -3,7 +3,7 @@ export * from './common/index.ts';
 export * from './createRequestSchema.ts';
 export * from './createResponseSchema.ts';
 export * from './RpcSchemaMap.ts';
-export * from './XyoGatewayRpcSchemas.ts';
+export * from './XyoPermissionsRpcSchemas.ts';
 export * from './XyoProviderRpcSchemas.ts';
 export * from './XyoRunnerRpcSchemas.ts';
 export * from './XyoSignerRpcSchemas.ts';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,2BAA2B,CAAA;AACzC,cAAc,mBAAmB,CAAA;AACjC,cAAc,2BAA2B,CAAA;AACzC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,2BAA2B,CAAA;AACzC,cAAc,mBAAmB,CAAA;AACjC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA"}

package/dist/node/engine/index.d.ts

@@ -1,3 +1,4 @@
 export * from './requestSchemas.ts';
 export * from './rpcMethodHandlersFromConnection.ts';
+export * from './rpcMethodHandlersFromPermissions.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/node/engine/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,sCAAsC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,sCAAsC,CAAA;AACpD,cAAc,uCAAuC,CAAA"}

package/dist/node/engine/rpcMethodHandlersFromPermissions.d.ts

@@ -0,0 +1,4 @@
+import type { XyoPermissions } from '@xyo-network/xl1-protocol';
+import type { XyoPermissionsRpcMethodHandlers } from '../types/index.ts';
+export declare const rpcMethodHandlersFromPermissions: (permissions: XyoPermissions) => XyoPermissionsRpcMethodHandlers;
+//# sourceMappingURL=rpcMethodHandlersFromPermissions.d.ts.map

package/dist/node/engine/rpcMethodHandlersFromPermissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpcMethodHandlersFromPermissions.d.ts","sourceRoot":"","sources":["../../../src/engine/rpcMethodHandlersFromPermissions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAE/D,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,mBAAmB,CAAA;AAExE,eAAO,MAAM,gCAAgC,GAAI,aAAa,cAAc,KAAG,+BAM9E,CAAA"}

package/dist/node/engine/rpcMethodHandlersFromViewer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpcMethodHandlersFromViewer.d.ts","sourceRoot":"","sources":["../../../src/engine/rpcMethodHandlersFromViewer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAE1D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAA;AAEnE,eAAO,MAAM,2BAA2B,GAAI,QAAQ,SAAS,KAAG,0BAsB/D,CAAA"}
+{"version":3,"file":"rpcMethodHandlersFromViewer.d.ts","sourceRoot":"","sources":["../../../src/engine/rpcMethodHandlersFromViewer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAE1D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAA;AAEnE,eAAO,MAAM,2BAA2B,GAAI,QAAQ,SAAS,KAAG,0BAyC/D,CAAA"}