@xyo-network/xl1-rpc 1.18.0-rc.1 → 1.18.1

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

@@ -1,4 +1,4 @@
-import * as z from 'zod';
+import { z } from 'zod';
 export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
     networkStakingStepRewardsTotalViewer_bonus: {
         params: {
@@ -9,7 +9,11 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>>>;
             }, z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
@@ -18,12 +22,16 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
         };
     };
     networkStakingStepRewardsTotalViewer_claimed: {
@@ -35,7 +43,11 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>>>;
             }, z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
@@ -44,12 +56,16 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
         };
     };
     networkStakingStepRewardsTotalViewer_earned: {
@@ -61,7 +77,11 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>>>;
             }, z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
@@ -70,12 +90,16 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
         };
     };
     networkStakingStepRewardsTotalViewer_total: {
@@ -87,7 +111,11 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>>>;
             }, z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
@@ -96,12 +124,16 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
         };
     };
     networkStakingStepRewardsTotalViewer_unclaimed: {
@@ -113,7 +145,11 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>>>;
             }, z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
@@ -122,12 +158,16 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                     block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
         };
     };
 };

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

@@ -1 +1 @@
-{"version":3,"file":"RewardsTotalViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RewardsTotalViewerRpcSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAKxB,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA;AAE3E,MAAM,MAAM,8CAA8C,GAAG,OAAO,8CAA8C,CAAA"}
+{"version":3,"file":"RewardsTotalViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RewardsTotalViewerRpcSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA;AAE3E,MAAM,MAAM,8CAA8C,GAAG,OAAO,8CAA8C,CAAA"}

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

@@ -1,4 +1,4 @@
-import * as z from 'zod';
+import { z } from 'zod';
 export declare const StakeTotalsViewerRpcSchemas: {
     stakeTotalsViewer_active: {
         params: {
@@ -6,28 +6,44 @@ export declare const StakeTotalsViewerRpcSchemas: {
             from: z.ZodOptional<z.ZodArray<z.ZodAny>>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>;
         };
     };
     stakeTotalsViewer_activeByStaked: {
         params: {
-            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>], null>;
-            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>], null>;
+            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }, string>>], null>;
+            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }, string>>], null>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>;
         };
     };
     stakeTotalsViewer_activeByStaker: {
         params: {
-            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>], null>;
-            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>], null>;
+            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }, string>>], null>;
+            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }, string>>], null>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>;
         };
     };
     stakeTotalsViewer_pending: {
@@ -36,18 +52,26 @@ export declare const StakeTotalsViewerRpcSchemas: {
             from: z.ZodOptional<z.ZodArray<z.ZodAny>>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>;
         };
     };
     stakeTotalsViewer_pendingByStaker: {
         params: {
-            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>], null>;
-            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>], null>;
+            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }, string>>], null>;
+            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }, string>>], null>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>;
         };
     };
     stakeTotalsViewer_withdrawn: {
@@ -56,18 +80,26 @@ export declare const StakeTotalsViewerRpcSchemas: {
             from: z.ZodOptional<z.ZodArray<z.ZodAny>>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>;
         };
     };
     stakeTotalsViewer_withdrawnByStaker: {
         params: {
-            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>], null>;
-            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>], null>;
+            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }, string>>], null>;
+            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }, string>>], null>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>;
+            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>;
         };
     };
 };

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

@@ -1 +1 @@
-{"version":3,"file":"StakeTotalsViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/StakeTotalsViewerRpcSchemas.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAKxB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEgB,CAAA;AAExD,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAA"}
+{"version":3,"file":"StakeTotalsViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/StakeTotalsViewerRpcSchemas.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEgB,CAAA;AAExD,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAA"}

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

@@ -1,19 +1,19 @@
-import z from 'zod';
+import { z } from 'zod';
 export declare const StepViewerRpcSchemas: {
     randomizer: {
         params: {
             from: z.ZodTuple<[z.ZodObject<{
                 block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
-            }, z.z.core.$strip>], null>;
+            }, z.core.$strip>], null>;
             to: z.ZodTuple<[z.ZodObject<{
                 block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
-            }, z.z.core.$strip>], null>;
+            }, z.core.$strip>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
-            to: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>;
+            from: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            to: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>;
         };
     };
     stake: {
@@ -21,15 +21,15 @@ export declare const StepViewerRpcSchemas: {
             from: z.ZodTuple<[z.ZodObject<{
                 block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
-            }, z.z.core.$strip>], null>;
+            }, z.core.$strip>], null>;
             to: z.ZodTuple<[z.ZodObject<{
                 block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
-            }, z.z.core.$strip>], null>;
+            }, z.core.$strip>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
-            to: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>;
+            from: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            to: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>;
         };
     };
     stakers: {
@@ -37,15 +37,23 @@ export declare const StepViewerRpcSchemas: {
             from: z.ZodTuple<[z.ZodObject<{
                 block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
-            }, z.z.core.$strip>], null>;
+            }, z.core.$strip>], null>;
             to: z.ZodTuple<[z.ZodObject<{
                 block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
-            }, z.z.core.$strip>], null>;
+            }, z.core.$strip>], null>;
         };
         result: {
-            from: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>;
-            to: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>;
+            from: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }, string>>>;
+            to: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                readonly __hex: true;
+            } & {
+                readonly __address: true;
+            }, string>>>;
         };
     };
     weight: {
@@ -53,15 +61,15 @@ export declare const StepViewerRpcSchemas: {
             from: z.ZodTuple<[z.ZodObject<{
                 block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
-            }, z.z.core.$strip>], null>;
+            }, z.core.$strip>], null>;
             to: z.ZodTuple<[z.ZodObject<{
                 block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
-            }, z.z.core.$strip>], null>;
+            }, z.core.$strip>], null>;
         };
         result: {
-            from: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
-            to: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>;
+            from: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            to: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>;
         };
     };
     positionCount: {
@@ -69,11 +77,11 @@ export declare const StepViewerRpcSchemas: {
             from: z.ZodTuple<[z.ZodObject<{
                 block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
-            }, z.z.core.$strip>], null>;
+            }, z.core.$strip>], null>;
             to: z.ZodTuple<[z.ZodObject<{
                 block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
-            }, z.z.core.$strip>], null>;
+            }, z.core.$strip>], null>;
         };
         result: {
             from: z.ZodNumber;
@@ -85,11 +93,11 @@ export declare const StepViewerRpcSchemas: {
             from: z.ZodTuple<[z.ZodObject<{
                 block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
-            }, z.z.core.$strip>], null>;
+            }, z.core.$strip>], null>;
             to: z.ZodTuple<[z.ZodObject<{
                 block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
-            }, z.z.core.$strip>], null>;
+            }, z.core.$strip>], null>;
         };
         result: {
             from: z.ZodArray<z.ZodPipe<z.ZodObject<{
@@ -97,50 +105,98 @@ export declare const StepViewerRpcSchemas: {
                 addBlock: z.ZodNumber;
                 id: z.ZodNumber;
                 removeBlock: z.ZodNumber;
-                staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
-                staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
+                staked: z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>;
+                staker: z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>;
                 withdrawBlock: z.ZodNumber;
-            }, z.z.core.$strip>, z.ZodTransform<{
+            }, z.core.$strip>, z.ZodTransform<{
                 addBlock: number;
-                amount: import("@xylabs/sdk-js").Hex;
+                amount: import("@xylabs/sdk-js").BrandedHex;
                 id: number;
                 removeBlock: number;
-                staked: import("@xylabs/sdk-js").Address;
-                staker: import("@xylabs/sdk-js").Address;
+                staked: Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                };
+                staker: Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                };
                 withdrawBlock: number;
             }, {
                 amount: bigint;
                 addBlock: number;
                 id: number;
                 removeBlock: number;
-                staked: import("@xylabs/sdk-js").Address;
-                staker: import("@xylabs/sdk-js").Address;
+                staked: Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                };
+                staker: Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                };
                 withdrawBlock: number;
             }>>>;
             to: z.ZodArray<z.ZodPipe<z.ZodObject<{
                 addBlock: z.ZodNumber;
                 id: z.ZodNumber;
                 removeBlock: z.ZodNumber;
-                staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
-                staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
+                staked: z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>;
+                staker: z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                }, string>>;
                 withdrawBlock: z.ZodNumber;
-                amount: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
-            }, z.z.core.$strip>, z.ZodTransform<{
+                amount: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
+            }, z.core.$strip>, z.ZodTransform<{
                 addBlock: number;
                 amount: import("@xyo-network/xl1-protocol").AttoXL1;
                 id: import("@xyo-network/xl1-protocol").PositionId;
                 removeBlock: number;
-                staked: import("@xylabs/sdk-js").Address;
-                staker: import("@xylabs/sdk-js").Address;
+                staked: Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                };
+                staker: Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                };
                 withdrawBlock: number;
             }, {
                 addBlock: number;
                 id: number;
                 removeBlock: number;
-                staked: import("@xylabs/sdk-js").Address;
-                staker: import("@xylabs/sdk-js").Address;
+                staked: Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                };
+                staker: Lowercase<string> & {
+                    readonly __hex: true;
+                } & {
+                    readonly __address: true;
+                };
                 withdrawBlock: number;
-                amount: import("@xylabs/sdk-js").Hex;
+                amount: import("@xylabs/sdk-js").BrandedHex;
             }>>>;
         };
     };
@@ -149,11 +205,11 @@ export declare const StepViewerRpcSchemas: {
             from: z.ZodTuple<[z.ZodObject<{
                 block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
-            }, z.z.core.$strip>], null>;
+            }, z.core.$strip>], null>;
             to: z.ZodTuple<[z.ZodObject<{
                 block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
-            }, z.z.core.$strip>], null>;
+            }, z.core.$strip>], null>;
         };
         result: {
             from: z.ZodNumber;

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

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

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

@@ -1,4 +1,4 @@
-import * as z from 'zod';
+import { z } from 'zod';
 export declare const TimeSyncViewerRpcSchemas: {
     timeSyncViewer_convertTime: {
         params: {
@@ -39,17 +39,17 @@ export declare const TimeSyncViewerRpcSchemas: {
             from: z.ZodObject<{
                 schema: z.ZodLiteral<"network.xyo.time">;
                 xl1: z.ZodOptional<z.ZodNumber>;
-                xl1Hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+                xl1Hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
                 ethereum: z.ZodOptional<z.ZodNumber>;
-                ethereumHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+                ethereumHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
                 epoch: z.ZodNumber;
             }, z.core.$strip>;
             to: z.ZodObject<{
                 schema: z.ZodLiteral<"network.xyo.time">;
                 xl1: z.ZodOptional<z.ZodNumber>;
-                xl1Hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+                xl1Hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
                 ethereum: z.ZodOptional<z.ZodNumber>;
-                ethereumHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+                ethereumHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").BrandedHash, string>>>;
                 epoch: z.ZodNumber;
             }, z.core.$strip>;
         };

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

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

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

@@ -1,4 +1,4 @@
-import * as z from 'zod';
+import { z } from 'zod';
 export declare const XyoPermissionsRpcSchemas: {
     xyoPermissions_getPermissions: {
         params: {

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

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