@xyo-network/xl1-rpc 1.15.2 → 1.15.4

package/dist/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-rpc",
-  "version": "1.15.2",
+  "version": "1.15.4",
   "description": "XYO Layer One API",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -55,45 +55,45 @@
     "types": "tsc --noEmit -p tsconfig.test.json"
   },
   "dependencies": {
-    "@metamask/json-rpc-engine": "~10.1.0",
+    "@metamask/json-rpc-engine": "~10.1.1",
     "@metamask/utils": "~11.8.1",
-    "@xylabs/arraybuffer": "~5.0.11",
-    "@xylabs/assert": "~5.0.11",
-    "@xylabs/axios": "~5.0.11",
-    "@xylabs/exists": "~5.0.11",
-    "@xylabs/hex": "~5.0.11",
-    "@xylabs/object": "~5.0.11",
-    "@xylabs/promise": "~5.0.11",
-    "@xylabs/typeof": "~5.0.11",
-    "@xyo-network/account-model": "~5.1.3",
-    "@xyo-network/archivist-memory": "~5.1.3",
-    "@xyo-network/archivist-model": "~5.1.3",
-    "@xyo-network/boundwitness-model": "~5.1.3",
-    "@xyo-network/hash": "~5.1.3",
-    "@xyo-network/module-model": "~5.1.3",
-    "@xyo-network/node-model": "~5.1.3",
-    "@xyo-network/payload-builder": "~5.1.3",
-    "@xyo-network/payload-model": "~5.1.3",
-    "@xyo-network/xl1-protocol": "~1.12.40",
-    "@xyo-network/xl1-protocol-sdk": "~1.15.2",
-    "@xyo-network/xl1-wrappers": "~1.15.2",
+    "@xylabs/arraybuffer": "~5.0.12",
+    "@xylabs/assert": "~5.0.12",
+    "@xylabs/axios": "~5.0.12",
+    "@xylabs/exists": "~5.0.12",
+    "@xylabs/hex": "~5.0.12",
+    "@xylabs/object": "~5.0.12",
+    "@xylabs/promise": "~5.0.12",
+    "@xylabs/typeof": "~5.0.12",
+    "@xyo-network/account-model": "~5.1.6",
+    "@xyo-network/archivist-memory": "~5.1.6",
+    "@xyo-network/archivist-model": "~5.1.6",
+    "@xyo-network/boundwitness-model": "~5.1.6",
+    "@xyo-network/hash": "~5.1.6",
+    "@xyo-network/module-model": "~5.1.6",
+    "@xyo-network/node-model": "~5.1.6",
+    "@xyo-network/payload-builder": "~5.1.6",
+    "@xyo-network/payload-model": "~5.1.6",
+    "@xyo-network/xl1-protocol": "~1.12.69",
+    "@xyo-network/xl1-protocol-sdk": "~1.15.4",
+    "@xyo-network/xl1-wrappers": "~1.15.4",
     "axios": "~1.12.2",
     "uuid": "~13.0.0",
-    "zod": "~4.1.11"
+    "zod": "~4.1.12"
   },
   "devDependencies": {
     "@metamask/utils": "~11.8.1",
-    "@types/node": "~24.5.2",
-    "@xylabs/logger": "~5.0.11",
-    "@xylabs/ts-scripts-yarn3": "~7.1.7",
-    "@xylabs/tsconfig": "~7.1.7",
-    "@xylabs/vitest-extended": "~5.0.11",
-    "@xyo-network/account": "~5.1.3",
-    "@xyo-network/chain-protocol": "~1.15.2",
-    "@xyo-network/wallet": "~5.1.3",
-    "dotenv": "~17.2.2",
-    "eslint": "^9.36.0",
-    "typescript": "~5.9.2",
+    "@types/node": "~24.7.2",
+    "@xylabs/logger": "~5.0.12",
+    "@xylabs/ts-scripts-yarn3": "~7.1.8",
+    "@xylabs/tsconfig": "~7.1.8",
+    "@xylabs/vitest-extended": "~5.0.12",
+    "@xyo-network/account": "~5.1.6",
+    "@xyo-network/chain-protocol": "~1.15.4",
+    "@xyo-network/wallet": "~5.1.6",
+    "dotenv": "~17.2.3",
+    "eslint": "^9.37.0",
+    "typescript": "~5.9.3",
     "vitest": "~3.2.4"
   },
   "packageManager": "yarn@4.6.0",

package/src/engine/index.ts

@@ -1,2 +1,3 @@
 export * from './requestSchemas.ts'
 export * from './rpcMethodHandlersFromConnection.ts'
+export * from './rpcMethodHandlersFromPermissions.ts'

package/src/engine/rpcMethodHandlersFromPermissions.ts

@@ -0,0 +1,11 @@
+import type { XyoPermissions } from '@xyo-network/xl1-protocol'
+
+import type { XyoPermissionsRpcMethodHandlers } from '../types/index.ts'
+
+export const rpcMethodHandlersFromPermissions = (permissions: XyoPermissions): XyoPermissionsRpcMethodHandlers => {
+  return {
+    xyoPermissions_getPermissions: params => permissions.getPermissions(...(params ?? [])),
+    xyoPermissions_requestPermissions: params => permissions.requestPermissions(...(params ?? [])),
+    xyoPermissions_revokePermissions: params => permissions.revokePermissions(...(params ?? [])),
+  }
+}

package/src/engine/rpcMethodHandlersFromViewer.ts

@@ -4,6 +4,21 @@ import type { XyoViewerRpcMethodHandlers } from '../types/index.ts'
 
 export const rpcMethodHandlersFromViewer = (viewer: XyoViewer): XyoViewerRpcMethodHandlers => {
   return {
+    xyoViewer_networkStakeStepRewardClaimedByAddress: params => viewer.networkStakeStepRewardClaimedByAddress(...(params ?? [])),
+    xyoViewer_networkStakeStepRewardAddressReward: params => viewer.networkStakeStepRewardAddressReward(...(params ?? [])),
+    xyoViewer_networkStakeStepRewardAddressHistory: params => viewer.networkStakeStepRewardAddressHistory(...(params ?? [])),
+    xyoViewer_networkStakeStepRewardAddressShare: params => viewer.networkStakeStepRewardAddressShare(...(params ?? [])),
+    xyoViewer_networkStakeStepRewardWeightForAddress: params => viewer.networkStakeStepRewardWeightForAddress?.(...(params ?? [])),
+    xyoViewer_networkStakeStepRewardUnclaimedByAddress: params => viewer.networkStakeStepRewardUnclaimedByAddress(...(params ?? [])),
+    xyoViewer_networkStakeStepRewardPoolShares: params => viewer.networkStakeStepRewardPoolShares(...(params ?? [])),
+    xyoViewer_networkStakeStepRewardPoolRewards: params => viewer.networkStakeStepRewardPoolRewards(...(params ?? [])),
+    xyoViewer_networkStakeStepRewardPositionWeight: params => viewer.networkStakeStepRewardPositionWeight?.(...(params ?? [])),
+    xyoViewer_networkStakeStepRewardPotentialPositionLoss: params => viewer.networkStakeStepRewardPotentialPositionLoss?.(...(params ?? [])),
+    xyoViewer_networkStakeStepRewardForStep: params => viewer.networkStakeStepRewardForStep?.(...(params ?? [])),
+    xyoViewer_networkStakeStepRewardRandomizer: params => viewer.networkStakeStepRewardRandomizer?.(...(params ?? [])),
+    xyoViewer_networkStakeStepRewardStakerCount: params => viewer.networkStakeStepRewardStakerCount?.(...(params ?? [])),
+    xyoViewer_networkStakeStepRewardForStepForPosition: params => viewer.networkStakeStepRewardForStepForPosition?.(...(params ?? [])),
+    xyoViewer_networkStakeStepRewardForPosition: params => viewer.networkStakeStepRewardForPosition?.(...(params ?? [])),
     xyoViewer_accountBalance: params => viewer.accountBalance(...(params ?? [])),
     xyoViewer_accountBalanceHistory: params => viewer.accountBalanceHistory(...(params ?? [])),
     xyoViewer_blockByHash: params => viewer.blockByHash(...(params ?? [])),
@@ -16,12 +31,16 @@ export const rpcMethodHandlersFromViewer = (viewer: XyoViewer): XyoViewerRpcMeth
     xyoViewer_currentBlockNumber: params => viewer.currentBlockNumber(...(params ?? [])),
     xyoViewer_forkHistory: params => viewer.forkHistory(...(params ?? [])),
     xyoViewer_stakeById: params => viewer.stakeById(...(params ?? [])),
-    xyoViewer_stakeByAddress: params => viewer.stakeByAddress(...(params ?? [])),
+    xyoViewer_stakeByStaker: params => viewer.stakeByStaker(...(params ?? [])),
     xyoViewer_stakesByStaked: params => viewer.stakesByStaked(...(params ?? [])),
     xyoViewer_stakesByStaker: params => viewer.stakesByStaker(...(params ?? [])),
     xyoViewer_stakedByStaker: params => viewer.stakedByStaker(...(params ?? [])),
     xyoViewer_transactionByBlockHashAndIndex: params => viewer.transactionByBlockHashAndIndex(...(params ?? [])),
     xyoViewer_transactionByBlockNumberAndIndex: params => viewer.transactionByBlockNumberAndIndex(...(params ?? [])),
     xyoViewer_transactionByHash: params => viewer.transactionByHash(...(params ?? [])),
+    xyoViewer_transferBalance: params => viewer.transferBalance(...(params ?? [])),
+    xyoViewer_transferBalanceHistory: params => viewer.transferBalanceHistory(...(params ?? [])),
+    xyoViewer_transferPairBalance: params => viewer.transferPairBalance(...(params ?? [])),
+    xyoViewer_transferPairBalanceHistory: params => viewer.transferPairBalanceHistory(...(params ?? [])),
   }
 }

package/src/provider/client/MemoryXyoClient.ts

@@ -1,12 +1,13 @@
 import type {
   PermissionsProvider, XyoClient, XyoGatewayProvider,
+  XyoPermissions,
 } from '@xyo-network/xl1-protocol'
 
 export class MemoryXyoClient implements XyoClient {
   gateways: Readonly<Record<string, XyoGatewayProvider>>
   permissions: PermissionsProvider
 
-  constructor(gateways: Readonly<Record<string, XyoGatewayProvider>>, permissions: PermissionsProvider) {
+  constructor(gateways: Readonly<Record<string, XyoGatewayProvider>>, permissions: XyoPermissions) {
     this.gateways = gateways
     this.permissions = permissions
   }

package/src/provider/client/index.ts

@@ -1,2 +1 @@
 export * from './MemoryXyoClient.ts'
-export * from './PermissionsStore/index.ts'