@xyo-network/xl1-rpc 1.15.26 → 1.15.28

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

@@ -1,5 +1,3 @@
-import type { Signed } from '@xyo-network/boundwitness-model';
-import type { TransactionBoundWitness } from '@xyo-network/xl1-protocol';
 import { z } from 'zod';
 export declare const XyoSignerRpcSchemas: {
     readonly xyoSigner_address: {
@@ -20,347 +18,6 @@ export declare const XyoSignerRpcSchemas: {
             }>, string>>;
         };
     };
-    readonly xyoSigner_createSignedTransaction: {
-        readonly params: {
-            readonly to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>, z.ZodArray<z.ZodObject<{
-                schema: z.ZodEnum<{
-                    [x: string]: string;
-                }>;
-            }, z.core.$strip>>, z.ZodArray<z.ZodObject<{
-                schema: z.ZodString;
-            }, z.core.$catchall<z.ZodAny>>>, z.ZodNumber, z.ZodNumber, z.ZodPipe<z.ZodObject<{
-                base: z.ZodBigInt;
-                gasLimit: z.ZodBigInt;
-                gasPrice: z.ZodBigInt;
-                priority: z.ZodBigInt;
-            }, z.core.$strip>, z.ZodTransform<{
-                base: import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>;
-                gasLimit: import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>;
-                gasPrice: import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>;
-                priority: import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>;
-            }, {
-                base: bigint;
-                gasLimit: bigint;
-                gasPrice: bigint;
-                priority: bigint;
-            }>>, z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, {
-                readonly __address: true;
-            }>, string>>>], null>;
-            readonly from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>, z.ZodArray<z.ZodObject<{
-                schema: z.ZodString;
-            }, z.core.$catchall<z.ZodAny>>>, z.ZodArray<z.ZodObject<{
-                schema: z.ZodString;
-            }, z.core.$catchall<z.ZodAny>>>, z.ZodNumber, z.ZodNumber, z.ZodPipe<z.ZodObject<{
-                base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, unknown>>;
-                gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, unknown>>;
-                gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, unknown>>;
-                priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, unknown>>;
-            }, z.core.$strip>, z.ZodTransform<{
-                base: bigint;
-                gasLimit: bigint;
-                gasPrice: bigint;
-                priority: bigint;
-            }, {
-                base: import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>;
-                gasLimit: import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>;
-                gasPrice: import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>;
-                priority: import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>;
-            }>>, z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, {
-                readonly __address: true;
-            }>, string>>>], null>;
-        };
-        readonly result: {
-            readonly to: z.ZodObject<{
-                schema: z.ZodLiteral<"network.xyo.boundwitness">;
-                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __address: true;
-                }>, string>>>;
-                payload_hashes: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>;
-                payload_schemas: z.ZodArray<z.ZodString>;
-                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>>;
-                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __address: true;
-                }>, string>>>;
-                $sourceQuery: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>;
-                $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, unknown>>, z.ZodNull]>>;
-                _hash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>>>>;
-                _dataHash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>>>>;
-                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
-                nbf: z.ZodNumber;
-                exp: z.ZodNumber;
-                fees: z.ZodObject<{
-                    base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown>>;
-                    gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown>>;
-                    gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown>>;
-                    priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown>>;
-                }, z.core.$strip>;
-                chain: z.ZodPipe<z.ZodString, z.ZodTransform<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>;
-            readonly from: z.ZodPipe<z.ZodObject<{
-                schema: z.ZodLiteral<"network.xyo.boundwitness">;
-                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __address: true;
-                }>, string>>>;
-                payload_hashes: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>;
-                payload_schemas: z.ZodArray<z.ZodString>;
-                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>>;
-                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __address: true;
-                }>, string>>>;
-                $sourceQuery: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>;
-                $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, unknown>>, z.ZodNull]>>;
-                _hash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>>>>;
-                _dataHash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>>>>;
-                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
-                nbf: z.ZodNumber;
-                exp: z.ZodNumber;
-                fees: z.ZodObject<{
-                    base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown>>;
-                    gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown>>;
-                    gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown>>;
-                    priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>, unknown>>;
-                }, z.core.$strip>;
-                chain: z.ZodPipe<z.ZodString, z.ZodTransform<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.ZodTransform<Signed<TransactionBoundWitness>, {
-                schema: "network.xyo.boundwitness";
-                addresses: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __address: true;
-                }>[];
-                payload_hashes: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>[];
-                payload_schemas: string[];
-                previous_hashes: (import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }> | null)[];
-                $signatures: (import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }> | null)[];
-                nbf: number;
-                exp: number;
-                fees: {
-                    base: import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>;
-                    gasLimit: import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>;
-                    gasPrice: import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>;
-                    priority: import("@xylabs/typeof").Brand<Lowercase<string>, {
-                        readonly __hex: true;
-                    }>;
-                };
-                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;
-                }>, {
-                    readonly __address: true;
-                }> | undefined;
-                $sourceQuery?: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }> | undefined;
-                _hash?: string | undefined;
-                _dataHash?: string | undefined;
-                _sequence?: string | undefined;
-                script?: string[] | undefined;
-            }>>;
-        };
-    };
     readonly xyoSigner_signTransaction: {
         readonly params: {
             readonly to: z.ZodTuple<[z.ZodTuple<[z.ZodObject<{
@@ -772,7 +429,7 @@ export declare const XyoSignerRpcSchemas: {
                 script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
             }, z.core.$strip>, z.ZodArray<z.ZodObject<{
                 schema: z.ZodString;
-            }, z.core.$catchall<z.ZodAny>>>], null>, z.ZodTransform<import("@xyo-network/xl1-protocol").HydratedTransactionWithStorageMeta<TransactionBoundWitness, import("@xyo-network/payload-model").Payload>, [{
+            }, z.core.$catchall<z.ZodAny>>>], null>, z.ZodTransform<import("@xyo-network/xl1-protocol").HydratedTransactionWithStorageMeta<import("@xyo-network/xl1-protocol").TransactionBoundWitness, import("@xyo-network/payload-model").Payload>, [{
                 schema: "network.xyo.boundwitness";
                 addresses: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
                     readonly __hex: true;

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

@@ -1 +1 @@
-{"version":3,"file":"XyoSignerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoSignerRpcSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAA;AAC7D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAA;AAExE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAavB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDyB,CAAA"}
+{"version":3,"file":"XyoSignerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoSignerRpcSchemas.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqByB,CAAA"}

package/dist/node/types/schema/common/BlockRange.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const BlockRangeZod: z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>;
+//# sourceMappingURL=BlockRange.d.ts.map

package/dist/node/types/schema/common/BlockRange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockRange.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/BlockRange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,aAAa,4EAGxB,CAAA"}

package/dist/node/types/schema/common/RewardsRangeOptions.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const RewardsRangeOptionsZod: z.ZodObject<{
+    positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    range: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>, z.ZodOptional<z.ZodNumber>], null>>;
+    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        block: z.ZodNumber;
+        step: z.ZodNumber;
+    }, z.core.$strip>>>;
+    stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>>>;
+}, z.core.$strip>;
+//# sourceMappingURL=RewardsRangeOptions.d.ts.map

package/dist/node/types/schema/common/RewardsRangeOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RewardsRangeOptions.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/RewardsRangeOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;iBAKjC,CAAA"}

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

@@ -1,5 +1,6 @@
 export * from './Address.ts';
 export * from './BlockBoundWitness.ts';
+export * from './BlockRange.ts';
 export * from './BoundWitness.ts';
 export * from './Chain.ts';
 export * from './HydratedBlock.ts';
@@ -7,6 +8,7 @@ export * from './HydratedTransaction.ts';
 export * from './Json.ts';
 export * from './Payload.ts';
 export * from './Permission.ts';
+export * from './RewardsRangeOptions.ts';
 export * from './Sequence.ts';
 export * from './Stake.ts';
 export * from './StepIdentity.ts';

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,mBAAmB,CAAA;AACjC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,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,iBAAiB,CAAA;AAC/B,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,0BAA0B,CAAA;AACxC,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,mBAAmB,CAAA;AACjC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA"}

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

@@ -3,9 +3,13 @@ export * from './common/index.ts';
 export * from './createRequestSchema.ts';
 export * from './createResponseSchema.ts';
 export * from './NetworkStakeViewerRpcSchemas.ts';
+export * from './RewardsByPositionViewerRpcSchemas.ts';
+export * from './RewardsByStakerViewerRpcSchemas.ts';
+export * from './RewardsByStepViewerRpcSchemas.ts';
+export * from './RewardsTotalViewerRpcSchemas.ts';
 export * from './RpcSchemaMap.ts';
+export * from './StepRewardsViewerRpcSchemas.ts';
 export * from './XyoPermissionsRpcSchemas.ts';
-export * from './XyoProviderRpcSchemas.ts';
 export * from './XyoRunnerRpcSchemas.ts';
 export * from './XyoSignerRpcSchemas.ts';
 export * from './XyoViewerRpcSchemas.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,mCAAmC,CAAA;AACjD,cAAc,mBAAmB,CAAA;AACjC,cAAc,+BAA+B,CAAA;AAC7C,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,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,+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.15.26",
+  "version": "1.15.28",
   "description": "XYO Layer One API",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -56,45 +56,43 @@
   },
   "dependencies": {
     "@metamask/json-rpc-engine": "~10.1.1",
-    "@metamask/utils": "~11.8.1",
-    "@xylabs/arraybuffer": "~5.0.17",
-    "@xylabs/assert": "~5.0.17",
-    "@xylabs/axios": "~5.0.17",
-    "@xylabs/exists": "~5.0.17",
-    "@xylabs/hex": "~5.0.17",
-    "@xylabs/object": "~5.0.17",
-    "@xylabs/promise": "~5.0.17",
-    "@xylabs/typeof": "~5.0.17",
-    "@xyo-network/account-model": "~5.1.15",
-    "@xyo-network/archivist-memory": "~5.1.15",
-    "@xyo-network/archivist-model": "~5.1.15",
-    "@xyo-network/boundwitness-model": "~5.1.15",
-    "@xyo-network/hash": "~5.1.15",
-    "@xyo-network/module-model": "~5.1.15",
-    "@xyo-network/node-model": "~5.1.15",
-    "@xyo-network/payload-builder": "~5.1.15",
-    "@xyo-network/payload-model": "~5.1.15",
-    "@xyo-network/xl1-protocol": "~1.12.95",
-    "@xyo-network/xl1-protocol-sdk": "~1.15.26",
-    "@xyo-network/xl1-wrappers": "~1.15.26",
-    "axios": "~1.13.1",
+    "@xylabs/arraybuffer": "~5.0.18",
+    "@xylabs/assert": "~5.0.18",
+    "@xylabs/axios": "~5.0.18",
+    "@xylabs/exists": "~5.0.18",
+    "@xylabs/hex": "~5.0.18",
+    "@xylabs/promise": "~5.0.18",
+    "@xylabs/typeof": "~5.0.18",
+    "@xyo-network/account-model": "~5.1.17",
+    "@xyo-network/archivist-memory": "~5.1.17",
+    "@xyo-network/archivist-model": "~5.1.17",
+    "@xyo-network/boundwitness-model": "~5.1.17",
+    "@xyo-network/hash": "~5.1.17",
+    "@xyo-network/module-model": "~5.1.17",
+    "@xyo-network/node-model": "~5.1.17",
+    "@xyo-network/payload-builder": "~5.1.17",
+    "@xyo-network/payload-model": "~5.1.17",
+    "@xyo-network/xl1-protocol": "~1.12.102",
+    "@xyo-network/xl1-protocol-sdk": "~1.15.28",
+    "axios": "~1.13.2",
     "uuid": "~13.0.0",
     "zod": "~4.1.12"
   },
   "devDependencies": {
     "@metamask/utils": "~11.8.1",
-    "@types/node": "~24.9.2",
-    "@xylabs/logger": "~5.0.17",
-    "@xylabs/ts-scripts-yarn3": "~7.1.8",
-    "@xylabs/tsconfig": "~7.1.8",
-    "@xylabs/vitest-extended": "~5.0.17",
-    "@xyo-network/account": "~5.1.15",
-    "@xyo-network/chain-protocol": "~1.15.26",
-    "@xyo-network/wallet": "~5.1.15",
+    "@types/node": "~24.10.0",
+    "@xylabs/logger": "~5.0.18",
+    "@xylabs/object": "~5.0.18",
+    "@xylabs/ts-scripts-yarn3": "~7.2.4",
+    "@xylabs/tsconfig": "~7.2.4",
+    "@xylabs/vitest-extended": "~5.0.18",
+    "@xyo-network/account": "~5.1.17",
+    "@xyo-network/chain-protocol": "~1.15.28",
+    "@xyo-network/wallet": "~5.1.17",
     "dotenv": "~17.2.3",
-    "eslint": "^9.39.0",
+    "eslint": "^9.39.1",
     "typescript": "~5.9.3",
-    "vitest": "~3.2.4"
+    "vitest": "~4.0.7"
   },
   "packageManager": "yarn@4.6.0",
   "engines": {

package/src/engine/index.ts

@@ -1,3 +1,8 @@
 export * from './requestSchemas.ts'
 export * from './rpcMethodHandlersFromConnection.ts'
+export * from './rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer.ts'
+export * from './rpcMethodHandlersFromNetworkStakingViewer.ts'
 export * from './rpcMethodHandlersFromPermissions.ts'
+export * from './rpcMethodHandlersFromRunner.ts'
+export * from './rpcMethodHandlersFromSigner.ts'
+export * from './rpcMethodHandlersFromViewer.ts'

package/src/engine/rpcMethodHandlersFromConnection.ts

@@ -1,17 +1,21 @@
-import type { XyoConnection } from '@xyo-network/xl1-protocol'
+import type { NetworkStakeViewer, XyoConnection } from '@xyo-network/xl1-protocol'
 
 import type { XyoProviderRpcMethodHandlers } from '../types/index.ts'
+import { rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer } from './rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer.ts'
 import { rpcMethodHandlersFromRunner } from './rpcMethodHandlersFromRunner.ts'
-import { rpcMethodHandlersFromSigner } from './rpcMethodHandlersFromSigner.ts'
 import { rpcMethodHandlersFromViewer } from './rpcMethodHandlersFromViewer.ts'
 
-export const rpcMethodHandlersFromConnection = (connection: XyoConnection): XyoProviderRpcMethodHandlers => {
-  const {
-    runner, signer, viewer,
-  } = connection
-  let result: XyoProviderRpcMethodHandlers = { xyoProvider_send: params => (connection as Required<XyoConnection>).send(...(params ?? [])) }
+/* networkStakeViewer is temporary as a param until it goes into root viewer */
+export const rpcMethodHandlersFromConnection = (connection: XyoConnection, networkStakeViewer?: NetworkStakeViewer): XyoProviderRpcMethodHandlers => {
+  const { runner, viewer } = connection
+  let result: XyoProviderRpcMethodHandlers = {}
   if (runner) result = { ...result, ...rpcMethodHandlersFromRunner(runner) }
-  if (signer) result = { ...result, ...rpcMethodHandlersFromSigner(signer) }
   if (viewer) result = { ...result, ...rpcMethodHandlersFromViewer(viewer) }
+  if (networkStakeViewer?.stepRewards?.position) {
+    result = {
+      ...result,
+      ...rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer(networkStakeViewer.stepRewards.position),
+    }
+  }
   return result
 }

package/src/engine/rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer.ts

@@ -0,0 +1,14 @@
+import type { RewardsByPositionViewerMethods } from '@xyo-network/xl1-protocol'
+
+import type { NetworkStakingStepRewardsByPositionViewerRpcMethodHandlers } from '../types/index.ts'
+
+export const rpcMethodHandlersFromNetworkStakingStepRewardsByPositionViewer
+  = (viewer: RewardsByPositionViewerMethods): NetworkStakingStepRewardsByPositionViewerRpcMethodHandlers => {
+    return {
+      networkStakingStepRewardsByPositionViewer_bonus: params => viewer.bonus(...(params ?? [])),
+      networkStakingStepRewardsByPositionViewer_claimed: params => viewer.claimed(...(params ?? [])),
+      networkStakingStepRewardsByPositionViewer_earned: params => viewer.earned(...(params ?? [])),
+      networkStakingStepRewardsByPositionViewer_total: params => viewer.total(...(params ?? [])),
+      networkStakingStepRewardsByPositionViewer_unclaimed: params => viewer.unclaimed(...(params ?? [])),
+    }
+  }

package/src/engine/rpcMethodHandlersFromNetworkStakingViewer.ts

@@ -0,0 +1,7 @@
+import type { NetworkStakeViewerMethods } from '@xyo-network/xl1-protocol'
+
+import type { NetworkStakeViewerRpcMethodHandlers } from '../types/index.ts'
+
+export const rpcMethodHandlersFromNetworkStakingViewer = (viewer: NetworkStakeViewerMethods): NetworkStakeViewerRpcMethodHandlers => {
+  return { networkStakeViewer_active: params => viewer.active(...(params ?? [])) }
+}

package/src/engine/rpcMethodHandlersFromSigner.ts

@@ -5,7 +5,6 @@ import type { XyoSignerRpcMethodHandlers } from '../types/index.ts'
 export const rpcMethodHandlersFromSigner = (signer: XyoSigner): XyoSignerRpcMethodHandlers => {
   return {
     xyoSigner_address: params => signer.address(...(params ?? [])),
-    xyoSigner_createSignedTransaction: params => signer.createSignedTransaction(...(params ?? [])),
     xyoSigner_signTransaction: params => signer.signTransaction(...(params ?? [])),
   }
 }

package/src/engine-node/index.ts

@@ -0,0 +1 @@
+export * from './rpcEngineFromConnection.ts'

package/src/{engine → engine-node}/rpcEngineFromConnection.ts

@@ -1,16 +1,16 @@
 import { createAsyncMiddleware, JsonRpcEngine } from '@metamask/json-rpc-engine'
 import type { Json } from '@metamask/utils'
-import type { XyoConnection } from '@xyo-network/xl1-protocol'
+import type { NetworkStakeViewer, XyoConnection } from '@xyo-network/xl1-protocol'
 
+import { requestSchemas, rpcMethodHandlersFromConnection } from '../engine/index.ts'
 import {
   AllRpcSchemas, createRequestSchema, JsonRpcErrorCodes,
 } from '../types/index.ts'
-import { requestSchemas } from './requestSchemas.ts'
-import { rpcMethodHandlersFromConnection } from './rpcMethodHandlersFromConnection.ts'
 
-export const rpcEngineFromConnection = (connection: XyoConnection) => {
+/* networkStakeViewer is temporary as a param until it goes into root viewer */
+export const rpcEngineFromConnection = (connection: XyoConnection, networkStakeViewer?: NetworkStakeViewer) => {
   const engine = new JsonRpcEngine()
-  const handlers = rpcMethodHandlersFromConnection(connection)
+  const handlers = rpcMethodHandlersFromConnection(connection, networkStakeViewer)
   engine.push(
     createAsyncMiddleware(async (req, res) => {
       // Get method name