@xyo-network/xl1-rpc 1.16.8 → 1.16.10

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

@@ -5,12 +5,8 @@ export declare const StakeZod: z.ZodObject<{
     addBlock: z.ZodNumber;
     id: z.ZodNumber;
     removeBlock: z.ZodNumber;
-    staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>;
-    staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>;
+    staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>;
+    staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>;
     withdrawBlock: z.ZodNumber;
 }, z.core.$strip>;
 export declare const StakeToJsonZod: z.ZodPipe<z.ZodObject<{
@@ -18,48 +14,32 @@ export declare const StakeToJsonZod: z.ZodPipe<z.ZodObject<{
     addBlock: z.ZodNumber;
     id: z.ZodNumber;
     removeBlock: z.ZodNumber;
-    staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>;
-    staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>;
+    staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>;
+    staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>;
     withdrawBlock: z.ZodNumber;
 }, z.core.$strip>, z.ZodTransform<{
     addBlock: number;
     amount: import("@xylabs/hex").Hex;
     id: number;
     removeBlock: number;
-    staked: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>;
-    staker: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>;
+    staked: import("@xylabs/hex").Address;
+    staker: import("@xylabs/hex").Address;
     withdrawBlock: number;
 }, {
     amount: bigint;
     addBlock: number;
     id: number;
     removeBlock: number;
-    staked: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>;
-    staker: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>;
+    staked: import("@xylabs/hex").Address;
+    staker: import("@xylabs/hex").Address;
     withdrawBlock: number;
 }>>;
 export declare const JsonToStakeZod: z.ZodPipe<z.ZodObject<{
     addBlock: z.ZodNumber;
     id: z.ZodNumber;
     removeBlock: z.ZodNumber;
-    staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>;
-    staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>;
+    staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>;
+    staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>;
     withdrawBlock: z.ZodNumber;
     amount: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
 }, z.core.$strip>, z.ZodTransform<{
@@ -67,23 +47,15 @@ export declare const JsonToStakeZod: z.ZodPipe<z.ZodObject<{
     amount: import("@xyo-network/xl1-protocol").AttoXL1;
     id: PositionId;
     removeBlock: number;
-    staked: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>;
-    staker: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>;
+    staked: import("@xylabs/hex").Address;
+    staker: import("@xylabs/hex").Address;
     withdrawBlock: number;
 }, {
     addBlock: number;
     id: number;
     removeBlock: number;
-    staked: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>;
-    staker: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>;
+    staked: import("@xylabs/hex").Address;
+    staker: import("@xylabs/hex").Address;
     withdrawBlock: number;
     amount: import("@xylabs/hex").Hex;
 }>>;

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

@@ -1 +1 @@
-{"version":3,"file":"Stake.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Stake.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAOxB,eAAO,MAAM,QAAQ;;;;;;;;;;;;iBAcnB,CAAA;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQxB,CAAA;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;QAGX,UAAU;;;;;;;;;;;;;;;;;;;;;GAKvB,CAAA"}
+{"version":3,"file":"Stake.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Stake.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,QAAQ;;;;;;;;iBAcnB,CAAA;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;GAQxB,CAAA;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;QAGX,UAAU;;;;;;;;;;;;;GAKvB,CAAA"}

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

@@ -0,0 +1,3 @@
+import * as z from 'zod';
+export declare const TimeDomainZod: z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>;
+//# sourceMappingURL=TimeDomain.d.ts.map

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

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

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

@@ -22,17 +22,13 @@ export declare const WithTransactionFeesZod: z.ZodObject<{
 }, z.core.$strip>;
 export declare const TransactionBoundWitnessZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").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/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
     _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -52,17 +48,13 @@ export declare const TransactionBoundWitnessZod: z.ZodObject<{
 }, z.core.$strip>;
 export declare const SignedTransactionBoundWitnessZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.boundwitness">;
-    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").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/hex").Hash, string>>>>;
-    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-        readonly __address: true;
-    }>, string>>>;
+    $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
     $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
     $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
     _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;

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

@@ -1 +1 @@
-{"version":3,"file":"TransactionBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionBoundWitness.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,aAAa;;iBAAoC,CAAA;AAC9D,eAAO,MAAM,WAAW;;iBAAoC,CAAA;AAC5D,eAAO,MAAM,gBAAgB;;;iBAAyD,CAAA;AACtF,eAAO,MAAM,eAAe;;iBAAuD,CAAA;AAEnF,eAAO,MAAM,sBAAsB;;;;;;;iBAA4C,CAAA;AAM/E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUd,CAAA;AAEzB,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUV,CAAA"}
+{"version":3,"file":"TransactionBoundWitness.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionBoundWitness.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,aAAa;;iBAAoC,CAAA;AAC9D,eAAO,MAAM,WAAW;;iBAAoC,CAAA;AAC5D,eAAO,MAAM,gBAAgB;;;iBAAyD,CAAA;AACtF,eAAO,MAAM,eAAe;;iBAAuD,CAAA;AAEnF,eAAO,MAAM,sBAAsB;;;;;;;iBAA4C,CAAA;AAM/E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;iBAUd,CAAA;AAEzB,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;iBAUV,CAAA"}

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

@@ -1,7 +1,3 @@
 import z from 'zod';
-export declare const TransferPairZod: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-    readonly __address: true;
-}>, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-    readonly __address: true;
-}>, string>>], null>;
+export declare const TransferPairZod: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>], null>;
 //# sourceMappingURL=TransferPair.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"TransferPair.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransferPair.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,eAAe;;;;oBAE1B,CAAA"}
+{"version":3,"file":"TransferPair.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransferPair.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,eAAO,MAAM,eAAe,kLAE1B,CAAA"}

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

@@ -1,4 +1,3 @@
-export * from './Address.ts';
 export * from './ArrayBuffer.ts';
 export * from './BlockBoundWitness.ts';
 export * from './BoundWitness.ts';
@@ -10,9 +9,8 @@ export * from './Permission.ts';
 export * from './RewardsRangeOptions.ts';
 export * from './Sequence.ts';
 export * from './Stake.ts';
-export * from './StepIdentity.ts';
+export * from './TimeDomain.ts';
 export * from './TransactionBoundWitness.ts';
 export * from './TransactionFees.ts';
-export * from './Transfer.ts';
 export * from './TransferPair.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,kBAAkB,CAAA;AAChC,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,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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,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,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sBAAsB,CAAA;AACpC,cAAc,mBAAmB,CAAA"}

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

@@ -10,6 +10,7 @@ export * from './RewardsByStepViewerRpcSchemas.ts';
 export * from './RewardsTotalViewerRpcSchemas.ts';
 export * from './RpcSchemaMap.ts';
 export * from './StepRewardsViewerRpcSchemas.ts';
+export * from './TimeSyncViewerRpcSchema.ts';
 export * from './XyoPermissionsRpcSchemas.ts';
 export * from './XyoRunnerRpcSchemas.ts';
 export * from './XyoSignerRpcSchemas.ts';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,2BAA2B,CAAA;AACzC,cAAc,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,+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,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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-rpc",
-  "version": "1.16.8",
+  "version": "1.16.10",
   "description": "XYO Layer One API",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -56,18 +56,18 @@
   },
   "dependencies": {
     "@metamask/json-rpc-engine": "~10.1.1",
-    "@xylabs/assert": "~5.0.24",
-    "@xylabs/axios": "~5.0.24",
-    "@xylabs/hex": "~5.0.24",
-    "@xylabs/typeof": "~5.0.24",
+    "@xylabs/assert": "~5.0.25",
+    "@xylabs/axios": "~5.0.25",
+    "@xylabs/hex": "~5.0.25",
+    "@xylabs/typeof": "~5.0.25",
     "@xyo-network/archivist-model": "~5.1.21",
     "@xyo-network/boundwitness-model": "~5.1.21",
     "@xyo-network/module-model": "~5.1.21",
     "@xyo-network/node-model": "~5.1.21",
     "@xyo-network/payload-builder": "~5.1.21",
     "@xyo-network/payload-model": "~5.1.21",
-    "@xyo-network/xl1-protocol": "~1.13.6",
-    "@xyo-network/xl1-protocol-sdk": "~1.16.8",
+    "@xyo-network/xl1-protocol": "~1.13.11",
+    "@xyo-network/xl1-protocol-sdk": "~1.16.10",
     "axios": "~1.13.2",
     "uuid": "~13.0.0",
     "zod": "~4.1.12"
@@ -75,19 +75,19 @@
   "devDependencies": {
     "@metamask/utils": "~11.8.1",
     "@types/node": "~24.10.1",
-    "@xylabs/logger": "~5.0.24",
-    "@xylabs/object": "~5.0.24",
+    "@xylabs/logger": "~5.0.25",
+    "@xylabs/object": "~5.0.25",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xylabs/vitest-extended": "~5.0.24",
+    "@xylabs/vitest-extended": "~5.0.25",
     "@xyo-network/account": "~5.1.21",
     "@xyo-network/account-model": "~5.1.21",
-    "@xyo-network/chain-protocol": "~1.16.8",
+    "@xyo-network/chain-protocol": "~1.16.10",
     "@xyo-network/wallet": "~5.1.21",
     "dotenv": "~17.2.3",
     "eslint": "^9.39.1",
     "typescript": "~5.9.3",
-    "vitest": "~4.0.8"
+    "vitest": "~4.0.9"
   },
   "packageManager": "yarn@4.6.0",
   "engines": {

package/src/engine/rpcMethodHandlersFromViewer.ts

@@ -37,7 +37,6 @@ export const rpcMethodHandlersFromViewer = (viewer: XyoViewer): XyoViewerRpcMeth
     xyoViewer_stakeByStaker: params => viewer.stakeByStaker(...(params ?? [])),
     xyoViewer_stakesByStaked: params => viewer.stakesByStaked(...(params ?? [])),
     xyoViewer_stakesByStaker: params => viewer.stakesByStaker(...(params ?? [])),
-    xyoViewer_stakedByStaker: params => viewer.stakedByStaker(...(params ?? [])),
     xyoViewer_transactionByBlockHashAndIndex: params => viewer.transactionByBlockHashAndIndex(...(params ?? [])),
     xyoViewer_transactionByBlockNumberAndIndex: params => viewer.transactionByBlockNumberAndIndex(...(params ?? [])),
     xyoViewer_transactionByHash: params => viewer.transactionByHash(...(params ?? [])),

package/src/engine-node/rpcEngineFromConnection.ts

@@ -37,6 +37,7 @@ export const rpcEngineFromConnection = (connection: XyoConnection, networkStakeV
       const parsed = requestSchema.safeParse(req)
       // If validation fails
       if (!parsed.success) {
+        console.error('RPC Request Validation Error:', parsed.error)
         res.error = {
           // Return invalid params error
           ...JsonRpcErrorCodes.InvalidParams,
@@ -48,9 +49,14 @@ export const rpcEngineFromConnection = (connection: XyoConnection, networkStakeV
 
       // Call handler with validated params
       const { params } = parsed.data
-      const result = await handler(params as never)
-      // Parse handler result according to schema
-      res.result = schema.result.to.parse(result) as Json
+      try {
+        const result = await handler(params as never)
+        // Parse handler result according to schema
+        res.result = schema.result.to.parse(result) as Json
+      } catch (error) {
+        console.error('RPC Response Handler Error:', error)
+        throw error
+      }
     }),
   )
   return engine

package/src/provider/runner/NodeXyoRunner.ts

@@ -39,12 +39,12 @@ export class NodeXyoRunner implements XyoRunner {
 
   protected getArchivist = async (identifier: ModuleIdentifier) => {
     const archivist = await this.node.resolve(identifier)
-    return assertEx(asArchivistInstance(archivist), () => `Error: Could not resolve ${identifier} to an archivist instance`)
+    return assertEx(asArchivistInstance(archivist), () => `Could not resolve ${identifier} to an archivist instance`)
   }
 
   protected getPendingArchivist = async () => {
     if (this._pendingArchivist) return this._pendingArchivist
     this._pendingArchivist = await this.getArchivist(this.pendingArchivistPath)
-    return assertEx(this._pendingArchivist, () => `Error: Could not resolve pending archivist at ${this.pendingArchivistPath}`)
+    return assertEx(this._pendingArchivist, () => `Could not resolve pending archivist at ${this.pendingArchivistPath}`)
   }
 }

package/src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewer.ts

@@ -0,0 +1,11 @@
+import type { TimeSyncViewer } from '@xyo-network/xl1-protocol-sdk'
+
+import type { RpcTransport } from '../../../transport/index.ts'
+import type { TimeSyncViewerRpcSchemas } from '../../../types/index.ts'
+import { JsonRpcTimeSyncViewerMethods } from './JsonRpcTimeSyncViewerMethods.ts'
+
+export class JsonRpcTimeSyncViewer extends JsonRpcTimeSyncViewerMethods implements TimeSyncViewer {
+  constructor(transport: RpcTransport<typeof TimeSyncViewerRpcSchemas>) {
+    super(transport)
+  }
+}

package/src/provider/viewer/JsonRpcTimeSyncViewer/JsonRpcTimeSyncViewerMethods.ts

@@ -0,0 +1,32 @@
+import type {
+  TimeDomain,
+  TimePayload,
+} from '@xyo-network/xl1-protocol'
+import type { TimeSyncViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+
+import type { RpcTransport } from '../../../transport/index.ts'
+import type { TimeSyncViewerRpcSchemas } from '../../../types/index.ts'
+
+export class JsonRpcTimeSyncViewerMethods implements TimeSyncViewerMethods {
+  protected readonly transport: RpcTransport<typeof TimeSyncViewerRpcSchemas>
+
+  constructor(transport: RpcTransport<typeof TimeSyncViewerRpcSchemas>) {
+    this.transport = transport
+  }
+
+  async convertTime(fromDomain: TimeDomain, toDomain: TimeDomain, from: number): Promise<number> {
+    return await this.transport.sendRequest('timeSyncViewer_convertTime', [fromDomain, toDomain, from])
+  }
+
+  async currentTime(domain: TimeDomain): Promise<[string, number]> {
+    return await this.transport.sendRequest('timeSyncViewer_currentTime', [domain])
+  }
+
+  async currentTimeAndHash(domain: TimeDomain): Promise<[number, string | null]> {
+    return await this.transport.sendRequest('timeSyncViewer_currentTimeAndHash', [domain])
+  }
+
+  async currentTimePayload(): Promise<TimePayload> {
+    return await this.transport.sendRequest('timeSyncViewer_currentTimePayload', [])
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './JsonRpcTimeSyncViewer.ts'
+export * from './JsonRpcTimeSyncViewerMethods.ts'

package/src/provider/viewer/JsonRpcXyoViewer.ts

@@ -1,7 +1,7 @@
 import {
-  type Address, asHash, type Hash,
-  isHash,
+  type Address, type Hash, isHash,
 } from '@xylabs/hex'
+import { isDefined } from '@xylabs/typeof'
 import type {
   AttoXL1,
   BlockRange,
@@ -10,15 +10,12 @@ import type {
   SignedHydratedTransaction,
   StepIdentity,
   StepIdentityString,
+  XL1BlockNumber,
   XL1BlockRange,
 } from '@xyo-network/xl1-protocol'
-import {
-  asAttoXL1, asHydratedBlock, asXL1BlockRange,
-  isRange,
-} from '@xyo-network/xl1-protocol'
+import { asAttoXL1, asHydratedBlock } from '@xyo-network/xl1-protocol'
 import type {
-  AccountBalanceHistoryItem,
-  ForkHistory, NetworkStakeViewer, Position, TransferBalanceHistoryItem, TransferPair, XyoViewer,
+  AccountBalanceHistoryItem, ForkHistory, NetworkStakeViewer, Position, TransferBalanceHistoryItem, TransferPair, XyoViewer,
 } from '@xyo-network/xl1-protocol-sdk'
 
 import type { RpcTransport } from '../../transport/index.ts'
@@ -49,15 +46,13 @@ export class JsonRpcXyoViewer implements XyoViewer {
   async accountBalanceHistory(address: Address, head: Hash): Promise<AccountBalanceHistoryItem[]>
   async accountBalanceHistory(address: Address, range: BlockRange): Promise<AccountBalanceHistoryItem[]>
   async accountBalanceHistory(address: Address, headOrRange?: BlockRange | Hash): Promise<AccountBalanceHistoryItem[]> {
-    const head = asHash(headOrRange)
-    const range = asXL1BlockRange(headOrRange)
-    if (isHash(head)) {
-      return (await this.transport.sendRequest('xyoViewer_accountBalanceHistory', [address, head])) as AccountBalanceHistoryItem[]
-    }
-    if (isRange(range)) {
-      return (await this.transport.sendRequest('xyoViewer_accountBalanceHistory', [address, range])) as AccountBalanceHistoryItem[]
+    if (isDefined(headOrRange)) {
+      if (isHash(headOrRange)) {
+        return (await this.transport.sendRequest('xyoViewer_accountBalanceHistory', [address, headOrRange])) as AccountBalanceHistoryItem[]
+      }
+      return (await this.transport.sendRequest('xyoViewer_accountBalanceHistory', [address, headOrRange])) as AccountBalanceHistoryItem[]
     }
-    return (await this.transport.sendRequest('xyoViewer_accountBalanceHistory', [address, range])) as AccountBalanceHistoryItem[]
+    return (await this.transport.sendRequest('xyoViewer_accountBalanceHistory', [address])) as AccountBalanceHistoryItem[]
   }
 
   async blockByHash(hash: Hash): Promise<HydratedBlock | null> {
@@ -88,7 +83,7 @@ export class JsonRpcXyoViewer implements XyoViewer {
     return (await this.transport.sendRequest('xyoViewer_currentBlockHash'))
   }
 
-  async currentBlockNumber(): Promise<number> {
+  async currentBlockNumber(): Promise<XL1BlockNumber> {
     return (await this.transport.sendRequest('xyoViewer_currentBlockNumber'))
   }
 
@@ -176,10 +171,6 @@ export class JsonRpcXyoViewer implements XyoViewer {
     return (await this.transport.sendRequest('xyoViewer_stakeByStaker', [staker, slot]))
   }
 
-  async stakedByStaker(staker: Address): Promise<Address[]> {
-    return (await this.transport.sendRequest('xyoViewer_stakedByStaker', [staker]))
-  }
-
   async stakesByStaked(staked: Address): Promise<Position[]> {
     return (await this.transport.sendRequest('xyoViewer_stakesByStaked', [staked]))
   }

package/src/provider/viewer/index.ts

@@ -1,4 +1,5 @@
 export * from './JsonRpcNetworkStakeViewer/index.ts'
 export * from './JsonRpcNetworkStakingStepRewardsViewer/index.ts'
+export * from './JsonRpcTimeSyncViewer/index.ts'
 export * from './JsonRpcViewer.ts'
 export * from './JsonRpcXyoViewer.ts'

package/src/types/TimeSyncViewerRpc.ts

@@ -0,0 +1,16 @@
+import type { TimeSyncViewerMethods } from '@xyo-network/xl1-protocol-sdk'
+
+import type { MethodName, RpcMethodName } from './RpcMethodName.ts'
+
+export const TimeSyncViewerRpcNamespace = 'timeSyncViewer' as const
+export type TimeSyncViewerRpcNamespace = typeof TimeSyncViewerRpcNamespace
+
+export type TimeSyncViewerMethodName = MethodName<TimeSyncViewerMethods>
+export type TimeSyncViewerRpcMethodName = RpcMethodName<TimeSyncViewerRpcNamespace,
+  TimeSyncViewerMethodName>
+
+export type TimeSyncViewerRpcMethodHandlers = {
+  [K in TimeSyncViewerMethodName as TimeSyncViewerRpcMethodName]: (
+    params: Parameters<TimeSyncViewerMethods[K]>,
+  ) => ReturnType<TimeSyncViewerMethods[K]>
+}

package/src/types/index.ts

@@ -1,3 +1,4 @@
+export * from './DataLakeViewerRpc.ts'
 export * from './ErrorCodes.ts'
 export * from './JsonRpc.ts'
 export * from './NetworkStakeViewerRpc.ts'
@@ -8,6 +9,7 @@ export * from './NetworkStakingStepRewardsTotalViewerRpc.ts'
 export * from './NetworkStakingStepRewardsViewerRpc.ts'
 export * from './RpcMethodName.ts'
 export * from './schema/index.ts'
+export * from './TimeSyncViewerRpc.ts'
 export * from './XyoPermissions.ts'
 export * from './XyoProviderRpc.ts'
 export * from './XyoRunnerRpc.ts'

package/src/types/schema/DataLakeViewerRpcSchema.ts

@@ -2,7 +2,7 @@ import { HashZod } from '@xylabs/hex'
 import { PayloadZod } from '@xyo-network/payload-model'
 import * as z from 'zod'
 
-import type { DataLakeViewerRpcMethodName } from '../XyoDataLakeViewerRpc.ts'
+import type { DataLakeViewerRpcMethodName } from '../DataLakeViewerRpc.ts'
 import { ArrayBufferToJsonZod, JsonToArrayBufferZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 

package/src/types/schema/RewardsByStakerViewerRpcSchemas.ts

@@ -1,8 +1,10 @@
-import { BigIntToJsonZod, JsonToBigIntZod } from '@xylabs/hex'
+import {
+  AddressZod, BigIntToJsonZod, JsonToBigIntZod,
+} from '@xylabs/hex'
 import z from 'zod'
 
 import type { NetworkStakingStepRewardsByStakerViewerRpcMethodName } from '../NetworkStakingStepRewardsByStakerViewerRpc.ts'
-import { AddressZod, RewardsRangeOptionsZod } from './common/index.ts'
+import { RewardsRangeOptionsZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
 export const NetworkStakingStepRewardsByStakerViewerRpcSchemas = {

package/src/types/schema/RewardsByStepViewerRpcSchemas.ts

@@ -1,8 +1,10 @@
-import { BigIntToJsonZod, JsonToBigIntZod } from '@xylabs/hex'
+import {
+  AddressZod, BigIntToJsonZod, JsonToBigIntZod,
+} from '@xylabs/hex'
 import z from 'zod'
 
 import type { NetworkStakingStepRewardsByStepViewerRpcMethodName } from '../NetworkStakingStepRewardsByStepViewerRpc.ts'
-import { AddressZod, RewardsRangeOptionsZod } from './common/index.ts'
+import { RewardsRangeOptionsZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
 export const NetworkStakingStepRewardsByStepViewerRpcSchemas = {

package/src/types/schema/StepViewerRpcSchemas.ts

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

package/src/types/schema/TimeSyncViewerRpcSchema.ts

@@ -0,0 +1,49 @@
+import { TimePayloadZod } from '@xyo-network/xl1-protocol'
+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 = {
+  timeSyncViewer_convertTime: {
+    params: {
+      from: z.tuple([TimeDomainZod, TimeDomainZod, z.number()]),
+      to: z.tuple([TimeDomainZod, TimeDomainZod, z.number()]),
+    },
+    result: {
+      from: z.number(),
+      to: z.number(),
+    },
+  },
+  timeSyncViewer_currentTime: {
+    params: {
+      from: z.tuple([TimeDomainZod]),
+      to: z.tuple([TimeDomainZod]),
+    },
+    result: {
+      from: z.tuple([TimeDomainZod, z.number()]),
+      to: z.tuple([TimeDomainZod, z.number()]),
+    },
+  },
+  timeSyncViewer_currentTimeAndHash: {
+    params: {
+      from: z.tuple([TimeDomainZod]),
+      to: z.tuple([TimeDomainZod]),
+    },
+    result: {
+      from: z.tuple([z.number(), z.nullable(z.string())]),
+      to: z.tuple([z.number(), z.nullable(z.string())]),
+    },
+  },
+  timeSyncViewer_currentTimePayload: {
+    params: {
+      from: z.tuple([]),
+      to: z.tuple([]),
+    },
+    result: {
+      from: TimePayloadZod,
+      to: TimePayloadZod,
+    },
+  },
+} satisfies RpcSchemaMap<TimeSyncViewerRpcMethodName>

package/src/types/schema/XyoSignerRpcSchemas.ts

@@ -1,9 +1,9 @@
+import { AddressZod } from '@xylabs/hex'
 import { asHydratedTransactionWithStorageMeta } from '@xyo-network/xl1-protocol'
 import { z } from 'zod'
 
 import type { XyoSignerRpcMethodName } from '../XyoSignerRpc.ts'
 import {
-  AddressZod,
   SignedHydratedTransactionZod,
   UnsignedHydratedTransactionZod,
 } from './common/index.ts'