@xyo-network/xl1-rpc 1.14.0 → 1.14.2

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

@@ -40,7 +40,7 @@ export declare const XyoViewerRpcSchemas: {
             }>>>;
         };
     };
-    xyoViewer_accountHistory: {
+    xyoViewer_accountBalanceHistory: {
         params: {
             to: z.ZodUnion<readonly [z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
                 readonly __hex: true;
@@ -718,6 +718,24 @@ export declare const XyoViewerRpcSchemas: {
             }>, string>>;
         };
     };
+    xyoViewer_chainIdAtBlock: {
+        params: {
+            to: z.ZodTuple<[z.ZodNumber], null>;
+            from: z.ZodTuple<[z.ZodNumber], null>;
+        };
+        result: {
+            to: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                readonly __hex: true;
+            }>, {
+                readonly __address: true;
+            }>, string>>;
+            from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                readonly __hex: true;
+            }>, {
+                readonly __address: true;
+            }>, string>>;
+        };
+    };
     xyoViewer_currentBlock: {
         params: {
             to: z.ZodOptional<z.ZodArray<z.ZodAny>>;
@@ -940,6 +958,248 @@ export declare const XyoViewerRpcSchemas: {
             from: z.ZodNumber;
         };
     };
+    xyoViewer_forkHistory: {
+        params: {
+            to: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+            from: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+        };
+        result: {
+            to: z.ZodRecord<z.ZodNumber, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                readonly __hex: true;
+            }>, {
+                readonly __address: true;
+            }>, string>>>;
+            from: z.ZodRecord<z.ZodNumber, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                readonly __hex: true;
+            }>, {
+                readonly __address: true;
+            }>, string>>>;
+        };
+    };
+    xyoViewer_stakeByAddress: {
+        params: {
+            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                readonly __hex: true;
+            }>, {
+                readonly __address: true;
+            }>, string>>, z.ZodNumber], null>;
+            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                readonly __hex: true;
+            }>, {
+                readonly __address: true;
+            }>, string>>, z.ZodNumber], null>;
+        };
+        result: {
+            to: z.ZodPipe<z.ZodObject<{
+                addBlock: z.ZodNumber;
+                amount: z.ZodBigInt;
+                id: z.ZodNumber;
+                removeBlock: z.ZodNumber;
+                staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>;
+                staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>;
+                withdrawBlock: z.ZodNumber;
+            }, z.core.$strip>, z.ZodTransform<{
+                addBlock: number;
+                amount: import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>;
+                id: number;
+                removeBlock: number;
+                staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                withdrawBlock: number;
+            }, {
+                addBlock: number;
+                amount: bigint;
+                id: number;
+                removeBlock: number;
+                staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                withdrawBlock: number;
+            }>>;
+            from: z.ZodPipe<z.ZodObject<{
+                addBlock: z.ZodNumber;
+                amount: z.ZodBigInt;
+                id: z.ZodNumber;
+                removeBlock: z.ZodNumber;
+                staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>;
+                staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>;
+                withdrawBlock: z.ZodNumber;
+            }, z.core.$strip>, z.ZodTransform<{
+                addBlock: number;
+                amount: import("@xyo-network/xl1-protocol").AttoXL1;
+                id: number;
+                removeBlock: number;
+                staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                withdrawBlock: number;
+            }, {
+                addBlock: number;
+                amount: bigint;
+                id: number;
+                removeBlock: number;
+                staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                withdrawBlock: number;
+            }>>;
+        };
+    };
+    xyoViewer_stakeById: {
+        params: {
+            to: z.ZodTuple<[z.ZodNumber], null>;
+            from: z.ZodTuple<[z.ZodNumber], null>;
+        };
+        result: {
+            to: z.ZodPipe<z.ZodObject<{
+                addBlock: z.ZodNumber;
+                amount: z.ZodBigInt;
+                id: z.ZodNumber;
+                removeBlock: z.ZodNumber;
+                staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>;
+                staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>;
+                withdrawBlock: z.ZodNumber;
+            }, z.core.$strip>, z.ZodTransform<{
+                addBlock: number;
+                amount: import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>;
+                id: number;
+                removeBlock: number;
+                staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                withdrawBlock: number;
+            }, {
+                addBlock: number;
+                amount: bigint;
+                id: number;
+                removeBlock: number;
+                staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                withdrawBlock: number;
+            }>>;
+            from: z.ZodPipe<z.ZodObject<{
+                addBlock: z.ZodNumber;
+                amount: z.ZodBigInt;
+                id: z.ZodNumber;
+                removeBlock: z.ZodNumber;
+                staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>;
+                staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>;
+                withdrawBlock: z.ZodNumber;
+            }, z.core.$strip>, z.ZodTransform<{
+                addBlock: number;
+                amount: import("@xyo-network/xl1-protocol").AttoXL1;
+                id: number;
+                removeBlock: number;
+                staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                withdrawBlock: number;
+            }, {
+                addBlock: number;
+                amount: bigint;
+                id: number;
+                removeBlock: number;
+                staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>;
+                withdrawBlock: number;
+            }>>;
+        };
+    };
     xyoViewer_transactionByBlockHashAndIndex: {
         params: {
             to: z.ZodTuple<[z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<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":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAYxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyIgB,CAAA"}
+{"version":3,"file":"XyoViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoViewerRpcSchemas.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAcxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiLgB,CAAA"}

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

@@ -0,0 +1,119 @@
+import * as z from 'zod';
+export declare const StakeZod: z.ZodObject<{
+    addBlock: z.ZodNumber;
+    amount: z.ZodBigInt;
+    id: z.ZodNumber;
+    removeBlock: z.ZodNumber;
+    staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>;
+    staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>;
+    withdrawBlock: z.ZodNumber;
+}, z.core.$strip>;
+export declare const StakeToJsonZod: z.ZodPipe<z.ZodObject<{
+    addBlock: z.ZodNumber;
+    amount: z.ZodBigInt;
+    id: z.ZodNumber;
+    removeBlock: z.ZodNumber;
+    staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>;
+    staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>;
+    withdrawBlock: z.ZodNumber;
+}, z.core.$strip>, z.ZodTransform<{
+    addBlock: number;
+    amount: import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>;
+    id: number;
+    removeBlock: number;
+    staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>;
+    staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>;
+    withdrawBlock: number;
+}, {
+    addBlock: number;
+    amount: bigint;
+    id: number;
+    removeBlock: number;
+    staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>;
+    staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>;
+    withdrawBlock: number;
+}>>;
+export declare const JsonToStakeZod: z.ZodPipe<z.ZodObject<{
+    addBlock: z.ZodNumber;
+    amount: z.ZodBigInt;
+    id: z.ZodNumber;
+    removeBlock: z.ZodNumber;
+    staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>;
+    staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>, string>>;
+    withdrawBlock: z.ZodNumber;
+}, z.core.$strip>, z.ZodTransform<{
+    addBlock: number;
+    amount: import("@xyo-network/xl1-protocol").AttoXL1;
+    id: number;
+    removeBlock: number;
+    staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>;
+    staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>;
+    withdrawBlock: number;
+}, {
+    addBlock: number;
+    amount: bigint;
+    id: number;
+    removeBlock: number;
+    staked: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>;
+    staker: import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+        readonly __hex: true;
+    }>, {
+        readonly __address: true;
+    }>;
+    withdrawBlock: number;
+}>>;
+//# sourceMappingURL=Stake.d.ts.map

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

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

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

@@ -1,9 +1,13 @@
 import * as z from 'zod';
-export declare const AttoFromStringZod: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
+export declare const AttoZod: z.ZodBigInt;
+export declare const JsonToAttoZod: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
     readonly __hex: true;
 }>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
     readonly __hex: true;
 }>>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
+export declare const AttoToJsonZod: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
+    readonly __hex: true;
+}>, bigint>>;
 export declare const TransactionFeesHexZod: z.ZodObject<{
     base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
         readonly __hex: true;

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

@@ -1 +1 @@
-{"version":3,"file":"TransactionFees.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionFees.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAGxB,eAAO,MAAM,iBAAiB;;;;0EAA+C,CAAA;AAE7E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;iBAKhC,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAE7E,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAA;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEnF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC/F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA"}
+{"version":3,"file":"TransactionFees.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionFees.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,OAAO,aAAa,CAAA;AACjC,eAAO,MAAM,aAAa;;;;0EAA+C,CAAA;AAEzE,eAAO,MAAM,aAAa;;YAAkB,CAAA;AAE5C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;iBAKhC,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAE7E,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAA;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEnF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC/F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA"}

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

@@ -1,5 +1,4 @@
 export * from './Address.ts';
-export * from './AllowedBlockPayload.ts';
 export * from './BlockBoundWitness.ts';
 export * from './BoundWitness.ts';
 export * from './Chain.ts';
@@ -8,6 +7,7 @@ export * from './HydratedTransaction.ts';
 export * from './Json.ts';
 export * from './Payload.ts';
 export * from './Sequence.ts';
+export * from './Stake.ts';
 export * from './TransactionBoundWitness.ts';
 export * from './TransactionFees.ts';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,0BAA0B,CAAA;AACxC,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,eAAe,CAAA;AAC7B,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-rpc",
-  "version": "1.14.0",
+  "version": "1.14.2",
   "description": "XYO Layer One API",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -56,7 +56,7 @@
   },
   "dependencies": {
     "@metamask/json-rpc-engine": "~10.0.3",
-    "@metamask/utils": "~11.4.2",
+    "@metamask/utils": "~11.7.0",
     "@xylabs/arraybuffer": "~5.0.11",
     "@xylabs/assert": "~5.0.11",
     "@xylabs/axios": "~5.0.11",
@@ -69,30 +69,29 @@
     "@xyo-network/archivist-memory": "~5.1.0",
     "@xyo-network/archivist-model": "~5.1.0",
     "@xyo-network/boundwitness-model": "~5.1.0",
-    "@xyo-network/core-payload-plugins": "~5.1.0",
     "@xyo-network/hash": "~5.1.0",
     "@xyo-network/module-model": "~5.1.0",
     "@xyo-network/node-model": "~5.1.0",
     "@xyo-network/payload-builder": "~5.1.0",
     "@xyo-network/payload-model": "~5.1.0",
-    "@xyo-network/xl1-protocol": "~1.11.0",
-    "@xyo-network/xl1-protocol-sdk": "~1.14.0",
-    "@xyo-network/xl1-wrappers": "~1.14.0",
+    "@xyo-network/xl1-protocol": "~1.12.14",
+    "@xyo-network/xl1-protocol-sdk": "~1.14.2",
+    "@xyo-network/xl1-wrappers": "~1.14.2",
     "axios": "~1.11.0",
     "uuid": "~11.1.0",
-    "zod": "~4.1.4"
+    "zod": "~4.1.5"
   },
   "devDependencies": {
-    "@metamask/utils": "~11.4.2",
+    "@metamask/utils": "~11.7.0",
     "@types/node": "~24.3.0",
     "@xylabs/logger": "~5.0.11",
     "@xylabs/ts-scripts-yarn3": "~7.1.7",
     "@xylabs/tsconfig": "~7.1.7",
     "@xylabs/vitest-extended": "~5.0.11",
     "@xyo-network/account": "~5.1.0",
-    "@xyo-network/chain-protocol": "~1.14.0",
+    "@xyo-network/chain-protocol": "~1.14.2",
     "@xyo-network/wallet": "~5.1.0",
-    "dotenv": "~17.2.1",
+    "dotenv": "~17.2.2",
     "eslint": "^9.34.0",
     "typescript": "~5.9.2",
     "vitest": "~3.2.4"

package/src/engine/rpcEngineFromProvider.ts

@@ -1,6 +1,6 @@
 import { createAsyncMiddleware, JsonRpcEngine } from '@metamask/json-rpc-engine'
 import type { Json } from '@metamask/utils'
-import type { XyoConnectionProvider } from '@xyo-network/xl1-protocol'
+import type { XyoConnection } from '@xyo-network/xl1-protocol'
 
 import {
   AllRpcSchemas, createRequestSchema, JsonRpcErrorCodes,
@@ -8,7 +8,7 @@ import {
 import { requestSchemas } from './requestSchemas.ts'
 import { rpcMethodHandlersFromProvider } from './rpcMethodHandlersFromProvider.ts'
 
-export const rpcEngineFromProvider = (provider: XyoConnectionProvider) => {
+export const rpcEngineFromProvider = (provider: XyoConnection) => {
   const engine = new JsonRpcEngine()
   const handlers = rpcMethodHandlersFromProvider(provider)
   engine.push(

package/src/engine/rpcMethodHandlersFromProvider.ts

@@ -1,15 +1,15 @@
-import type { XyoConnectionProvider } from '@xyo-network/xl1-protocol'
+import type { XyoConnection } from '@xyo-network/xl1-protocol'
 
 import type { XyoProviderRpcMethodHandlers } from '../types/index.ts'
 import { rpcMethodHandlersFromRunner } from './rpcMethodHandlersFromRunner.ts'
 import { rpcMethodHandlersFromSigner } from './rpcMethodHandlersFromSigner.ts'
 import { rpcMethodHandlersFromViewer } from './rpcMethodHandlersFromViewer.ts'
 
-export const rpcMethodHandlersFromProvider = (provider: XyoConnectionProvider): XyoProviderRpcMethodHandlers => {
+export const rpcMethodHandlersFromProvider = (provider: XyoConnection): XyoProviderRpcMethodHandlers => {
   const {
     runner, signer, viewer,
   } = provider
-  let result: XyoProviderRpcMethodHandlers = { xyoProvider_send: params => (provider as Required<XyoConnectionProvider>).send(...(params ?? [])) }
+  let result: XyoProviderRpcMethodHandlers = { xyoProvider_send: params => (provider as Required<XyoConnection>).send(...(params ?? [])) }
   if (runner) result = { ...result, ...rpcMethodHandlersFromRunner(runner) }
   if (signer) result = { ...result, ...rpcMethodHandlersFromSigner(signer) }
   if (viewer) result = { ...result, ...rpcMethodHandlersFromViewer(viewer) }

package/src/engine/rpcMethodHandlersFromViewer.ts

@@ -5,14 +5,18 @@ import type { XyoViewerRpcMethodHandlers } from '../types/index.ts'
 export const rpcMethodHandlersFromViewer = (viewer: XyoViewer): XyoViewerRpcMethodHandlers => {
   return {
     xyoViewer_accountBalance: params => viewer.accountBalance(...(params ?? [])),
-    xyoViewer_accountHistory: params => viewer.accountHistory(...(params ?? [])),
+    xyoViewer_accountBalanceHistory: params => viewer.accountBalanceHistory(...(params ?? [])),
     xyoViewer_blockByHash: params => viewer.blockByHash(...(params ?? [])),
     xyoViewer_blockByNumber: params => viewer.blockByNumber(...(params ?? [])),
     xyoViewer_blocksByHash: params => viewer.blocksByHash(...(params ?? [])),
     xyoViewer_chainId: params => viewer.chainId(...(params ?? [])),
+    xyoViewer_chainIdAtBlock: params => viewer.chainIdAtBlock(...(params ?? [])),
     xyoViewer_currentBlock: params => viewer.currentBlock(...(params ?? [])),
     xyoViewer_currentBlockHash: params => viewer.currentBlockHash(...(params ?? [])),
     xyoViewer_currentBlockNumber: params => viewer.currentBlockNumber(...(params ?? [])),
+    xyoViewer_forkHistory: params => viewer.forkHistory(...(params ?? [])),
+    xyoViewer_stakeById: params => viewer.stakeById(...(params ?? [])),
+    xyoViewer_stakeByAddress: params => viewer.stakeByAddress(...(params ?? [])),
     xyoViewer_transactionByBlockHashAndIndex: params => viewer.transactionByBlockHashAndIndex(...(params ?? [])),
     xyoViewer_transactionByBlockNumberAndIndex: params => viewer.transactionByBlockNumberAndIndex(...(params ?? [])),
     xyoViewer_transactionByHash: params => viewer.transactionByHash(...(params ?? [])),

package/src/provider/client/spec/MemoryXyoClient.spec.ts

@@ -5,7 +5,7 @@ import type { Payload } from '@xyo-network/payload-model'
 import { HDWallet } from '@xyo-network/wallet'
 import type {
   AllowedBlockPayload, GatewayName, HashPayload, XyoClient,
-  XyoConnectionProvider,
+  XyoConnection,
 } from '@xyo-network/xl1-protocol'
 import { HashSchema } from '@xyo-network/xl1-protocol'
 import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from '@xyo-network/xl1-protocol-sdk'
@@ -30,7 +30,7 @@ describe.skip('Client', () => {
   let account: AccountInstance
   let signer: MemoryXyoSigner
   let store: MemoryPermissionsStore
-  let connection: XyoConnectionProvider
+  let connection: XyoConnection
   let gateway: MemoryXyoGateway
   let client: XyoClient
 

package/src/provider/connection/HttpRpcXyoConnection.ts

@@ -1,6 +1,6 @@
 import { isDefined, isString } from '@xylabs/typeof'
 import type { AccountInstance } from '@xyo-network/account-model'
-import type { XyoDataLakeProvider } from '@xyo-network/xl1-protocol'
+import type { XyoDataLake } from '@xyo-network/xl1-protocol'
 import { isDataLakeProvider } from '@xyo-network/xl1-protocol'
 
 import { HttpRpcTransport } from '../../transport/index.ts'
@@ -9,15 +9,15 @@ import { HttpXyoDataLake } from '../datalake/index.ts'
 import { JsonRpcXyoRunner } from '../runner/index.ts'
 import { MemoryXyoSigner } from '../signer/index.ts'
 import { JsonRpcXyoViewer } from '../viewer/index.ts'
-import { XyoConnection } from './XyoConnection.ts'
+import { XyoBaseConnection } from './XyoBaseConnection.ts'
 
 export interface RpcXyoProviderParams {
   account?: AccountInstance
   endpoint: string
-  storage?: string | XyoDataLakeProvider
+  storage?: string | XyoDataLake
 }
 
-export class HttpRpcXyoConnection extends XyoConnection {
+export class HttpRpcXyoConnection extends XyoBaseConnection {
   constructor(params: RpcXyoProviderParams) {
     const {
       account, endpoint, storage: storageParam,

package/src/provider/connection/{XyoConnection.ts → XyoBaseConnection.ts}

@@ -7,23 +7,23 @@ import type {
   AllowedBlockPayload,
   SignedHydratedTransactionWithStorageMeta,
   TransactionBoundWitness, TransactionFeesBigInt,
-  TransactionOptions, XyoConnectionProvider, XyoDataLakeProvider, XyoDataLakeViewer, XyoNetwork, XyoRunner, XyoSigner, XyoViewer,
+  TransactionOptions, XyoConnection, XyoDataLake, XyoDataLakeViewer, XyoNetwork, XyoRunner, XyoSigner, XyoViewer,
 } from '@xyo-network/xl1-protocol'
 import { defaultTransactionFees, isDataLakeProvider } from '@xyo-network/xl1-protocol'
 import { HydratedTransactionWrapper } from '@xyo-network/xl1-wrappers'
 
-export class XyoConnection implements XyoConnectionProvider {
+export class XyoBaseConnection implements XyoConnection {
   private readonly _network?: XyoNetwork
   private readonly _runner?: XyoRunner
   private readonly _signer?: XyoSigner
-  private readonly _storage?: XyoDataLakeProvider | XyoDataLakeViewer
+  private readonly _storage?: XyoDataLake | XyoDataLakeViewer
   private readonly _viewer?: XyoViewer
 
   constructor(params?: {
     network?: XyoNetwork
     runner?: XyoRunner
     signer?: XyoSigner
-    storage?: XyoDataLakeProvider | XyoDataLakeViewer
+    storage?: XyoDataLake | XyoDataLakeViewer
     viewer?: XyoViewer
   }) {
     this._network = params?.network
@@ -46,7 +46,7 @@ export class XyoConnection implements XyoConnectionProvider {
     return this._signer
   }
 
-  get storage(): XyoDataLakeProvider | XyoDataLakeViewer | undefined {
+  get storage(): XyoDataLake | XyoDataLakeViewer | undefined {
     return this._storage
   }