@xyo-network/xl1-rpc 1.16.22 → 1.16.24

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

@@ -248,8 +248,8 @@ export declare const XyoViewerRpcSchemas: {
     };
     xyoViewer_accountBalance: {
         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.ZodUnion<readonly [z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>], null>, z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>], null>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>]>], null>]>;
+            from: z.ZodUnion<readonly [z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>], null>, z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>], null>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>]>], null>]>;
         };
         result: {
             to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>;
@@ -310,7 +310,7 @@ export declare const XyoViewerRpcSchemas: {
             }, z.core.$strip>>, z.ZodObject<{
                 schema: z.ZodLiteral<"network.xyo.transfer">;
                 $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
                 epoch: z.ZodNumber;
                 from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
                 transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>>;
@@ -365,7 +365,135 @@ export declare const XyoViewerRpcSchemas: {
             }, z.core.$strip>>, z.ZodObject<{
                 schema: z.ZodLiteral<"network.xyo.transfer">;
                 $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+                epoch: z.ZodNumber;
+                from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
+                transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>>;
+                _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>;
+                _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>;
+            }, z.core.$strip>], null>>;
+        };
+    };
+    xyoViewer_accountsBalances: {
+        params: {
+            to: z.ZodUnion<readonly [z.ZodTuple<[z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>], null>, z.ZodTuple<[z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>], null>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>]>], null>]>;
+            from: z.ZodUnion<readonly [z.ZodTuple<[z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>], null>, z.ZodTuple<[z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>], null>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>]>], null>]>;
+        };
+        result: {
+            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").Hex, bigint>>>;
+            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").Hex>>>;
+        };
+    };
+    xyoViewer_accountsBalancesHistory: {
+        params: {
+            to: z.ZodUnion<readonly [z.ZodTuple<[z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>], null>, z.ZodTuple<[z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>], null>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>]>], null>]>;
+            from: z.ZodUnion<readonly [z.ZodTuple<[z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>], null>, z.ZodTuple<[z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>, z.ZodUnion<readonly [z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>], null>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>]>], null>]>;
+        };
+        result: {
+            to: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodTuple<[z.ZodObject<{
+                schema: z.ZodLiteral<"network.xyo.boundwitness">;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>;
+                payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
+                payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+                    __schema: true;
+                }, string>>]>>;
+                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>;
+                $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
+                $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodNull]>>;
+                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
+                chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
+                previous: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
+                protocol: z.ZodNumber;
+                step_hashes: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>>;
+                $epoch: z.ZodNumber;
+                _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>;
+                _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>;
+            }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+                schema: z.ZodLiteral<"network.xyo.boundwitness">;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>;
+                payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
+                payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+                    __schema: true;
+                }, string>>]>>;
+                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>;
+                $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
+                $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodNull]>>;
+                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
+                nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
+                exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
+                fees: z.ZodObject<{
+                    base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+                    gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+                    gasPrice: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+                    priority: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+                }, z.core.$strip>;
+                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>>;
+                _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>;
+                _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>;
+            }, z.core.$strip>>, z.ZodObject<{
+                schema: z.ZodLiteral<"network.xyo.transfer">;
+                $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+                epoch: z.ZodNumber;
+                from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
+                transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>>;
+                _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>;
+                _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>;
+            }, z.core.$strip>], null>>;
+            from: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodTuple<[z.ZodObject<{
+                schema: z.ZodLiteral<"network.xyo.boundwitness">;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>;
+                payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
+                payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+                    __schema: true;
+                }, string>>]>>;
+                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>;
+                $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
+                $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodNull]>>;
+                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
+                chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
+                previous: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
+                protocol: z.ZodNumber;
+                step_hashes: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>>;
+                $epoch: z.ZodNumber;
+                _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>;
+                _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>;
+            }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+                schema: z.ZodLiteral<"network.xyo.boundwitness">;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>;
+                payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
+                payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
+                    __schema: true;
+                }, string>>]>>;
+                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>>;
+                $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>>;
+                $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>, z.ZodNull]>>;
+                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").LocalSequence, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/payload-model").QualifiedSequence, string>>]>>;
+                nbf: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
+                exp: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>;
+                fees: z.ZodObject<{
+                    base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+                    gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+                    gasPrice: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+                    priority: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>;
+                }, z.core.$strip>;
+                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>>;
+                _hash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>;
+                _dataHash: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hash, string>>;
+            }, z.core.$strip>>, z.ZodObject<{
+                schema: z.ZodLiteral<"network.xyo.transfer">;
+                $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
                 epoch: z.ZodNumber;
                 from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
                 transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>>;
@@ -438,7 +566,7 @@ export declare const XyoViewerRpcSchemas: {
             }, z.core.$strip>>, z.ZodObject<{
                 schema: z.ZodLiteral<"network.xyo.transfer">;
                 $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
                 epoch: z.ZodNumber;
                 from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
                 transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>>;
@@ -493,7 +621,7 @@ export declare const XyoViewerRpcSchemas: {
             }, z.core.$strip>>, z.ZodObject<{
                 schema: z.ZodLiteral<"network.xyo.transfer">;
                 $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
                 epoch: z.ZodNumber;
                 from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
                 transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>>;
@@ -566,7 +694,7 @@ export declare const XyoViewerRpcSchemas: {
             }, z.core.$strip>>, z.ZodObject<{
                 schema: z.ZodLiteral<"network.xyo.transfer">;
                 $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
                 epoch: z.ZodNumber;
                 from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
                 transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>>;
@@ -621,7 +749,7 @@ export declare const XyoViewerRpcSchemas: {
             }, z.core.$strip>>, z.ZodObject<{
                 schema: z.ZodLiteral<"network.xyo.transfer">;
                 $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
                 epoch: z.ZodNumber;
                 from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>;
                 transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Address, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").Hex, string>>>;

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":"AASA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAcxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiZgB,CAAA"}
+{"version":3,"file":"XyoViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoViewerRpcSchemas.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAKxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqagB,CAAA"}

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

@@ -1,5 +1,5 @@
+export * from './AccountBalanceViewerRpcSchemas.ts';
 export * from './AllRpcSchemas.ts';
-export * from './common/index.ts';
 export * from './createRequestSchema.ts';
 export * from './createResponseSchema.ts';
 export * from './DataLakeViewerRpcSchema.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,8BAA8B,CAAA;AAC5C,cAAc,mCAAmC,CAAA;AACjD,cAAc,wCAAwC,CAAA;AACtD,cAAc,sCAAsC,CAAA;AACpD,cAAc,oCAAoC,CAAA;AAClD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mBAAmB,CAAA;AACjC,cAAc,kCAAkC,CAAA;AAChD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,+BAA+B,CAAA;AAC7C,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,qCAAqC,CAAA;AACnD,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,2BAA2B,CAAA;AACzC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,mCAAmC,CAAA;AACjD,cAAc,wCAAwC,CAAA;AACtD,cAAc,sCAAsC,CAAA;AACpD,cAAc,oCAAoC,CAAA;AAClD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mBAAmB,CAAA;AACjC,cAAc,kCAAkC,CAAA;AAChD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,+BAA+B,CAAA;AAC7C,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.16.22",
+  "version": "1.16.24",
   "description": "XYO Layer One API",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -59,16 +59,15 @@
   },
   "dependencies": {
     "@metamask/json-rpc-engine": "~10.1.1",
-    "@xylabs/axios": "~5.0.37",
-    "@xylabs/sdk-js": "~5.0.37",
+    "@xylabs/axios": "~5.0.39",
+    "@xylabs/sdk-js": "~5.0.39",
     "@xyo-network/archivist-model": "~5.1.24",
-    "@xyo-network/boundwitness-model": "~5.1.24",
     "@xyo-network/module-model": "~5.1.24",
     "@xyo-network/node-model": "~5.1.24",
     "@xyo-network/payload-builder": "~5.1.24",
     "@xyo-network/payload-model": "~5.1.24",
-    "@xyo-network/xl1-protocol": "~1.13.11",
-    "@xyo-network/xl1-protocol-sdk": "~1.16.22",
+    "@xyo-network/xl1-protocol": "~1.13.13",
+    "@xyo-network/xl1-protocol-sdk": "~1.16.24",
     "axios": "~1.13.2",
     "uuid": "~13.0.0",
     "zod": "~4.1.12"
@@ -76,13 +75,13 @@
   "devDependencies": {
     "@metamask/utils": "~11.8.1",
     "@types/node": "~24.10.1",
-    "@xylabs/sdk-js": "~5.0.37",
+    "@xylabs/sdk-js": "~5.0.39",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xylabs/vitest-extended": "~5.0.37",
+    "@xylabs/vitest-extended": "~5.0.39",
     "@xyo-network/account": "~5.1.24",
     "@xyo-network/account-model": "~5.1.24",
-    "@xyo-network/chain-protocol": "~1.16.22",
+    "@xyo-network/chain-protocol": "~1.16.24",
     "@xyo-network/wallet": "~5.1.24",
     "dotenv": "~17.2.3",
     "eslint": "^9.39.1",

package/src/engine/rpcMethodHandlersFromViewer.ts

@@ -24,6 +24,8 @@ export const rpcMethodHandlersFromViewer = (viewer: XyoViewer): XyoViewerRpcMeth
     xyoViewer_networkStakeStepRewardsForStepLevel: params => viewer.networkStakeStepRewardsForStepLevel?.(...(params ?? [])),
     xyoViewer_accountBalance: params => viewer.accountBalance(...(params ?? [])),
     xyoViewer_accountBalanceHistory: params => viewer.accountBalanceHistory(...(params ?? [])),
+    xyoViewer_accountsBalances: params => viewer.accountsBalances(...(params ?? [])),
+    xyoViewer_accountsBalancesHistory: params => viewer.accountsBalancesHistory(...(params ?? [])),
     xyoViewer_blockByHash: params => viewer.blockByHash(...(params ?? [])),
     xyoViewer_blockByNumber: params => viewer.blockByNumber(...(params ?? [])),
     xyoViewer_blocksByHash: params => viewer.blocksByHash(...(params ?? [])),

package/src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewer.ts

@@ -0,0 +1,23 @@
+import type { Address, Hash } from '@xylabs/sdk-js'
+import {
+  asAttoXL1, type AttoXL1, type XL1BlockRange,
+} from '@xyo-network/xl1-protocol'
+import type { AccountBalanceHistoryItem, AccountBalanceViewer } from '@xyo-network/xl1-protocol-sdk'
+
+import type { RpcTransport } from '../../../transport/index.ts'
+import type { AccountBalanceViewerRpcSchemas } from '../../../types/index.ts'
+import { JsonRpcAccountBalanceViewerMethods } from './JsonRpcAccountBalanceViewerMethods.ts'
+
+export class JsonRpcAccountBalanceViewer extends JsonRpcAccountBalanceViewerMethods implements AccountBalanceViewer {
+  constructor(transport: RpcTransport<typeof AccountBalanceViewerRpcSchemas>) {
+    super(transport)
+  }
+
+  async accountBalance(address: Address, headOrRange?: Hash | XL1BlockRange): Promise<AttoXL1> {
+    return (await this.accountsBalances([address], headOrRange))[address] ?? asAttoXL1(0)
+  }
+
+  async accountBalanceHistory(address: Address, headOrRange?: Hash | XL1BlockRange): Promise<AccountBalanceHistoryItem[]> {
+    return (await this.accountsBalancesHistory([address], headOrRange))[address] ?? []
+  }
+}

package/src/provider/viewer/JsonRpcAccountBalanceViewer/JsonRpcAccountBalanceViewerMethods.ts

@@ -0,0 +1,31 @@
+import type { Address, Hash } from '@xylabs/sdk-js'
+import {
+  type AttoXL1,
+  type XL1BlockRange,
+} from '@xyo-network/xl1-protocol'
+import type { AccountBalanceHistoryItem, AccountBalanceViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+
+import type { RpcTransport } from '../../../transport/index.ts'
+import type { AccountBalanceViewerRpcSchemas } from '../../../types/index.ts'
+
+export class JsonRpcAccountBalanceViewerMethods implements AccountBalanceViewerMethods {
+  protected readonly transport: RpcTransport<typeof AccountBalanceViewerRpcSchemas>
+
+  constructor(transport: RpcTransport<typeof AccountBalanceViewerRpcSchemas>) {
+    this.transport = transport
+  }
+
+  async accountsBalances(address: Address[], headOrRange?: Hash | XL1BlockRange): Promise<Partial<Record<Address, AttoXL1>>> {
+    return await this.transport.sendRequest(
+      'accountBalanceViewer_accountsBalances',
+      headOrRange ? [address, headOrRange] : [address],
+    ) as Partial<Record<Address, AttoXL1>>
+  }
+
+  async accountsBalancesHistory(address: Address[], headOrRange?: Hash | XL1BlockRange): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>> {
+    return (await this.transport.sendRequest(
+      'accountBalanceViewer_accountsBalancesHistory',
+      headOrRange ? [address, headOrRange] : [address],
+    )) as Partial<Record<Address, AccountBalanceHistoryItem[]>>
+  }
+}

package/src/provider/viewer/JsonRpcAccountBalanceViewer/index.ts

@@ -0,0 +1,2 @@
+export * from './JsonRpcAccountBalanceViewer.ts'
+export * from './JsonRpcAccountBalanceViewerMethods.ts'

package/src/provider/viewer/JsonRpcXyoViewer.ts

@@ -1,7 +1,5 @@
-import {
-  type Address, type Hash, isHash,
-} from '@xylabs/sdk-js'
-import { isDefined } from '@xylabs/sdk-js'
+import type { Address, Hash } from '@xylabs/sdk-js'
+import { isDefined, isHash } from '@xylabs/sdk-js'
 import type {
   AttoXL1,
   BlockRange,
@@ -38,8 +36,17 @@ export class JsonRpcXyoViewer implements XyoViewer {
     return this.providers?.networkStakeViewer
   }
 
-  async accountBalance(address: Address): Promise<AttoXL1> {
-    return asAttoXL1(await this.transport.sendRequest('xyoViewer_accountBalance', [address]))
+  async accountBalance(address: Address): Promise<AttoXL1>
+  async accountBalance(address: Address, head: Hash): Promise<AttoXL1>
+  async accountBalance(address: Address, range: BlockRange): Promise<AttoXL1>
+  async accountBalance(address: Address, headOrRange?: BlockRange | Hash): Promise<AttoXL1> {
+    if (isDefined(headOrRange)) {
+      if (isHash(headOrRange)) {
+        return (await this.transport.sendRequest('xyoViewer_accountBalance', [address, headOrRange])) as AttoXL1
+      }
+      return (await this.transport.sendRequest('xyoViewer_accountBalance', [address, headOrRange])) as AttoXL1
+    }
+    return (await this.transport.sendRequest('xyoViewer_accountBalance', [address])) as AttoXL1
   }
 
   async accountBalanceHistory(address: Address): Promise<AccountBalanceHistoryItem[]>
@@ -55,6 +62,20 @@ export class JsonRpcXyoViewer implements XyoViewer {
     return (await this.transport.sendRequest('xyoViewer_accountBalanceHistory', [address])) as AccountBalanceHistoryItem[]
   }
 
+  accountsBalances(address: Address[]): Promise<Partial<Record<Address, AttoXL1>>>
+  accountsBalances(address: Address[], head: Hash): Promise<Partial<Record<Address, AttoXL1>>>
+  accountsBalances(address: Address[], range: BlockRange): Promise<Partial<Record<Address, AttoXL1>>>
+  accountsBalances(address: Address[], headOrRange?: Hash | BlockRange): Promise<Partial<Record<Address, AttoXL1>>> {
+    throw new Error('Method not implemented.')
+  }
+
+  accountsBalancesHistory(address: Address[]): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
+  accountsBalancesHistory(address: Address[], head: Hash): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
+  accountsBalancesHistory(address: Address[], range: BlockRange): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
+  accountsBalancesHistory(address: Address[], headOrRange?: Hash | BlockRange): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>> {
+    throw new Error('Method not implemented.')
+  }
+
   async blockByHash(hash: Hash): Promise<HydratedBlock | null> {
     return asHydratedBlock(await this.transport.sendRequest('xyoViewer_blockByHash', [hash])) ?? null
   }

package/src/provider/viewer/index.ts

@@ -1,3 +1,4 @@
+export * from './JsonRpcAccountBalanceViewer/index.ts'
 export * from './JsonRpcNetworkStakeViewer/index.ts'
 export * from './JsonRpcNetworkStakingStepRewardsViewer/index.ts'
 export * from './JsonRpcTimeSyncViewer/index.ts'

package/src/types/AccountBalanceViewerRpc.ts

@@ -0,0 +1,16 @@
+import type { AccountBalanceViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+
+import type { MethodName, RpcMethodName } from './RpcMethodName.ts'
+
+export const AccountBalanceViewerRpcNamespace = 'accountBalanceViewer' as const
+export type AccountBalanceViewerRpcNamespace = typeof AccountBalanceViewerRpcNamespace
+
+export type AccountBalanceViewerMethodName = MethodName<AccountBalanceViewerMethods>
+export type AccountBalanceViewerRpcMethodName = RpcMethodName<AccountBalanceViewerRpcNamespace,
+  AccountBalanceViewerMethodName>
+
+export type AccountBalanceViewerRpcMethodHandlers = {
+  [K in AccountBalanceViewerMethodName as AccountBalanceViewerRpcMethodName]: (
+    params: Parameters<AccountBalanceViewerMethods[K]>,
+  ) => ReturnType<AccountBalanceViewerMethods[K]>
+}

package/src/types/index.ts

@@ -1,3 +1,4 @@
+export * from './AccountBalanceViewerRpc.ts'
 export * from './DataLakeViewerRpc.ts'
 export * from './ErrorCodes.ts'
 export * from './JsonRpc.ts'

package/src/types/schema/AccountBalanceViewerRpcSchemas.ts

@@ -0,0 +1,33 @@
+import {
+  AddressZod,
+  BigIntToJsonZod, HashZod, JsonToBigIntZod,
+} from '@xylabs/sdk-js'
+import { XL1BlockRangeZod } from '@xyo-network/xl1-protocol'
+import { AccountBalanceHistoryItemZod } from '@xyo-network/xl1-protocol-sdk'
+import * as z from 'zod'
+
+import type { AccountBalanceViewerRpcMethodName } from '../AccountBalanceViewerRpc.ts'
+import type { RpcSchemaMap } from './RpcSchemaMap.ts'
+
+export const AccountBalanceViewerRpcSchemas = {
+  accountBalanceViewer_accountsBalances: {
+    params: {
+      to: z.union([z.tuple([z.array(AddressZod)]), z.tuple([z.array(AddressZod), z.union([XL1BlockRangeZod, HashZod])])]),
+      from: z.union([z.tuple([z.array(AddressZod)]), z.tuple([z.array(AddressZod), z.union([XL1BlockRangeZod, HashZod])])]),
+    },
+    result: {
+      to: z.record(AddressZod, BigIntToJsonZod),
+      from: z.record(AddressZod, JsonToBigIntZod),
+    },
+  },
+  accountBalanceViewer_accountsBalancesHistory: {
+    params: {
+      to: z.union([z.tuple([z.array(AddressZod)]), z.tuple([z.array(AddressZod), z.union([XL1BlockRangeZod, HashZod])])]),
+      from: z.union([z.tuple([z.array(AddressZod)]), z.tuple([z.array(AddressZod), z.union([XL1BlockRangeZod, HashZod])])]),
+    },
+    result: {
+      to: z.record(AddressZod, z.array(AccountBalanceHistoryItemZod)),
+      from: z.record(AddressZod, z.array(AccountBalanceHistoryItemZod)),
+    },
+  },
+} satisfies RpcSchemaMap<AccountBalanceViewerRpcMethodName>

package/src/types/schema/AllRpcSchemas.ts

@@ -1,3 +1,4 @@
+import { AccountBalanceViewerRpcSchemas } from './AccountBalanceViewerRpcSchemas.ts'
 import { NetworkStakeViewerRpcSchemas } from './NetworkStakeViewerRpcSchemas.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 import { XyoPermissionsRpcSchemas } from './XyoPermissionsRpcSchemas.ts'
@@ -6,6 +7,7 @@ import { XyoSignerRpcSchemas } from './XyoSignerRpcSchemas.ts'
 import { XyoViewerRpcSchemas } from './XyoViewerRpcSchemas.ts'
 
 export const AllRpcSchemas = {
+  ...AccountBalanceViewerRpcSchemas,
   ...XyoRunnerRpcSchemas,
   ...XyoSignerRpcSchemas,
   ...XyoViewerRpcSchemas,

package/src/types/schema/DataLakeViewerRpcSchema.ts

@@ -1,9 +1,9 @@
 import { HashZod } from '@xylabs/sdk-js'
 import { PayloadZod } from '@xyo-network/payload-model'
+import { ArrayBufferToJsonZod, JsonToArrayBufferZod } from '@xyo-network/xl1-protocol-sdk'
 import * as z from 'zod'
 
 import type { DataLakeViewerRpcMethodName } from '../DataLakeViewerRpc.ts'
-import { ArrayBufferToJsonZod, JsonToArrayBufferZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
 export const DataLakeViewerRpcSchemas = {

package/src/types/schema/RewardsByPositionViewerRpcSchemas.ts

@@ -1,9 +1,9 @@
 import { BigIntToJsonZod, JsonToBigIntZod } from '@xylabs/sdk-js'
 import { asAttoXL1 } from '@xyo-network/xl1-protocol'
+import { RewardsRangeOptionsZod } from '@xyo-network/xl1-protocol-sdk'
 import z from 'zod'
 
 import type { NetworkStakingStepRewardsByPositionViewerRpcMethodName } from '../NetworkStakingStepRewardsByPositionViewerRpc.ts'
-import { RewardsRangeOptionsZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
 export const NetworkStakingStepRewardsByPositionViewerRpcSchemas = {

package/src/types/schema/RewardsByStakerViewerRpcSchemas.ts

@@ -1,10 +1,10 @@
 import {
   AddressZod, BigIntToJsonZod, JsonToBigIntZod,
 } from '@xylabs/sdk-js'
+import { RewardsRangeOptionsZod } from '@xyo-network/xl1-protocol-sdk'
 import z from 'zod'
 
 import type { NetworkStakingStepRewardsByStakerViewerRpcMethodName } from '../NetworkStakingStepRewardsByStakerViewerRpc.ts'
-import { RewardsRangeOptionsZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
 export const NetworkStakingStepRewardsByStakerViewerRpcSchemas = {

package/src/types/schema/RewardsByStepViewerRpcSchemas.ts

@@ -1,10 +1,10 @@
 import {
   AddressZod, BigIntToJsonZod, JsonToBigIntZod,
 } from '@xylabs/sdk-js'
+import { RewardsRangeOptionsZod } from '@xyo-network/xl1-protocol-sdk'
 import z from 'zod'
 
 import type { NetworkStakingStepRewardsByStepViewerRpcMethodName } from '../NetworkStakingStepRewardsByStepViewerRpc.ts'
-import { RewardsRangeOptionsZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
 export const NetworkStakingStepRewardsByStepViewerRpcSchemas = {

package/src/types/schema/RewardsTotalViewerRpcSchemas.ts

@@ -1,9 +1,9 @@
 import { BigIntToJsonZod, JsonToBigIntZod } from '@xylabs/sdk-js'
 import { asAttoXL1 } from '@xyo-network/xl1-protocol'
+import { RewardsRangeOptionsZod } from '@xyo-network/xl1-protocol-sdk'
 import * as z from 'zod'
 
 import type { NetworkStakingStepRewardsTotalViewerRpcMethodName } from '../NetworkStakingStepRewardsTotalViewerRpc.ts'
-import { RewardsRangeOptionsZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
 export const NetworkStakingStepRewardsTotalViewerRpcSchemas = {

package/src/types/schema/StepViewerRpcSchemas.ts

@@ -2,10 +2,10 @@ import {
   AddressZod, BigIntToJsonZod, JsonToBigIntZod,
 } from '@xylabs/sdk-js'
 import { StepIdentityZod } from '@xyo-network/xl1-protocol'
+import { JsonToStakeZod, StakeToJsonZod } from '@xyo-network/xl1-protocol-sdk'
 import z from 'zod'
 
 import type { StepViewerMethodName } from '../StepViewerRpc.ts'
-import { JsonToStakeZod, StakeToJsonZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
 export const StepViewerRpcSchemas = {

package/src/types/schema/TimeSyncViewerRpcSchema.ts

@@ -1,8 +1,8 @@
 import { TimePayloadZod } from '@xyo-network/xl1-protocol'
+import { TimeDomainZod } from '@xyo-network/xl1-protocol-sdk'
 import * as z from 'zod'
 
 import type { TimeSyncViewerRpcMethodName } from '../TimeSyncViewerRpc.ts'
-import { TimeDomainZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
 export const TimeSyncViewerRpcSchemas = {

package/src/types/schema/XyoPermissionsRpcSchemas.ts

@@ -1,9 +1,9 @@
+import {
+  InvokerPermissionZod, PermissionRequestZod, RequestedPermissionZod,
+} from '@xyo-network/xl1-protocol-sdk'
 import * as z from 'zod'
 
 import type { XyoPermissionsRpcMethodName } from '../XyoPermissions.ts'
-import {
-  InvokerPermissionZod, PermissionRequestZod, RequestedPermissionZod,
-} from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
 export const XyoPermissionsRpcSchemas = {

package/src/types/schema/XyoRunnerRpcSchemas.ts

@@ -1,8 +1,8 @@
 import { HashToJsonZod, JsonToHashZod } from '@xylabs/sdk-js'
+import { SignedHydratedTransactionZod } from '@xyo-network/xl1-protocol-sdk'
 import * as z from 'zod'
 
 import type { XyoRunnerRpcMethodName } from '../XyoRunnerRpc.ts'
-import { SignedHydratedTransactionZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
 export const XyoRunnerRpcSchemas = {

package/src/types/schema/XyoSignerRpcSchemas.ts

@@ -1,12 +1,9 @@
 import { AddressZod } from '@xylabs/sdk-js'
 import { asHydratedTransactionWithStorageMeta } from '@xyo-network/xl1-protocol'
+import { SignedHydratedTransactionZod, UnsignedHydratedTransactionZod } from '@xyo-network/xl1-protocol-sdk'
 import { z } from 'zod'
 
 import type { XyoSignerRpcMethodName } from '../XyoSignerRpc.ts'
-import {
-  SignedHydratedTransactionZod,
-  UnsignedHydratedTransactionZod,
-} from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
 export const XyoSignerRpcSchemas = {