@xyo-network/xl1-rpc 1.24.23 → 1.24.25

package/dist/neutral/index.mjs

@@ -197,7 +197,7 @@ var rpcMethodHandlersFromSigner = (signer) => {
 };
 
 // src/provider/datalake/JsonRpcDataLakeViewer.ts
-import { creatableProvider as creatableProvider11 } from "@xyo-network/xl1-protocol-sdk";
+import { creatableProvider as creatableProvider12 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/datalake/JsonRpcDataLakeViewerMethods.ts
 import { DataLakeViewerMoniker as DataLakeViewerMoniker2 } from "@xyo-network/xl1-protocol";
@@ -269,7 +269,7 @@ var AccountBalanceViewerRpcSchemas = {
 
 // src/types/schema/BlockViewerRpcSchemas.ts
 import { HashZod } from "@xylabs/sdk-js";
-import { PayloadZodLoose } from "@xyo-network/sdk-js";
+import { PayloadZodLoose, WithHashMetaZod } from "@xyo-network/sdk-js";
 import { SignedHydratedBlockWithHashMetaZod, XL1BlockNumberZod } from "@xyo-network/xl1-protocol";
 import { z as z2 } from "zod";
 var BlockViewerRpcSchemas = {
@@ -309,8 +309,8 @@ var BlockViewerRpcSchemas = {
       from: z2.tuple([z2.array(HashZod)])
     },
     result: {
-      to: z2.array(PayloadZodLoose),
-      from: z2.array(PayloadZodLoose)
+      to: z2.array(WithHashMetaZod(PayloadZodLoose)),
+      from: z2.array(WithHashMetaZod(PayloadZodLoose))
     }
   }
 };
@@ -948,55 +948,102 @@ var TimeSyncViewerRpcSchemas = {
   }
 };
 
+// src/types/schema/TransactionViewerRpcSchema.ts
+import { HashZod as HashZod4 } from "@xylabs/sdk-js";
+import { SignedHydratedTransactionZod as SignedHydratedTransactionZod2 } from "@xyo-network/xl1-protocol";
+import { z as z16 } from "zod";
+var TransactionViewerRpcSchemas = {
+  transactionViewer_transactionByBlockHashAndIndex: {
+    params: {
+      to: z16.tuple([HashZod4, z16.number()]),
+      from: z16.tuple([HashZod4, z16.number()])
+    },
+    result: {
+      to: SignedHydratedTransactionZod2.nullable(),
+      from: SignedHydratedTransactionZod2.nullable()
+    }
+  },
+  transactionViewer_transactionByBlockNumberAndIndex: {
+    params: {
+      to: z16.tuple([z16.number(), z16.number()]),
+      from: z16.tuple([z16.number(), z16.number()])
+    },
+    result: {
+      to: SignedHydratedTransactionZod2.nullable(),
+      from: SignedHydratedTransactionZod2.nullable()
+    }
+  },
+  transactionViewer_byHash: {
+    params: {
+      to: z16.tuple([HashZod4]),
+      from: z16.tuple([HashZod4])
+    },
+    result: {
+      to: SignedHydratedTransactionZod2.nullable(),
+      from: SignedHydratedTransactionZod2.nullable()
+    }
+  },
+  transactionViewer_transactionByHash: {
+    params: {
+      to: z16.tuple([HashZod4]),
+      from: z16.tuple([HashZod4])
+    },
+    result: {
+      to: SignedHydratedTransactionZod2.nullable(),
+      from: SignedHydratedTransactionZod2.nullable()
+    }
+  }
+};
+
 // src/types/schema/XyoPermissionsRpcSchemas.ts
 import {
   InvokerPermissionZod,
   PermissionRequestZod,
   RequestedPermissionZod
 } from "@xyo-network/xl1-protocol";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var XyoPermissionsRpcSchemas = {
   xyoPermissions_getPermissions: {
     params: {
-      to: z16.array(z16.any()).length(0),
-      from: z16.array(z16.any()).length(0)
+      to: z17.array(z17.any()).length(0),
+      from: z17.array(z17.any()).length(0)
     },
     result: {
-      to: z16.array(InvokerPermissionZod),
-      from: z16.array(InvokerPermissionZod)
+      to: z17.array(InvokerPermissionZod),
+      from: z17.array(InvokerPermissionZod)
     }
   },
   xyoPermissions_requestPermissions: {
     params: {
-      to: z16.tuple([z16.array(PermissionRequestZod)]),
-      from: z16.tuple([z16.array(PermissionRequestZod)])
+      to: z17.tuple([z17.array(PermissionRequestZod)]),
+      from: z17.tuple([z17.array(PermissionRequestZod)])
     },
     result: {
-      to: z16.array(RequestedPermissionZod),
-      from: z16.array(RequestedPermissionZod)
+      to: z17.array(RequestedPermissionZod),
+      from: z17.array(RequestedPermissionZod)
     }
   },
   xyoPermissions_revokePermissions: {
     params: {
-      to: z16.tuple([z16.array(PermissionRequestZod)]),
-      from: z16.tuple([z16.array(PermissionRequestZod)])
+      to: z17.tuple([z17.array(PermissionRequestZod)]),
+      from: z17.tuple([z17.array(PermissionRequestZod)])
     },
     result: {
-      to: z16.array(RequestedPermissionZod),
-      from: z16.array(RequestedPermissionZod)
+      to: z17.array(RequestedPermissionZod),
+      from: z17.array(RequestedPermissionZod)
     }
   }
 };
 
 // src/types/schema/XyoRunnerRpcSchemas.ts
 import { HashToJsonZod, JsonToHashZod } from "@xylabs/sdk-js";
-import { SignedHydratedTransactionZod as SignedHydratedTransactionZod2 } from "@xyo-network/xl1-protocol";
-import { z as z17 } from "zod";
+import { SignedHydratedTransactionZod as SignedHydratedTransactionZod3 } from "@xyo-network/xl1-protocol";
+import { z as z18 } from "zod";
 var XyoRunnerRpcSchemas = {
   xyoRunner_broadcastTransaction: {
     params: {
-      to: z17.tuple([SignedHydratedTransactionZod2]),
-      from: z17.tuple([SignedHydratedTransactionZod2])
+      to: z18.tuple([SignedHydratedTransactionZod3]),
+      from: z18.tuple([SignedHydratedTransactionZod3])
     },
     result: {
       to: HashToJsonZod,
@@ -1008,12 +1055,12 @@ var XyoRunnerRpcSchemas = {
 // src/types/schema/XyoSignerRpcSchemas.ts
 import { AddressZod as AddressZod6 } from "@xylabs/sdk-js";
 import { SignedHydratedTransactionWithHashMetaZod as SignedHydratedTransactionWithHashMetaZod2, UnsignedHydratedTransactionZod } from "@xyo-network/xl1-protocol";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var XyoSignerRpcSchemas = {
   xyoSigner_address: {
     params: {
-      to: z18.array(z18.any()).length(0).optional(),
-      from: z18.array(z18.any()).length(0).optional()
+      to: z19.array(z19.any()).length(0).optional(),
+      from: z19.array(z19.any()).length(0).optional()
     },
     result: {
       to: AddressZod6,
@@ -1022,8 +1069,8 @@ var XyoSignerRpcSchemas = {
   },
   xyoSigner_signTransaction: {
     params: {
-      to: z18.tuple([UnsignedHydratedTransactionZod]),
-      from: z18.tuple([UnsignedHydratedTransactionZod])
+      to: z19.tuple([UnsignedHydratedTransactionZod]),
+      from: z19.tuple([UnsignedHydratedTransactionZod])
     },
     result: {
       to: SignedHydratedTransactionWithHashMetaZod2,
@@ -1036,7 +1083,7 @@ var XyoSignerRpcSchemas = {
 import {
   AddressZod as AddressZod7,
   BigIntToJsonZod as BigIntToJsonZod9,
-  HashZod as HashZod4,
+  HashZod as HashZod5,
   HexZod,
   JsonToBigIntZod as JsonToBigIntZod9
 } from "@xylabs/sdk-js";
@@ -1046,18 +1093,18 @@ import {
   asAttoXL1 as asAttoXL16,
   JsonToStakeZod as JsonToStakeZod3,
   SignedHydratedBlockWithHashMetaZod as SignedHydratedBlockWithHashMetaZod3,
-  SignedHydratedTransactionZod as SignedHydratedTransactionZod3,
+  SignedHydratedTransactionZod as SignedHydratedTransactionZod4,
   StakeToJsonZod as StakeToJsonZod3,
   StepIdentityZod as StepIdentityZod2,
   XL1BlockNumberZod as XL1BlockNumberZod2,
   XL1BlockRangeZod
 } from "@xyo-network/xl1-protocol";
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var XyoViewerRpcSchemas = {
   xyoViewer_networkStakeStepRewardClaimedByAddress: {
     params: {
-      to: z19.tuple([AddressZod7]),
-      from: z19.tuple([AddressZod7])
+      to: z20.tuple([AddressZod7]),
+      from: z20.tuple([AddressZod7])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1066,38 +1113,38 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardAddressReward: {
     params: {
-      to: z19.tuple([StepIdentityZod2, AddressZod7]),
-      from: z19.tuple([StepIdentityZod2, AddressZod7])
+      to: z20.tuple([StepIdentityZod2, AddressZod7]),
+      from: z20.tuple([StepIdentityZod2, AddressZod7])
     },
     result: {
-      to: z19.record(AddressZod7, BigIntToJsonZod9),
-      from: z19.record(AddressZod7, JsonToBigIntZod9.transform((val) => asAttoXL16(val)))
+      to: z20.record(AddressZod7, BigIntToJsonZod9),
+      from: z20.record(AddressZod7, JsonToBigIntZod9.transform((val) => asAttoXL16(val)))
     }
   },
   xyoViewer_networkStakeStepRewardAddressHistory: {
     params: {
-      to: z19.tuple([AddressZod7]),
-      from: z19.tuple([AddressZod7])
+      to: z20.tuple([AddressZod7]),
+      from: z20.tuple([AddressZod7])
     },
     result: {
-      to: z19.record(AddressZod7, BigIntToJsonZod9),
-      from: z19.record(AddressZod7, JsonToBigIntZod9.transform((val) => asAttoXL16(val)))
+      to: z20.record(AddressZod7, BigIntToJsonZod9),
+      from: z20.record(AddressZod7, JsonToBigIntZod9.transform((val) => asAttoXL16(val)))
     }
   },
   xyoViewer_networkStakeStepRewardAddressShare: {
     params: {
-      to: z19.tuple([StepIdentityZod2, AddressZod7]),
-      from: z19.tuple([StepIdentityZod2, AddressZod7])
+      to: z20.tuple([StepIdentityZod2, AddressZod7]),
+      from: z20.tuple([StepIdentityZod2, AddressZod7])
     },
     result: {
-      to: z19.tuple([BigIntToJsonZod9, BigIntToJsonZod9]),
-      from: z19.tuple([JsonToBigIntZod9, JsonToBigIntZod9])
+      to: z20.tuple([BigIntToJsonZod9, BigIntToJsonZod9]),
+      from: z20.tuple([JsonToBigIntZod9, JsonToBigIntZod9])
     }
   },
   xyoViewer_networkStakeStepRewardWeightForAddress: {
     params: {
-      to: z19.tuple([StepIdentityZod2, AddressZod7]),
-      from: z19.tuple([StepIdentityZod2, AddressZod7])
+      to: z20.tuple([StepIdentityZod2, AddressZod7]),
+      from: z20.tuple([StepIdentityZod2, AddressZod7])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1106,8 +1153,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardUnclaimedByAddress: {
     params: {
-      to: z19.tuple([AddressZod7]),
-      from: z19.tuple([AddressZod7])
+      to: z20.tuple([AddressZod7]),
+      from: z20.tuple([AddressZod7])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1116,18 +1163,18 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardPoolRewards: {
     params: {
-      to: z19.tuple([StepIdentityZod2]),
-      from: z19.tuple([StepIdentityZod2])
+      to: z20.tuple([StepIdentityZod2]),
+      from: z20.tuple([StepIdentityZod2])
     },
     result: {
-      to: z19.record(AddressZod7, BigIntToJsonZod9),
-      from: z19.record(AddressZod7, JsonToBigIntZod9.transform((val) => asAttoXL16(val)))
+      to: z20.record(AddressZod7, BigIntToJsonZod9),
+      from: z20.record(AddressZod7, JsonToBigIntZod9.transform((val) => asAttoXL16(val)))
     }
   },
   xyoViewer_networkStakeStepRewardPositionWeight: {
     params: {
-      to: z19.tuple([StepIdentityZod2, z19.number()]),
-      from: z19.tuple([StepIdentityZod2, z19.number()])
+      to: z20.tuple([StepIdentityZod2, z20.number()]),
+      from: z20.tuple([StepIdentityZod2, z20.number()])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1136,8 +1183,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardPotentialPositionLoss: {
     params: {
-      to: z19.tuple([StepIdentityZod2, z19.number()]),
-      from: z19.tuple([StepIdentityZod2, z19.number()])
+      to: z20.tuple([StepIdentityZod2, z20.number()]),
+      from: z20.tuple([StepIdentityZod2, z20.number()])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1146,8 +1193,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardForStep: {
     params: {
-      to: z19.tuple([StepIdentityZod2]),
-      from: z19.tuple([StepIdentityZod2])
+      to: z20.tuple([StepIdentityZod2]),
+      from: z20.tuple([StepIdentityZod2])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1156,8 +1203,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardRandomizer: {
     params: {
-      to: z19.tuple([StepIdentityZod2]),
-      from: z19.tuple([StepIdentityZod2])
+      to: z20.tuple([StepIdentityZod2]),
+      from: z20.tuple([StepIdentityZod2])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1166,48 +1213,48 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardStakerCount: {
     params: {
-      to: z19.tuple([StepIdentityZod2]),
-      from: z19.tuple([StepIdentityZod2])
+      to: z20.tuple([StepIdentityZod2]),
+      from: z20.tuple([StepIdentityZod2])
     },
     result: {
-      to: z19.number(),
-      from: z19.number()
+      to: z20.number(),
+      from: z20.number()
     }
   },
   xyoViewer_networkStakeStepRewardPoolShares: {
     params: {
-      to: z19.tuple([StepIdentityZod2]),
-      from: z19.tuple([StepIdentityZod2])
+      to: z20.tuple([StepIdentityZod2]),
+      from: z20.tuple([StepIdentityZod2])
     },
     result: {
-      to: z19.record(AddressZod7, BigIntToJsonZod9),
-      from: z19.record(AddressZod7, JsonToBigIntZod9)
+      to: z20.record(AddressZod7, BigIntToJsonZod9),
+      from: z20.record(AddressZod7, JsonToBigIntZod9)
     }
   },
   xyoViewer_networkStakeStepRewardForStepForPosition: {
     params: {
-      to: z19.tuple([StepIdentityZod2, z19.number()]),
-      from: z19.tuple([StepIdentityZod2, z19.number()])
+      to: z20.tuple([StepIdentityZod2, z20.number()]),
+      from: z20.tuple([StepIdentityZod2, z20.number()])
     },
     result: {
-      to: z19.tuple([BigIntToJsonZod9, BigIntToJsonZod9]),
-      from: z19.tuple([JsonToBigIntZod9.transform((val) => asAttoXL16(val)), JsonToBigIntZod9.transform((val) => asAttoXL16(val))])
+      to: z20.tuple([BigIntToJsonZod9, BigIntToJsonZod9]),
+      from: z20.tuple([JsonToBigIntZod9.transform((val) => asAttoXL16(val)), JsonToBigIntZod9.transform((val) => asAttoXL16(val))])
     }
   },
   xyoViewer_networkStakeStepRewardForPosition: {
     params: {
-      to: z19.tuple([z19.number(), z19.tuple([z19.number(), z19.number()])]),
-      from: z19.tuple([z19.number(), z19.tuple([z19.number(), z19.number()])])
+      to: z20.tuple([z20.number(), z20.tuple([z20.number(), z20.number()])]),
+      from: z20.tuple([z20.number(), z20.tuple([z20.number(), z20.number()])])
     },
     result: {
-      to: z19.tuple([BigIntToJsonZod9, BigIntToJsonZod9]),
-      from: z19.tuple([JsonToBigIntZod9.transform((val) => asAttoXL16(val)), JsonToBigIntZod9.transform((val) => asAttoXL16(val))])
+      to: z20.tuple([BigIntToJsonZod9, BigIntToJsonZod9]),
+      from: z20.tuple([JsonToBigIntZod9.transform((val) => asAttoXL16(val)), JsonToBigIntZod9.transform((val) => asAttoXL16(val))])
     }
   },
   xyoViewer_networkStakeStepRewardsForRange: {
     params: {
-      to: z19.tuple([z19.tuple([z19.number(), z19.number()])]),
-      from: z19.tuple([z19.tuple([z19.number(), z19.number()])])
+      to: z20.tuple([z20.tuple([z20.number(), z20.number()])]),
+      from: z20.tuple([z20.tuple([z20.number(), z20.number()])])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1216,8 +1263,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardsForStepLevel: {
     params: {
-      to: z19.tuple([z19.number(), z19.tuple([z19.number(), z19.number()])]),
-      from: z19.tuple([z19.number(), z19.tuple([z19.number(), z19.number()])])
+      to: z20.tuple([z20.number(), z20.tuple([z20.number(), z20.number()])]),
+      from: z20.tuple([z20.number(), z20.tuple([z20.number(), z20.number()])])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1226,18 +1273,18 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_networkStakeStepRewardsForPosition: {
     params: {
-      to: z19.tuple([z19.number(), z19.tuple([z19.number(), z19.number()])]),
-      from: z19.tuple([z19.number(), z19.tuple([z19.number(), z19.number()])])
+      to: z20.tuple([z20.number(), z20.tuple([z20.number(), z20.number()])]),
+      from: z20.tuple([z20.number(), z20.tuple([z20.number(), z20.number()])])
     },
     result: {
-      to: z19.record(z19.string(), z19.tuple([BigIntToJsonZod9, BigIntToJsonZod9])),
-      from: z19.record(z19.string(), z19.tuple([JsonToBigIntZod9.transform((val) => asAttoXL16(val)), JsonToBigIntZod9.transform((val) => asAttoXL16(val))]))
+      to: z20.record(z20.string(), z20.tuple([BigIntToJsonZod9, BigIntToJsonZod9])),
+      from: z20.record(z20.string(), z20.tuple([JsonToBigIntZod9.transform((val) => asAttoXL16(val)), JsonToBigIntZod9.transform((val) => asAttoXL16(val))]))
     }
   },
   xyoViewer_accountBalance: {
     params: {
-      to: z19.union([z19.tuple([AddressZod7]), z19.tuple([AddressZod7, z19.union([XL1BlockRangeZod, HashZod4])])]),
-      from: z19.union([z19.tuple([AddressZod7]), z19.tuple([AddressZod7, z19.union([XL1BlockRangeZod, HashZod4])])])
+      to: z20.union([z20.tuple([AddressZod7]), z20.tuple([AddressZod7, z20.union([XL1BlockRangeZod, HashZod5])])]),
+      from: z20.union([z20.tuple([AddressZod7]), z20.tuple([AddressZod7, z20.union([XL1BlockRangeZod, HashZod5])])])
     },
     result: {
       to: BigIntToJsonZod9,
@@ -1246,38 +1293,38 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_accountBalanceHistory: {
     params: {
-      to: z19.union([z19.tuple([AddressZod7]), z19.tuple([AddressZod7, z19.union([XL1BlockRangeZod, HashZod4])])]),
-      from: z19.union([z19.tuple([AddressZod7]), z19.tuple([AddressZod7, z19.union([XL1BlockRangeZod, HashZod4])])])
+      to: z20.union([z20.tuple([AddressZod7]), z20.tuple([AddressZod7, z20.union([XL1BlockRangeZod, HashZod5])])]),
+      from: z20.union([z20.tuple([AddressZod7]), z20.tuple([AddressZod7, z20.union([XL1BlockRangeZod, HashZod5])])])
     },
     result: {
-      to: z19.array(AccountBalanceHistoryItemZod2),
-      from: z19.array(AccountBalanceHistoryItemZod2)
+      to: z20.array(AccountBalanceHistoryItemZod2),
+      from: z20.array(AccountBalanceHistoryItemZod2)
     }
   },
   xyoViewer_blocksByNumber: {
     params: {
-      to: z19.tuple([XL1BlockNumberZod2, z19.number().optional()]),
-      from: z19.tuple([XL1BlockNumberZod2, z19.number().optional()])
+      to: z20.tuple([XL1BlockNumberZod2, z20.number().optional()]),
+      from: z20.tuple([XL1BlockNumberZod2, z20.number().optional()])
     },
     result: {
-      to: z19.array(SignedHydratedBlockWithHashMetaZod3),
-      from: z19.array(SignedHydratedBlockWithHashMetaZod3)
+      to: z20.array(SignedHydratedBlockWithHashMetaZod3),
+      from: z20.array(SignedHydratedBlockWithHashMetaZod3)
     }
   },
   xyoViewer_blocksByHash: {
     params: {
-      to: z19.tuple([HashZod4, z19.number().optional()]),
-      from: z19.tuple([HashZod4, z19.number().optional()])
+      to: z20.tuple([HashZod5, z20.number().optional()]),
+      from: z20.tuple([HashZod5, z20.number().optional()])
     },
     result: {
-      to: z19.array(SignedHydratedBlockWithHashMetaZod3),
-      from: z19.array(SignedHydratedBlockWithHashMetaZod3)
+      to: z20.array(SignedHydratedBlockWithHashMetaZod3),
+      from: z20.array(SignedHydratedBlockWithHashMetaZod3)
     }
   },
   xyoViewer_currentBlock: {
     params: {
-      to: z19.array(z19.any()).length(0).optional(),
-      from: z19.array(z19.any()).length(0).optional()
+      to: z20.array(z20.any()).length(0).optional(),
+      from: z20.array(z20.any()).length(0).optional()
     },
     result: {
       to: SignedHydratedBlockWithHashMetaZod3,
@@ -1286,18 +1333,18 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_forkHistory: {
     params: {
-      to: z19.array(z19.any()).length(0).optional(),
-      from: z19.array(z19.any()).length(0).optional()
+      to: z20.array(z20.any()).length(0).optional(),
+      from: z20.array(z20.any()).length(0).optional()
     },
     result: {
-      to: z19.record(z19.number(), HexZod),
-      from: z19.record(z19.number(), HexZod)
+      to: z20.record(z20.number(), HexZod),
+      from: z20.record(z20.number(), HexZod)
     }
   },
   xyoViewer_stakeByStaker: {
     params: {
-      to: z19.tuple([AddressZod7, z19.number()]),
-      from: z19.tuple([AddressZod7, z19.number()])
+      to: z20.tuple([AddressZod7, z20.number()]),
+      from: z20.tuple([AddressZod7, z20.number()])
     },
     result: {
       to: StakeToJsonZod3,
@@ -1306,8 +1353,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakeById: {
     params: {
-      to: z19.tuple([z19.number()]),
-      from: z19.tuple([z19.number()])
+      to: z20.tuple([z20.number()]),
+      from: z20.tuple([z20.number()])
     },
     result: {
       to: StakeToJsonZod3,
@@ -1316,62 +1363,62 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakesByStaker: {
     params: {
-      to: z19.tuple([AddressZod7]),
-      from: z19.tuple([AddressZod7])
+      to: z20.tuple([AddressZod7]),
+      from: z20.tuple([AddressZod7])
     },
     result: {
-      to: z19.array(StakeToJsonZod3),
-      from: z19.array(JsonToStakeZod3)
+      to: z20.array(StakeToJsonZod3),
+      from: z20.array(JsonToStakeZod3)
     }
   },
   xyoViewer_stakesByStaked: {
     params: {
-      to: z19.tuple([AddressZod7]),
-      from: z19.tuple([AddressZod7])
+      to: z20.tuple([AddressZod7]),
+      from: z20.tuple([AddressZod7])
     },
     result: {
-      to: z19.array(StakeToJsonZod3),
-      from: z19.array(JsonToStakeZod3)
+      to: z20.array(StakeToJsonZod3),
+      from: z20.array(JsonToStakeZod3)
     }
   },
   xyoViewer_transactionByBlockHashAndIndex: {
     params: {
-      to: z19.tuple([HashZod4, z19.number()]),
-      from: z19.tuple([HashZod4, z19.number()])
+      to: z20.tuple([HashZod5, z20.number()]),
+      from: z20.tuple([HashZod5, z20.number()])
     },
     result: {
-      to: SignedHydratedTransactionZod3.nullable(),
-      from: SignedHydratedTransactionZod3.nullable()
+      to: SignedHydratedTransactionZod4.nullable(),
+      from: SignedHydratedTransactionZod4.nullable()
     }
   },
   xyoViewer_transactionByBlockNumberAndIndex: {
     params: {
-      to: z19.tuple([z19.number(), z19.number()]),
-      from: z19.tuple([z19.number(), z19.number()])
+      to: z20.tuple([z20.number(), z20.number()]),
+      from: z20.tuple([z20.number(), z20.number()])
     },
     result: {
-      to: SignedHydratedTransactionZod3.nullable(),
-      from: SignedHydratedTransactionZod3.nullable()
+      to: SignedHydratedTransactionZod4.nullable(),
+      from: SignedHydratedTransactionZod4.nullable()
     }
   },
   xyoViewer_transactionByHash: {
     params: {
-      to: z19.tuple([HashZod4]),
-      from: z19.tuple([HashZod4])
+      to: z20.tuple([HashZod5]),
+      from: z20.tuple([HashZod5])
     },
     result: {
-      to: SignedHydratedTransactionZod3.nullable(),
-      from: SignedHydratedTransactionZod3.nullable()
+      to: SignedHydratedTransactionZod4.nullable(),
+      from: SignedHydratedTransactionZod4.nullable()
     }
   },
   xyoViewer_payloadsByHash: {
     params: {
-      to: z19.tuple([z19.array(HashZod4)]),
-      from: z19.tuple([z19.array(HashZod4)])
+      to: z20.tuple([z20.array(HashZod5)]),
+      from: z20.tuple([z20.array(HashZod5)])
     },
     result: {
-      to: z19.array(PayloadZodLoose2),
-      from: z19.array(PayloadZodLoose2)
+      to: z20.array(PayloadZodLoose2),
+      from: z20.array(PayloadZodLoose2)
     }
   }
 };
@@ -1396,34 +1443,35 @@ var AllRpcSchemas = {
   ...NetworkStakingStepRewardsTotalViewerRpcSchemas,
   ...NetworkStakingStepRewardsByStepViewerRpcSchemas,
   ...NetworkStakingStepRewardsByStakerViewerRpcSchemas,
-  ...NetworkStakingStepRewardsByPositionViewerRpcSchemas
+  ...NetworkStakingStepRewardsByPositionViewerRpcSchemas,
+  ...TransactionViewerRpcSchemas
 };
 
 // src/types/schema/createRequestSchema.ts
-import { z as z20 } from "zod";
-var createRequestSchema = (methodName, paramsSchema = z20.undefined()) => z20.object({
-  id: z20.union([z20.string(), z20.number()]),
-  jsonrpc: z20.literal(jsonrpc),
-  method: z20.literal(methodName),
+import { z as z21 } from "zod";
+var createRequestSchema = (methodName, paramsSchema = z21.undefined()) => z21.object({
+  id: z21.union([z21.string(), z21.number()]),
+  jsonrpc: z21.literal(jsonrpc),
+  method: z21.literal(methodName),
   params: paramsSchema
 });
 
 // src/types/schema/createResponseSchema.ts
-import { z as z21 } from "zod";
-var createResponseSchema = (resultSchema = z21.undefined()) => z21.object({
-  id: z21.union([z21.string(), z21.number()]),
-  jsonrpc: z21.literal(jsonrpc),
+import { z as z22 } from "zod";
+var createResponseSchema = (resultSchema = z22.undefined()) => z22.object({
+  id: z22.union([z22.string(), z22.number()]),
+  jsonrpc: z22.literal(jsonrpc),
   result: resultSchema
 });
 
 // src/types/schema/FinalizationViewerRpcSchemas.ts
 import { SignedHydratedBlockWithHashMetaZod as SignedHydratedBlockWithHashMetaZod4 } from "@xyo-network/xl1-protocol";
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var FinalizationViewerRpcSchemas = {
   finalizationViewer_head: {
     params: {
-      to: z22.array(z22.any()).length(0).optional(),
-      from: z22.array(z22.any()).length(0).optional()
+      to: z23.array(z23.any()).length(0).optional(),
+      from: z23.array(z23.any()).length(0).optional()
     },
     result: {
       to: SignedHydratedBlockWithHashMetaZod4,
@@ -1446,15 +1494,15 @@ import { isDefined as isDefined2 } from "@xylabs/sdk-js";
 import { AbstractCreatableProvider } from "@xyo-network/xl1-protocol-sdk";
 
 // src/transport/HttpRpcTransport.ts
-import { axiosJsonConfig } from "@xylabs/axios";
 import {
+  axiosJsonConfig,
   isDefined,
   isError,
   isUndefinedOrNull
 } from "@xylabs/sdk-js";
 import { Axios, isAxiosError } from "axios";
 import { v4 } from "uuid";
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var HttpRpcTransport = class {
   _passThrough;
   _rpcUrl;
@@ -1477,7 +1525,7 @@ var HttpRpcTransport = class {
       };
       const schema = schemas[method];
       if (params) {
-        body.params = isDefined(schema) ? schema.params.to.parse(params) : this._passThrough ? z23.json().parse(params) : void 0;
+        body.params = isDefined(schema) ? schema.params.to.parse(params) : this._passThrough ? z24.json().parse(params) : void 0;
         if (!isDefined(body.params)) {
           throw new Error(`[callRpc] RPC method ${String(method)} missing schema`);
         }
@@ -1618,17 +1666,8 @@ import {
 
 // src/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewerMethods.ts
 import { isDefined as isDefined3 } from "@xylabs/sdk-js";
-import {
-  asAnyPayload,
-  asHashMeta,
-  isAnyPayload
-} from "@xyo-network/sdk-js";
-import { PayloadBuilder } from "@xyo-network/sdk-js";
-import {
-  asSignedHydratedBlockWithHashMeta,
-  BlockViewerMoniker,
-  DataLakeViewerMoniker
-} from "@xyo-network/xl1-protocol";
+import { BlockViewerMoniker, DataLakeViewerMoniker } from "@xyo-network/xl1-protocol";
+import { addDataLakePayloads, addDataLakePayloadsToPayloads } from "@xyo-network/xl1-protocol-sdk";
 var JsonRpcBlockViewerMethods = class extends AbstractJsonRpcViewer {
   moniker = BlockViewerMoniker;
   dataLakeViewer;
@@ -1637,14 +1676,14 @@ var JsonRpcBlockViewerMethods = class extends AbstractJsonRpcViewer {
       "blockViewer_blocksByHash",
       isDefined3(limit) ? [hash, limit] : [hash]
     );
-    return await Promise.all(result.map(async (block) => await this.addDataLakePayloadsToBlock(block)));
+    return await Promise.all(result.map(async (block) => (await addDataLakePayloads(block, this.dataLakeViewer))[0]));
   }
   async blocksByNumber(block, limit) {
     const result = await this.transport.sendRequest(
       "blockViewer_blocksByNumber",
       isDefined3(limit) ? [block, limit] : [block]
     );
-    return await Promise.all(result.map(async (block2) => await this.addDataLakePayloadsToBlock(block2)));
+    return await Promise.all(result.map(async (block2) => (await addDataLakePayloads(block2, this.dataLakeViewer))[0]));
   }
   async createHandler() {
     await super.createHandler();
@@ -1655,30 +1694,14 @@ var JsonRpcBlockViewerMethods = class extends AbstractJsonRpcViewer {
       "blockViewer_currentBlock",
       []
     );
-    return await this.addDataLakePayloadsToBlock(result);
+    return (await addDataLakePayloads(result, this.dataLakeViewer))[0];
   }
   async payloadsByHash(hashes) {
     const result = await this.transport.sendRequest(
       "blockViewer_payloadsByHash",
       [hashes]
     );
-    return await this.addDataLakePayloadsToPayloads(hashes, result.map((p) => asHashMeta(p, true)).map((p) => asAnyPayload(p, { required: true })));
-  }
-  async addDataLakePayloadsToBlock(block) {
-    const dataLakeViewer = this.dataLakeViewer;
-    if (!dataLakeViewer) return block;
-    const missingPayloadHashes = block[0].payload_hashes.filter((hash) => !block[1].some((p) => p._hash === hash));
-    const payloadsFromDataLake = await PayloadBuilder.addHashMeta((await dataLakeViewer.get(missingPayloadHashes)).filter(isAnyPayload));
-    return asSignedHydratedBlockWithHashMeta([block[0], [...block[1], ...payloadsFromDataLake]], true);
-  }
-  async addDataLakePayloadsToPayloads(hashes, payloads) {
-    const dataLakeViewer = this.dataLakeViewer;
-    if (!dataLakeViewer) return payloads;
-    const missingPayloadHashes = hashes.filter((hash) => !payloads.some((p) => p._hash === hash));
-    const payloadsFromDataLake = await PayloadBuilder.addHashMeta(
-      await PayloadBuilder.addHashMeta((await dataLakeViewer.get(missingPayloadHashes)).filter(isAnyPayload))
-    );
-    return [...payloads, ...payloadsFromDataLake];
+    return (await addDataLakePayloadsToPayloads(hashes, result, this.dataLakeViewer))[0];
   }
   schemas() {
     return BlockViewerRpcSchemas;
@@ -2021,26 +2044,103 @@ JsonRpcTimeSyncViewer = __decorateClass([
   creatableProvider9()
 ], JsonRpcTimeSyncViewer);
 
+// src/provider/viewer/JsonRpcTransactionViewer/JsonRpcTransactionViewer.ts
+import {
+  assertEx as assertEx2,
+  exists
+} from "@xylabs/sdk-js";
+import { BoundWitnessSchema } from "@xyo-network/sdk-js";
+import {
+  BlockViewerMoniker as BlockViewerMoniker3,
+  isTransactionBoundWitnessWithHashMeta,
+  TransactionViewerMoniker
+} from "@xyo-network/xl1-protocol";
+import { creatableProvider as creatableProvider10 } from "@xyo-network/xl1-protocol-sdk";
+var JsonRpcTransactionViewer = class extends AbstractJsonRpcViewer {
+  moniker = JsonRpcTransactionViewer.defaultMoniker;
+  _blockViewer;
+  get blockViewer() {
+    return this._blockViewer;
+  }
+  async byBlockHashAndIndex(blockHash, transactionIndex) {
+    return await this.spanAsync("transactionByBlockHashAndIndex", async () => {
+      assertEx2(transactionIndex >= 0, () => "transactionIndex must be greater than or equal to 0");
+      try {
+        const block = await this.blockViewer.blockByHash(blockHash);
+        if (!block) return null;
+        const blockBoundWitnessIndexes = block[0].payload_schemas.map((schema, index) => schema === BoundWitnessSchema ? index : void 0).filter(exists);
+        const blockBoundWitnessHashes = new Set(blockBoundWitnessIndexes.map((index) => block[0].payload_hashes[index]));
+        const blockBoundWitnesses = block[1].filter((payload) => blockBoundWitnessHashes.has(payload._hash) || blockBoundWitnessHashes.has(payload._dataHash));
+        const blockTransactionBoundWitnesses = blockBoundWitnesses.filter(isTransactionBoundWitnessWithHashMeta);
+        const transaction = blockTransactionBoundWitnesses.at(transactionIndex);
+        if (!transaction) return null;
+        return await this.transactionByHash(transaction._hash);
+      } catch {
+        return null;
+      }
+    }, this.context);
+  }
+  async byBlockNumberAndIndex(blockNumber, transactionIndex) {
+    return await this.spanAsync("transactionByBlockNumberAndIndex", async () => {
+      try {
+        const block = await this.blockViewer.blockByNumber(blockNumber);
+        if (!block) return null;
+        return await this.transactionByBlockHashAndIndex(block[0]._hash, transactionIndex);
+      } catch {
+        return null;
+      }
+    }, this.context);
+  }
+  async byHash(transactionHash) {
+    return await this.transport.sendRequest("transactionViewer_byHash", [transactionHash]);
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker3);
+  }
+  async transactionByBlockHashAndIndex(blockHash, transactionIndex) {
+    return await this.transport.sendRequest("transactionViewer_transactionByBlockHashAndIndex", [blockHash, transactionIndex]);
+  }
+  async transactionByBlockNumberAndIndex(blockNumber, transactionIndex) {
+    return await this.transport.sendRequest("transactionViewer_transactionByBlockNumberAndIndex", [blockNumber, transactionIndex]);
+  }
+  async transactionByHash(transactionHash) {
+    return await this.transport.sendRequest("transactionViewer_transactionByHash", [transactionHash]);
+  }
+  schemas() {
+    return TransactionViewerRpcSchemas;
+  }
+};
+__publicField(JsonRpcTransactionViewer, "defaultMoniker", TransactionViewerMoniker);
+__publicField(JsonRpcTransactionViewer, "dependencies", [
+  BlockViewerMoniker3
+]);
+__publicField(JsonRpcTransactionViewer, "monikers", [TransactionViewerMoniker]);
+JsonRpcTransactionViewer = __decorateClass([
+  creatableProvider10()
+], JsonRpcTransactionViewer);
+
 // src/provider/viewer/JsonRpcXyoViewer.ts
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
+import { PayloadBuilder } from "@xyo-network/sdk-js";
 import {
   AccountBalanceViewerMoniker as AccountBalanceViewerMoniker3,
-  BlockViewerMoniker as BlockViewerMoniker3,
+  BlockViewerMoniker as BlockViewerMoniker4,
   isSignedHydratedBlock,
   isSignedHydratedBlockWithHashMeta,
   MempoolViewerMoniker as MempoolViewerMoniker3,
   NetworkStakeViewerMoniker as NetworkStakeViewerMoniker3,
   StepViewerMoniker,
   TimeSyncViewerMoniker as TimeSyncViewerMoniker3,
+  TransactionViewerMoniker as TransactionViewerMoniker2,
   XyoViewerMoniker
 } from "@xyo-network/xl1-protocol";
-import { creatableProvider as creatableProvider10 } from "@xyo-network/xl1-protocol-sdk";
+import { creatableProvider as creatableProvider11 } from "@xyo-network/xl1-protocol-sdk";
 async function fixSignedHydratedBlockWithHashMeta(block) {
   if (isSignedHydratedBlockWithHashMeta(block)) {
     return block;
   }
   if (isSignedHydratedBlock(block)) {
-    return [await PayloadBuilder2.addHashMeta(block[0]), await PayloadBuilder2.addHashMeta(block[1])];
+    return [await PayloadBuilder.addHashMeta(block[0]), await PayloadBuilder.addHashMeta(block[1])];
   }
   throw new Error("Invalid block format");
 }
@@ -2054,6 +2154,7 @@ var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
   _stakeViewer;
   _stepViewer;
   _timeSyncViewer;
+  _transactionViewer;
   get account() {
     return { balance: this._accountBalanceViewer };
   }
@@ -2075,6 +2176,9 @@ var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
   get time() {
     return this._timeSyncViewer;
   }
+  get transaction() {
+    return this._transactionViewer;
+  }
   async accountBalance(address, config = {}) {
     return await this.account.balance.accountBalance(address, config);
   }
@@ -2109,11 +2213,12 @@ var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
   async createHandler() {
     await super.createHandler();
     this._accountBalanceViewer = await this.locator.getInstance(AccountBalanceViewerMoniker3);
-    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker3);
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker4);
     this._mempoolViewer = await this.locator.getInstance(MempoolViewerMoniker3);
     this._stepViewer = await this.locator.getInstance(StepViewerMoniker);
     this._networkStakeViewer = await this.locator.getInstance(NetworkStakeViewerMoniker3);
     this._timeSyncViewer = await this.locator.getInstance(TimeSyncViewerMoniker3);
+    this._transactionViewer = await this.locator.getInstance(TransactionViewerMoniker2);
   }
   async currentBlock() {
     const result = await this.transport.sendRequest("xyoViewer_currentBlock");
@@ -2186,7 +2291,7 @@ var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
     return (await this.payloadsByHash([hash]))[0] ?? null;
   }
   async payloadsByHash(hashes) {
-    return await PayloadBuilder2.addHashMeta(await this.transport.sendRequest(
+    return await PayloadBuilder.addHashMeta(await this.transport.sendRequest(
       "xyoViewer_payloadsByHash",
       [hashes]
     ));
@@ -2228,14 +2333,14 @@ var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
 __publicField(JsonRpcXyoViewer, "defaultMoniker", XyoViewerMoniker);
 __publicField(JsonRpcXyoViewer, "dependencies", [
   AccountBalanceViewerMoniker3,
-  BlockViewerMoniker3,
+  BlockViewerMoniker4,
   MempoolViewerMoniker3,
   StepViewerMoniker,
   TimeSyncViewerMoniker3
 ]);
 __publicField(JsonRpcXyoViewer, "monikers", [XyoViewerMoniker]);
 JsonRpcXyoViewer = __decorateClass([
-  creatableProvider10()
+  creatableProvider11()
 ], JsonRpcXyoViewer);
 
 // src/provider/datalake/JsonRpcDataLakeViewerMethods.ts
@@ -2259,7 +2364,7 @@ var JsonRpcDataLakeViewer = class extends JsonRpcDataLakeViewerMethods {
 };
 __publicField(JsonRpcDataLakeViewer, "dependencies", []);
 JsonRpcDataLakeViewer = __decorateClass([
-  creatableProvider11()
+  creatableProvider12()
 ], JsonRpcDataLakeViewer);
 
 // src/provider/permissions/RpcXyoPermissions.ts
@@ -2284,7 +2389,7 @@ var RpcXyoPermissions = class {
 import {
   MempoolRunnerMoniker as MempoolRunnerMoniker2
 } from "@xyo-network/xl1-protocol";
-import { creatableProvider as creatableProvider12 } from "@xyo-network/xl1-protocol-sdk";
+import { creatableProvider as creatableProvider13 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts
 import { MempoolRunnerMoniker } from "@xyo-network/xl1-protocol";
@@ -2344,12 +2449,12 @@ __publicField(JsonRpcMempoolRunner, "defaultMoniker", MempoolRunnerMoniker2);
 __publicField(JsonRpcMempoolRunner, "dependencies", []);
 __publicField(JsonRpcMempoolRunner, "monikers", [MempoolRunnerMoniker2]);
 JsonRpcMempoolRunner = __decorateClass([
-  creatableProvider12()
+  creatableProvider13()
 ], JsonRpcMempoolRunner);
 
 // src/provider/runner/JsonRpcXyoRunner.ts
 import { MempoolRunnerMoniker as MempoolRunnerMoniker3, XyoRunnerMoniker } from "@xyo-network/xl1-protocol";
-import { creatableProvider as creatableProvider13 } from "@xyo-network/xl1-protocol-sdk";
+import { creatableProvider as creatableProvider14 } from "@xyo-network/xl1-protocol-sdk";
 var JsonRpcXyoRunner = class extends AbstractJsonRpcRunner {
   moniker = JsonRpcXyoRunner.defaultMoniker;
   _mempoolRunner;
@@ -2371,18 +2476,18 @@ __publicField(JsonRpcXyoRunner, "defaultMoniker", XyoRunnerMoniker);
 __publicField(JsonRpcXyoRunner, "dependencies", [MempoolRunnerMoniker3]);
 __publicField(JsonRpcXyoRunner, "monikers", [XyoRunnerMoniker]);
 JsonRpcXyoRunner = __decorateClass([
-  creatableProvider13()
+  creatableProvider14()
 ], JsonRpcXyoRunner);
 
 // src/provider/runner/NodeXyoRunner.ts
-import { assertEx as assertEx2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
 import { asArchivistInstance } from "@xyo-network/sdk-js";
 import {
   XyoRunnerMoniker as XyoRunnerMoniker2
 } from "@xyo-network/xl1-protocol";
 import {
   AbstractCreatableProvider as AbstractCreatableProvider3,
-  creatableProvider as creatableProvider14,
+  creatableProvider as creatableProvider15,
   SimpleMempoolRunner
 } from "@xyo-network/xl1-protocol-sdk";
 var NodeXyoRunner = class extends AbstractCreatableProvider3 {
@@ -2414,19 +2519,19 @@ var NodeXyoRunner = class extends AbstractCreatableProvider3 {
   }
   getArchivist = async (identifier) => {
     const archivist = await this.node.resolve(identifier);
-    return assertEx2(asArchivistInstance(archivist), () => `Could not resolve ${identifier} to an archivist instance`);
+    return assertEx3(asArchivistInstance(archivist), () => `Could not resolve ${identifier} to an archivist instance`);
   };
   async startHandler() {
     await super.startHandler();
-    this._pendingTransactionsArchivist = assertEx2(
+    this._pendingTransactionsArchivist = assertEx3(
       await this.getArchivist(this.pendingTransactionsArchivistPath),
       () => `Could not resolve pending archivist at ${this.pendingTransactionsArchivistPath}`
     );
-    this._pendingBlocksArchivist = assertEx2(
+    this._pendingBlocksArchivist = assertEx3(
       await this.getArchivist(this.pendingBlocksArchivistPath),
       () => `Could not resolve pending archivist at ${this.pendingBlocksArchivistPath}`
     );
-    this._mempoolRunner = assertEx2(await SimpleMempoolRunner.create({
+    this._mempoolRunner = assertEx3(await SimpleMempoolRunner.create({
       context: this.context,
       pendingTransactionsArchivist: this.pendingTransactionsArchivist,
       pendingBlocksArchivist: this.pendingBlocksArchivist
@@ -2437,7 +2542,7 @@ __publicField(NodeXyoRunner, "defaultMoniker", XyoRunnerMoniker2);
 __publicField(NodeXyoRunner, "dependencies", []);
 __publicField(NodeXyoRunner, "monikers", [XyoRunnerMoniker2]);
 NodeXyoRunner = __decorateClass([
-  creatableProvider14()
+  creatableProvider15()
 ], NodeXyoRunner);
 
 // src/provider/signer/JsonRpcXyoSigner.ts
@@ -2496,6 +2601,7 @@ export {
   JsonRpcStakeViewerMethods,
   JsonRpcTimeSyncViewer,
   JsonRpcTimeSyncViewerMethods,
+  JsonRpcTransactionViewer,
   JsonRpcXyoRunner,
   JsonRpcXyoSigner,
   JsonRpcXyoSignerMethods,
@@ -2521,6 +2627,7 @@ export {
   StakeTotalsViewerRpcSchemas,
   StakeViewerRpcSchemas,
   TimeSyncViewerRpcSchemas,
+  TransactionViewerRpcSchemas,
   XyoPermissionsRpcSchemas,
   XyoRunnerRpcSchemas,
   XyoSignerRpcSchemas,