@xyo-network/xl1-rpc 1.15.2 → 1.15.3

package/dist/neutral/index.mjs

@@ -23,6 +23,20 @@ var rpcMethodHandlersFromSigner = /* @__PURE__ */ __name((signer) => {
 // src/engine/rpcMethodHandlersFromViewer.ts
 var rpcMethodHandlersFromViewer = /* @__PURE__ */ __name((viewer) => {
   return {
+    xyoViewer_networkStakeStepRewardClaimedByAddress: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardClaimedByAddress(...params ?? []), "xyoViewer_networkStakeStepRewardClaimedByAddress"),
+    xyoViewer_networkStakeStepRewardAddressReward: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardAddressReward(...params ?? []), "xyoViewer_networkStakeStepRewardAddressReward"),
+    xyoViewer_networkStakeStepRewardAddressHistory: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardAddressHistory(...params ?? []), "xyoViewer_networkStakeStepRewardAddressHistory"),
+    xyoViewer_networkStakeStepRewardAddressShare: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardAddressShare(...params ?? []), "xyoViewer_networkStakeStepRewardAddressShare"),
+    xyoViewer_networkStakeStepRewardWeightForAddress: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardWeightForAddress?.(...params ?? []), "xyoViewer_networkStakeStepRewardWeightForAddress"),
+    xyoViewer_networkStakeStepRewardUnclaimedByAddress: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardUnclaimedByAddress(...params ?? []), "xyoViewer_networkStakeStepRewardUnclaimedByAddress"),
+    xyoViewer_networkStakeStepRewardPoolShares: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardPoolShares(...params ?? []), "xyoViewer_networkStakeStepRewardPoolShares"),
+    xyoViewer_networkStakeStepRewardPoolRewards: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardPoolRewards(...params ?? []), "xyoViewer_networkStakeStepRewardPoolRewards"),
+    xyoViewer_networkStakeStepRewardPositionWeight: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardPositionWeight?.(...params ?? []), "xyoViewer_networkStakeStepRewardPositionWeight"),
+    xyoViewer_networkStakeStepRewardPotentialPositionLoss: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardPotentialPositionLoss?.(...params ?? []), "xyoViewer_networkStakeStepRewardPotentialPositionLoss"),
+    xyoViewer_networkStakeStepRewardForStep: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardForStep?.(...params ?? []), "xyoViewer_networkStakeStepRewardForStep"),
+    xyoViewer_networkStakeStepRewardRandomizer: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardRandomizer?.(...params ?? []), "xyoViewer_networkStakeStepRewardRandomizer"),
+    xyoViewer_networkStakeStepRewardStakerCount: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardStakerCount?.(...params ?? []), "xyoViewer_networkStakeStepRewardStakerCount"),
+    xyoViewer_networkStakeStepRewardForStepForPosition: /* @__PURE__ */ __name((params) => viewer.networkStakeStepRewardForStepForPosition?.(...params ?? []), "xyoViewer_networkStakeStepRewardForStepForPosition"),
     xyoViewer_accountBalance: /* @__PURE__ */ __name((params) => viewer.accountBalance(...params ?? []), "xyoViewer_accountBalance"),
     xyoViewer_accountBalanceHistory: /* @__PURE__ */ __name((params) => viewer.accountBalanceHistory(...params ?? []), "xyoViewer_accountBalanceHistory"),
     xyoViewer_blockByHash: /* @__PURE__ */ __name((params) => viewer.blockByHash(...params ?? []), "xyoViewer_blockByHash"),
@@ -35,13 +49,17 @@ var rpcMethodHandlersFromViewer = /* @__PURE__ */ __name((viewer) => {
     xyoViewer_currentBlockNumber: /* @__PURE__ */ __name((params) => viewer.currentBlockNumber(...params ?? []), "xyoViewer_currentBlockNumber"),
     xyoViewer_forkHistory: /* @__PURE__ */ __name((params) => viewer.forkHistory(...params ?? []), "xyoViewer_forkHistory"),
     xyoViewer_stakeById: /* @__PURE__ */ __name((params) => viewer.stakeById(...params ?? []), "xyoViewer_stakeById"),
-    xyoViewer_stakeByAddress: /* @__PURE__ */ __name((params) => viewer.stakeByAddress(...params ?? []), "xyoViewer_stakeByAddress"),
+    xyoViewer_stakeByStaker: /* @__PURE__ */ __name((params) => viewer.stakeByStaker(...params ?? []), "xyoViewer_stakeByStaker"),
     xyoViewer_stakesByStaked: /* @__PURE__ */ __name((params) => viewer.stakesByStaked(...params ?? []), "xyoViewer_stakesByStaked"),
     xyoViewer_stakesByStaker: /* @__PURE__ */ __name((params) => viewer.stakesByStaker(...params ?? []), "xyoViewer_stakesByStaker"),
     xyoViewer_stakedByStaker: /* @__PURE__ */ __name((params) => viewer.stakedByStaker(...params ?? []), "xyoViewer_stakedByStaker"),
     xyoViewer_transactionByBlockHashAndIndex: /* @__PURE__ */ __name((params) => viewer.transactionByBlockHashAndIndex(...params ?? []), "xyoViewer_transactionByBlockHashAndIndex"),
     xyoViewer_transactionByBlockNumberAndIndex: /* @__PURE__ */ __name((params) => viewer.transactionByBlockNumberAndIndex(...params ?? []), "xyoViewer_transactionByBlockNumberAndIndex"),
-    xyoViewer_transactionByHash: /* @__PURE__ */ __name((params) => viewer.transactionByHash(...params ?? []), "xyoViewer_transactionByHash")
+    xyoViewer_transactionByHash: /* @__PURE__ */ __name((params) => viewer.transactionByHash(...params ?? []), "xyoViewer_transactionByHash"),
+    xyoViewer_transferBalance: /* @__PURE__ */ __name((params) => viewer.transferBalance(...params ?? []), "xyoViewer_transferBalance"),
+    xyoViewer_transferBalanceHistory: /* @__PURE__ */ __name((params) => viewer.transferBalanceHistory(...params ?? []), "xyoViewer_transferBalanceHistory"),
+    xyoViewer_transferPairBalance: /* @__PURE__ */ __name((params) => viewer.transferPairBalance(...params ?? []), "xyoViewer_transferPairBalance"),
+    xyoViewer_transferPairBalanceHistory: /* @__PURE__ */ __name((params) => viewer.transferPairBalanceHistory(...params ?? []), "xyoViewer_transferPairBalanceHistory")
   };
 }, "rpcMethodHandlersFromViewer");
 
@@ -66,6 +84,15 @@ var rpcMethodHandlersFromConnection = /* @__PURE__ */ __name((connection) => {
   return result;
 }, "rpcMethodHandlersFromConnection");
 
+// src/engine/rpcMethodHandlersFromPermissions.ts
+var rpcMethodHandlersFromPermissions = /* @__PURE__ */ __name((permissions) => {
+  return {
+    xyoPermissions_getPermissions: /* @__PURE__ */ __name((params) => permissions.getPermissions(...params ?? []), "xyoPermissions_getPermissions"),
+    xyoPermissions_requestPermissions: /* @__PURE__ */ __name((params) => permissions.requestPermissions(...params ?? []), "xyoPermissions_requestPermissions"),
+    xyoPermissions_revokePermissions: /* @__PURE__ */ __name((params) => permissions.revokePermissions(...params ?? []), "xyoPermissions_revokePermissions")
+  };
+}, "rpcMethodHandlersFromPermissions");
+
 // src/provider/client/MemoryXyoClient.ts
 var MemoryXyoClient = class {
   static {
@@ -79,47 +106,8 @@ var MemoryXyoClient = class {
   }
 };
 
-// src/provider/client/PermissionsStore/getPermissionsStoreFromTransport.ts
-var getPermissionsStoreFromTransport = /* @__PURE__ */ __name((_transport) => {
-  throw new Error("Not implemented");
-}, "getPermissionsStoreFromTransport");
-
-// src/provider/client/PermissionsStore/MemoryPermissionsStore.ts
-var MemoryPermissionsStore = class {
-  static {
-    __name(this, "MemoryPermissionsStore");
-  }
-  _store = /* @__PURE__ */ new Map();
-  getPermissions() {
-    return [
-      ...this._store.values()
-    ];
-  }
-  requestPermissions(permissions) {
-    const now = Date.now();
-    for (const perm of permissions) {
-      const key = this.getKey(perm);
-      this._store.set(key, {
-        ...perm,
-        date: now
-      });
-    }
-    return true;
-  }
-  revokePermissions(permissions) {
-    for (const perm of permissions) {
-      const key = this.getKey(perm);
-      this._store.delete(key);
-    }
-    return true;
-  }
-  getKey(permission) {
-    return `${permission.invoker}::${permission.capability}`;
-  }
-};
-
 // src/provider/connection/HttpRpcXyoConnection.ts
-import { isDefined as isDefined3, isString as isString2 } from "@xylabs/typeof";
+import { isDefined as isDefined2, isString as isString2 } from "@xylabs/typeof";
 import { isDataLakeProvider as isDataLakeProvider2 } from "@xyo-network/xl1-protocol";
 
 // src/transport/HttpRpcTransport.ts
@@ -155,8 +143,8 @@ var JsonRpcErrorCodes = {
 // src/types/JsonRpc.ts
 var jsonrpc = "2.0";
 
-// src/types/schema/XyoProviderRpcSchemas.ts
-import * as z14 from "zod";
+// src/types/schema/XyoPermissionsRpcSchemas.ts
+import * as z16 from "zod";
 
 // src/types/schema/common/Address.ts
 import { AddressRegEx, toAddress } from "@xylabs/hex";
@@ -395,14 +383,15 @@ var CaveatTypesZod = z12.enum([
   "chain",
   "expiration",
   "filteredResponse",
-  "rateLimit"
+  "rateLimit",
+  "restrictReturnedAccounts"
 ]);
 var CaveatsZod = z12.object({
   type: CaveatTypesZod,
   value: z12.json()
 });
 var PermissionZod = z12.object({
-  capability: z12.string(),
+  parentCapability: z12.string(),
   caveats: CaveatsZod.array().optional(),
   invoker: z12.string()
 });
@@ -411,17 +400,17 @@ var InvokerPermissionZod = PermissionZod.extend({
 });
 var PermissionRequestZod = z12.record(z12.string(), z12.record(z12.string(), z12.any()));
 var RequestedPermissionZod = z12.object({
-  capability: z12.string(),
+  parentCapability: z12.string(),
   date: z12.number().optional()
 });
 
 // src/types/schema/common/Stake.ts
+import { HexZod as HexZod4 } from "@xylabs/hex";
 import * as z13 from "zod";
 var StakeZod = z13.object({
+  amount: AttoZod,
   // the block number when the stake was added
   addBlock: z13.number(),
-  // the amount that is staked
-  amount: AttoZod,
   // the unique id for the stake item
   id: z13.number(),
   // the block number when the stake was removed (set to 0 if not removed)
@@ -442,7 +431,9 @@ var StakeToJsonZod = StakeZod.transform((val) => ({
   staker: AddressZod.parse(val.staker),
   withdrawBlock: val.withdrawBlock
 }));
-var JsonToStakeZod = StakeZod.transform((val) => ({
+var JsonToStakeZod = StakeZod.extend({
+  amount: HexZod4
+}).transform((val) => ({
   addBlock: val.addBlock,
   amount: JsonToAttoZod.parse(val.amount),
   id: val.id,
@@ -452,25 +443,87 @@ var JsonToStakeZod = StakeZod.transform((val) => ({
   withdrawBlock: val.withdrawBlock
 }));
 
+// src/types/schema/common/StepContext.ts
+import * as z14 from "zod";
+var StepContextZod = z14.object({
+  block: z14.number(),
+  step: z14.number()
+});
+
+// src/types/schema/common/Transfer.ts
+import { BigIntToJsonZod as BigIntToJsonZod2 } from "@xylabs/hex";
+import { PayloadZodStrictOfSchema } from "@xyo-network/payload-model";
+import { TransferSchema } from "@xyo-network/xl1-protocol";
+import z15 from "zod";
+var TransferFieldsZod = z15.object({
+  epoch: z15.number(),
+  from: AddressZod,
+  transfers: z15.record(AddressZod, BigIntToJsonZod2)
+});
+var TransferZod = PayloadZodStrictOfSchema(TransferSchema).extend(TransferFieldsZod.shape);
+
+// src/types/schema/XyoPermissionsRpcSchemas.ts
+var XyoPermissionsRpcSchemas = {
+  xyoPermissions_getPermissions: {
+    params: {
+      to: z16.array(z16.any()).length(0),
+      from: z16.array(z16.any()).length(0)
+    },
+    result: {
+      to: z16.array(InvokerPermissionZod),
+      from: z16.array(InvokerPermissionZod)
+    }
+  },
+  xyoPermissions_requestPermissions: {
+    params: {
+      to: z16.tuple([
+        z16.array(PermissionRequestZod)
+      ]),
+      from: z16.tuple([
+        z16.array(PermissionRequestZod)
+      ])
+    },
+    result: {
+      to: z16.array(RequestedPermissionZod),
+      from: z16.array(RequestedPermissionZod)
+    }
+  },
+  xyoPermissions_revokePermissions: {
+    params: {
+      to: z16.tuple([
+        z16.array(PermissionRequestZod)
+      ]),
+      from: z16.tuple([
+        z16.array(PermissionRequestZod)
+      ])
+    },
+    result: {
+      to: z16.array(RequestedPermissionZod),
+      from: z16.array(RequestedPermissionZod)
+    }
+  }
+};
+
 // src/types/schema/XyoProviderRpcSchemas.ts
+import * as z17 from "zod";
 var XyoProviderRpcSchemas = {
   xyoProvider_send: {
     params: {
-      to: z14.tuple([
+      to: z17.tuple([
         AddressZod,
-        z14.array(PayloadZod),
-        z14.array(PayloadZod),
-        z14.number().nonnegative(),
-        z14.number().nonnegative(),
+        z17.array(PayloadZod),
+        z17.array(PayloadZod),
+        z17.number().nonnegative(),
+        z17.number().nonnegative(),
         TransactionFeesBigIntToJsonZod,
         AddressZod.optional()
       ]),
-      from: z14.tuple([
+      from: z17.tuple([
         AddressZod,
-        z14.array(PayloadZod),
-        z14.array(PayloadZod),
-        z14.number().nonnegative(),
-        z14.number().nonnegative(),
+        z17.array(PayloadZod),
+        z17.array(PayloadZod),
+        z17.number().nonnegative(),
+        z17.number().nonnegative(),
         TransactionFeesJsonToBigIntZod,
         AddressZod.optional()
       ])
@@ -484,14 +537,14 @@ var XyoProviderRpcSchemas = {
 
 // src/types/schema/XyoRunnerRpcSchemas.ts
 import { HashToJsonZod as HashToJsonZod2, JsonToHashZod } from "@xylabs/hex";
-import * as z15 from "zod";
+import * as z18 from "zod";
 var XyoRunnerRpcSchemas = {
   xyoRunner_broadcastTransaction: {
     params: {
-      to: z15.tuple([
+      to: z18.tuple([
         SignedHydratedTransactionZod
       ]),
-      from: z15.tuple([
+      from: z18.tuple([
         SignedHydratedTransactionZod
       ])
     },
@@ -504,12 +557,12 @@ var XyoRunnerRpcSchemas = {
 
 // src/types/schema/XyoSignerRpcSchemas.ts
 import { AllowedBlockPayloadZod, asHydratedTransactionWithStorageMeta } from "@xyo-network/xl1-protocol";
-import { z as z16 } from "zod";
+import { z as z19 } from "zod";
 var XyoSignerRpcSchemas = {
   xyoSigner_address: {
     params: {
-      to: z16.array(z16.any()).length(0).optional(),
-      from: z16.array(z16.any()).length(0).optional()
+      to: z19.array(z19.any()).length(0).optional(),
+      from: z19.array(z19.any()).length(0).optional()
     },
     result: {
       to: AddressZod,
@@ -519,21 +572,21 @@ var XyoSignerRpcSchemas = {
   // NOTE: method is deprecated which is why it uses deprecated types
   xyoSigner_createSignedTransaction: {
     params: {
-      to: z16.tuple([
+      to: z19.tuple([
         ChainZod,
-        z16.array(AllowedBlockPayloadZod),
-        z16.array(PayloadZod),
-        z16.number().nonnegative(),
-        z16.number().nonnegative(),
+        z19.array(AllowedBlockPayloadZod),
+        z19.array(PayloadZod),
+        z19.number().nonnegative(),
+        z19.number().nonnegative(),
         TransactionFeesBigIntToJsonZod,
         AddressZod.optional()
       ]),
-      from: z16.tuple([
+      from: z19.tuple([
         ChainZod,
-        z16.array(PayloadZod),
-        z16.array(PayloadZod),
-        z16.number().nonnegative(),
-        z16.number().nonnegative(),
+        z19.array(PayloadZod),
+        z19.array(PayloadZod),
+        z19.number().nonnegative(),
+        z19.number().nonnegative(),
         TransactionFeesJsonToBigIntZod,
         AddressZod.optional()
       ])
@@ -545,10 +598,10 @@ var XyoSignerRpcSchemas = {
   },
   xyoSigner_signTransaction: {
     params: {
-      to: z16.tuple([
+      to: z19.tuple([
         UnsignedHydratedTransactionZod
       ]),
-      from: z16.tuple([
+      from: z19.tuple([
         UnsignedHydratedTransactionZod
       ])
     },
@@ -562,83 +615,423 @@ var XyoSignerRpcSchemas = {
 };
 
 // src/types/schema/XyoViewerRpcSchemas.ts
-import { BigIntToJsonZod as BigIntToJsonZod2, HashToJsonZod as HashToJsonZod3, HashZod as HashZod2, JsonToBigIntZod as JsonToBigIntZod2, JsonToHashZod as JsonToHashZod2 } from "@xylabs/hex";
-import * as z17 from "zod";
+import { BigIntToJsonZod as BigIntToJsonZod3, HashToJsonZod as HashToJsonZod3, HashZod as HashZod2, JsonToBigIntZod as JsonToBigIntZod2, JsonToHashZod as JsonToHashZod2 } from "@xylabs/hex";
+import * as z20 from "zod";
 var XyoViewerRpcSchemas = {
+  xyoViewer_networkStakeStepRewardClaimedByAddress: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          AddressZod
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          AddressZod
+        ])
+      ])
+    },
+    result: {
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod2
+    }
+  },
+  xyoViewer_networkStakeStepRewardAddressReward: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          StepContextZod,
+          AddressZod
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          StepContextZod,
+          AddressZod
+        ])
+      ])
+    },
+    result: {
+      to: z20.record(AddressZod, BigIntToJsonZod3),
+      from: z20.record(AddressZod, JsonToBigIntZod2)
+    }
+  },
+  xyoViewer_networkStakeStepRewardAddressHistory: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          AddressZod
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          AddressZod
+        ])
+      ])
+    },
+    result: {
+      to: z20.record(AddressZod, BigIntToJsonZod3),
+      from: z20.record(AddressZod, JsonToBigIntZod2)
+    }
+  },
+  xyoViewer_networkStakeStepRewardAddressShare: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          StepContextZod,
+          AddressZod
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          StepContextZod,
+          AddressZod
+        ])
+      ])
+    },
+    result: {
+      to: z20.tuple([
+        BigIntToJsonZod3,
+        BigIntToJsonZod3
+      ]),
+      from: z20.tuple([
+        JsonToBigIntZod2,
+        JsonToBigIntZod2
+      ])
+    }
+  },
+  xyoViewer_networkStakeStepRewardWeightForAddress: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          StepContextZod,
+          AddressZod
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          StepContextZod,
+          AddressZod
+        ])
+      ])
+    },
+    result: {
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod2
+    }
+  },
+  xyoViewer_networkStakeStepRewardUnclaimedByAddress: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          AddressZod
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          AddressZod
+        ])
+      ])
+    },
+    result: {
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod2
+    }
+  },
+  xyoViewer_networkStakeStepRewardPoolRewards: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          StepContextZod
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          StepContextZod
+        ])
+      ])
+    },
+    result: {
+      to: z20.record(AddressZod, BigIntToJsonZod3),
+      from: z20.record(AddressZod, JsonToBigIntZod2)
+    }
+  },
+  xyoViewer_networkStakeStepRewardPositionWeight: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          StepContextZod,
+          z20.number()
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          StepContextZod,
+          z20.number()
+        ])
+      ])
+    },
+    result: {
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod2
+    }
+  },
+  xyoViewer_networkStakeStepRewardPotentialPositionLoss: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          StepContextZod,
+          z20.number()
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          StepContextZod,
+          z20.number()
+        ])
+      ])
+    },
+    result: {
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod2
+    }
+  },
+  xyoViewer_networkStakeStepRewardForStep: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          StepContextZod
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          StepContextZod
+        ])
+      ])
+    },
+    result: {
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod2
+    }
+  },
+  xyoViewer_networkStakeStepRewardRandomizer: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          StepContextZod
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          StepContextZod
+        ])
+      ])
+    },
+    result: {
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod2
+    }
+  },
+  xyoViewer_networkStakeStepRewardStakerCount: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          StepContextZod
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          StepContextZod
+        ])
+      ])
+    },
+    result: {
+      to: z20.number(),
+      from: z20.number()
+    }
+  },
+  xyoViewer_networkStakeStepRewardPoolShares: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          StepContextZod
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          StepContextZod
+        ])
+      ])
+    },
+    result: {
+      to: z20.record(AddressZod, BigIntToJsonZod3),
+      from: z20.record(AddressZod, JsonToBigIntZod2)
+    }
+  },
+  xyoViewer_networkStakeStepRewardForStepForPosition: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          StepContextZod,
+          z20.number()
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          StepContextZod,
+          z20.number()
+        ])
+      ])
+    },
+    result: {
+      to: z20.tuple([
+        BigIntToJsonZod3,
+        BigIntToJsonZod3
+      ]),
+      from: z20.tuple([
+        JsonToBigIntZod2,
+        JsonToBigIntZod2
+      ])
+    }
+  },
   xyoViewer_accountBalance: {
     params: {
-      to: z17.union([
-        z17.tuple([
+      to: z20.union([
+        z20.tuple([
           AddressZod
-        ]),
-        z17.tuple([
-          AddressZod,
-          z17.number()
-        ]),
-        z17.tuple([
-          AddressZod,
-          z17.number(),
-          z17.boolean()
         ])
       ]),
-      from: z17.union([
-        z17.tuple([
+      from: z20.union([
+        z20.tuple([
           AddressZod
-        ]),
-        z17.tuple([
-          AddressZod,
-          z17.number()
-        ]),
-        z17.tuple([
-          AddressZod,
-          z17.number(),
-          z17.boolean()
         ])
       ])
     },
     result: {
-      to: BigIntToJsonZod2,
+      to: BigIntToJsonZod3,
       from: JsonToBigIntZod2
     }
   },
   xyoViewer_accountBalanceHistory: {
     params: {
-      to: z17.union([
-        z17.tuple([
+      to: z20.union([
+        z20.tuple([
           AddressZod
-        ]),
-        z17.tuple([
-          AddressZod,
-          z17.number()
-        ]),
-        z17.tuple([
-          AddressZod,
-          z17.number(),
-          z17.boolean()
         ])
       ]),
-      from: z17.union([
-        z17.tuple([
+      from: z20.union([
+        z20.tuple([
           AddressZod
-        ]),
-        z17.tuple([
-          AddressZod,
-          z17.number()
-        ]),
-        z17.tuple([
-          AddressZod,
-          z17.number(),
-          z17.boolean()
         ])
       ])
     },
     result: {
-      to: z17.array(z17.tuple([
+      to: z20.array(z20.tuple([
+        HashZod2,
+        HashZod2,
+        TransferZod
+      ])),
+      from: z20.array(z20.tuple([
+        HashZod2,
+        HashZod2,
+        TransferZod
+      ]))
+    }
+  },
+  xyoViewer_transferPairBalance: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          z20.tuple([
+            AddressZod,
+            AddressZod
+          ])
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          z20.tuple([
+            AddressZod,
+            AddressZod
+          ])
+        ])
+      ])
+    },
+    result: {
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod2
+    }
+  },
+  xyoViewer_transferPairBalanceHistory: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          z20.tuple([
+            AddressZod,
+            AddressZod
+          ])
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          z20.tuple([
+            AddressZod,
+            AddressZod
+          ])
+        ])
+      ])
+    },
+    result: {
+      to: z20.array(z20.tuple([
         HashZod2,
         HashZod2,
         PayloadZod
       ])),
-      from: z17.array(z17.tuple([
+      from: z20.array(z20.tuple([
+        HashZod2,
+        HashZod2,
+        PayloadZod
+      ]))
+    }
+  },
+  xyoViewer_transferBalance: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          AddressZod
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          AddressZod
+        ])
+      ])
+    },
+    result: {
+      to: BigIntToJsonZod3,
+      from: JsonToBigIntZod2
+    }
+  },
+  xyoViewer_transferBalanceHistory: {
+    params: {
+      to: z20.union([
+        z20.tuple([
+          AddressZod
+        ])
+      ]),
+      from: z20.union([
+        z20.tuple([
+          AddressZod
+        ])
+      ])
+    },
+    result: {
+      to: z20.array(z20.tuple([
+        HashZod2,
+        HashZod2,
+        PayloadZod
+      ])),
+      from: z20.array(z20.tuple([
         HashZod2,
         HashZod2,
         PayloadZod
@@ -647,10 +1040,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blockByHash: {
     params: {
-      to: z17.tuple([
+      to: z20.tuple([
         HashToJsonZod3
       ]),
-      from: z17.tuple([
+      from: z20.tuple([
         JsonToHashZod2
       ])
     },
@@ -661,11 +1054,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blockByNumber: {
     params: {
-      to: z17.tuple([
-        z17.number()
+      to: z20.tuple([
+        z20.number()
       ]),
-      from: z17.tuple([
-        z17.number()
+      from: z20.tuple([
+        z20.number()
       ])
     },
     result: {
@@ -675,24 +1068,24 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_blocksByHash: {
     params: {
-      to: z17.tuple([
+      to: z20.tuple([
         HashZod2,
-        z17.number().optional()
+        z20.number().optional()
       ]),
-      from: z17.tuple([
+      from: z20.tuple([
         HashZod2,
-        z17.number().optional()
+        z20.number().optional()
       ])
     },
     result: {
-      to: z17.array(SignedHydratedBlockZod),
-      from: z17.array(SignedHydratedBlockZod)
+      to: z20.array(SignedHydratedBlockZod),
+      from: z20.array(SignedHydratedBlockZod)
     }
   },
   xyoViewer_chainId: {
     params: {
-      to: z17.array(z17.any()).length(0).optional(),
-      from: z17.array(z17.any()).length(0).optional()
+      to: z20.array(z20.any()).length(0).optional(),
+      from: z20.array(z20.any()).length(0).optional()
     },
     result: {
       to: AddressZod,
@@ -701,10 +1094,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_chainIdAtBlock: {
     params: {
-      to: z17.tuple([
+      to: z20.tuple([
         BlockNumberZod
       ]),
-      from: z17.tuple([
+      from: z20.tuple([
         BlockNumberZod
       ])
     },
@@ -715,8 +1108,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_currentBlock: {
     params: {
-      to: z17.array(z17.any()).length(0).optional(),
-      from: z17.array(z17.any()).length(0).optional()
+      to: z20.array(z20.any()).length(0).optional(),
+      from: z20.array(z20.any()).length(0).optional()
     },
     result: {
       to: SignedHydratedBlockZod,
@@ -725,8 +1118,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_currentBlockHash: {
     params: {
-      to: z17.array(z17.any()).length(0).optional(),
-      from: z17.array(z17.any()).length(0).optional()
+      to: z20.array(z20.any()).length(0).optional(),
+      from: z20.array(z20.any()).length(0).optional()
     },
     result: {
       to: HashZod2,
@@ -735,8 +1128,8 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_currentBlockNumber: {
     params: {
-      to: z17.array(z17.any()).length(0).optional(),
-      from: z17.array(z17.any()).length(0).optional()
+      to: z20.array(z20.any()).length(0).optional(),
+      from: z20.array(z20.any()).length(0).optional()
     },
     result: {
       to: BlockNumberZod,
@@ -745,23 +1138,23 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_forkHistory: {
     params: {
-      to: z17.array(z17.any()).length(0).optional(),
-      from: z17.array(z17.any()).length(0).optional()
+      to: z20.array(z20.any()).length(0).optional(),
+      from: z20.array(z20.any()).length(0).optional()
     },
     result: {
-      to: z17.record(z17.number(), AddressZod),
-      from: z17.record(z17.number(), AddressZod)
+      to: z20.record(z20.number(), AddressZod),
+      from: z20.record(z20.number(), AddressZod)
     }
   },
-  xyoViewer_stakeByAddress: {
+  xyoViewer_stakeByStaker: {
     params: {
-      to: z17.tuple([
+      to: z20.tuple([
         AddressZod,
-        z17.number()
+        z20.number()
       ]),
-      from: z17.tuple([
+      from: z20.tuple([
         AddressZod,
-        z17.number()
+        z20.number()
       ])
     },
     result: {
@@ -771,11 +1164,11 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakeById: {
     params: {
-      to: z17.tuple([
-        z17.number()
+      to: z20.tuple([
+        z20.number()
       ]),
-      from: z17.tuple([
-        z17.number()
+      from: z20.tuple([
+        z20.number()
       ])
     },
     result: {
@@ -785,55 +1178,55 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_stakedByStaker: {
     params: {
-      to: z17.tuple([
+      to: z20.tuple([
         AddressZod
       ]),
-      from: z17.tuple([
+      from: z20.tuple([
         AddressZod
       ])
     },
     result: {
-      to: BigIntToJsonZod2,
-      from: JsonToBigIntZod2
+      to: z20.array(AddressZod),
+      from: z20.array(AddressZod)
     }
   },
   xyoViewer_stakesByStaker: {
     params: {
-      to: z17.tuple([
+      to: z20.tuple([
         AddressZod
       ]),
-      from: z17.tuple([
+      from: z20.tuple([
         AddressZod
       ])
     },
     result: {
-      to: z17.number(),
-      from: z17.number()
+      to: z20.array(StakeToJsonZod),
+      from: z20.array(JsonToStakeZod)
     }
   },
   xyoViewer_stakesByStaked: {
     params: {
-      to: z17.tuple([
+      to: z20.tuple([
         AddressZod
       ]),
-      from: z17.tuple([
+      from: z20.tuple([
         AddressZod
       ])
     },
     result: {
-      to: z17.number(),
-      from: z17.number()
+      to: z20.array(StakeToJsonZod),
+      from: z20.array(JsonToStakeZod)
     }
   },
   xyoViewer_transactionByBlockHashAndIndex: {
     params: {
-      to: z17.tuple([
+      to: z20.tuple([
         HashZod2,
-        z17.number()
+        z20.number()
       ]),
-      from: z17.tuple([
+      from: z20.tuple([
         HashZod2,
-        z17.number()
+        z20.number()
       ])
     },
     result: {
@@ -843,13 +1236,13 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByBlockNumberAndIndex: {
     params: {
-      to: z17.tuple([
-        z17.number(),
-        z17.number()
+      to: z20.tuple([
+        z20.number(),
+        z20.number()
       ]),
-      from: z17.tuple([
-        z17.number(),
-        z17.number()
+      from: z20.tuple([
+        z20.number(),
+        z20.number()
       ])
     },
     result: {
@@ -859,10 +1252,10 @@ var XyoViewerRpcSchemas = {
   },
   xyoViewer_transactionByHash: {
     params: {
-      to: z17.tuple([
+      to: z20.tuple([
         HashZod2
       ]),
-      from: z17.tuple([
+      from: z20.tuple([
         HashZod2
       ])
     },
@@ -878,117 +1271,33 @@ var AllRpcSchemas = {
   ...XyoProviderRpcSchemas,
   ...XyoRunnerRpcSchemas,
   ...XyoSignerRpcSchemas,
-  ...XyoViewerRpcSchemas
+  ...XyoViewerRpcSchemas,
+  ...XyoPermissionsRpcSchemas
 };
 
 // src/types/schema/createRequestSchema.ts
-import * as z18 from "zod";
-var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z18.undefined()) => z18.object({
-  id: z18.union([
-    z18.string(),
-    z18.number()
+import * as z21 from "zod";
+var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z21.undefined()) => z21.object({
+  id: z21.union([
+    z21.string(),
+    z21.number()
   ]),
-  jsonrpc: z18.literal(jsonrpc),
-  method: z18.literal(methodName),
+  jsonrpc: z21.literal(jsonrpc),
+  method: z21.literal(methodName),
   params: paramsSchema
 }), "createRequestSchema");
 
 // src/types/schema/createResponseSchema.ts
-import * as z19 from "zod";
-var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z19.undefined()) => z19.object({
-  id: z19.union([
-    z19.string(),
-    z19.number()
+import * as z22 from "zod";
+var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z22.undefined()) => z22.object({
+  id: z22.union([
+    z22.string(),
+    z22.number()
   ]),
-  jsonrpc: z19.literal(jsonrpc),
+  jsonrpc: z22.literal(jsonrpc),
   result: resultSchema
 }), "createResponseSchema");
 
-// src/types/schema/XyoGatewayRpcSchemas.ts
-import * as z20 from "zod";
-var ChainConnectionZod = z20.object({
-  chainId: z20.union([
-    z20.string(),
-    z20.custom()
-  ]).optional(),
-  name: z20.string(),
-  url: z20.string()
-});
-var XyoGatewayRpcSchemas = {
-  /*
-  xyoGateway_addConnection: {
-    params: {
-      to: z.tuple([ChainConnectionSchema]),
-      from: z.tuple([ChainConnectionSchema]),
-    },
-    result: {
-      to: z.tuple([z.boolean()]),
-      from: z.tuple([z.boolean()]),
-    },
-  },
-  xyoGateway_connections: {
-    params: {
-      to: z.array(z.any()).length(0).optional(),
-      from: z.array(z.any()).length(0).optional(),
-    },
-    result: {
-      to: z.array(ChainConnectionSchema),
-      from: z.array(ChainConnectionSchema),
-    },
-  },
-  xyoGateway_getPermissions: {
-    params: {
-      to: z.array(z.any()).length(0).optional(),
-      from: z.array(z.any()).length(0).optional(),
-    },
-    result: {
-      to: z.array(InvokerPermissionSchema),
-      from: z.array(InvokerPermissionSchema),
-    },
-  },
-  xyoGateway_requestPermissions: {
-    params: {
-      to: z.array(PermissionSchema),
-      from: z.array(PermissionSchema),
-    },
-    result: {
-      to: z.boolean(),
-      from: z.boolean(),
-    },
-  },
-  xyoGateway_revokePermissions: {
-    params: {
-      to: z.array(PermissionSchema),
-      from: z.array(PermissionSchema),
-    },
-    result: {
-      to: z.boolean(),
-      from: z.boolean(),
-    },
-  },
-  xyoGateway_activeConnection: {
-    params: {
-      from: z.never(),
-      to: z.never(),
-    },
-    result: {
-      from: z.string().optional(),
-      to: z.string().optional(),
-    },
-  },
-  */
-  xyoGateway_submitTransaction: {
-    params: {
-      from: z20.array(HydratedTransactionZod),
-      to: z20.array(HydratedTransactionZod)
-    },
-    result: {
-      from: BlockBoundWitnessZod,
-      to: BlockBoundWitnessZod
-    }
-  }
-};
-
 // src/transport/HttpRpcTransport.ts
 var HttpRpcTransport = class {
   static {
@@ -1071,100 +1380,6 @@ var MemoryRpcTransport = class {
   }
 };
 
-// src/transport/post-message/LegacyPostMessageRpcTransport.ts
-import { isJsonRpcError, isJsonRpcSuccess } from "@metamask/utils";
-import { isDefined } from "@xylabs/typeof";
-import { v4 as v43 } from "uuid";
-
-// src/transport/post-message/helpers.ts
-var isRpcError = /* @__PURE__ */ __name((data) => {
-  return data && typeof data === "object" && "error" in data && data.error;
-}, "isRpcError");
-
-// src/transport/post-message/resolveData.ts
-var hasMatchingId = /* @__PURE__ */ __name((eventData, targetId) => {
-  return eventData?.id === targetId ? {
-    legacyEventData: eventData
-  } : false;
-}, "hasMatchingId");
-var hasMatchingNestedId = /* @__PURE__ */ __name((eventData, targetId) => {
-  return eventData?.data?.id === targetId ? {
-    eventData: eventData.data
-  } : false;
-}, "hasMatchingNestedId");
-var resolvedEvent = /* @__PURE__ */ __name((event, targetId) => {
-  return hasMatchingId(event.data, targetId) || hasMatchingNestedId(event.data, targetId);
-}, "resolvedEvent");
-
-// src/transport/post-message/LegacyPostMessageRpcTransport.ts
-var isValidBaseRpcEvent = /* @__PURE__ */ __name((data) => {
-  return !!(data && typeof data === "object" && "jsonrpc" in data && data.jsonrpc === "2.0" && "method" in data && typeof data.method === "string" && "id" in data && typeof data.id === "string");
-}, "isValidBaseRpcEvent");
-var isRpcResponse = /* @__PURE__ */ __name((data, targetId) => {
-  return isValidBaseRpcEvent(data) && (isDefined(targetId) ? data.id === targetId : true) && "result" in data && Array.isArray(data.result);
-}, "isRpcResponse");
-var LegacyPostMessageRpcTransport = class {
-  static {
-    __name(this, "LegacyPostMessageRpcTransport");
-  }
-  destination;
-  schemas;
-  sessionId;
-  constructor(defaultDestination, sessionId) {
-    this.schemas = XyoGatewayRpcSchemas;
-    this.destination = defaultDestination;
-    this.sessionId = sessionId;
-  }
-  async sendRequest(method, params) {
-    const id = v43();
-    return await this.callRpc(this.schemas, method, id, params);
-  }
-  async callRpc(schemas, method, id, params) {
-    const body = {
-      jsonrpc,
-      id,
-      method
-    };
-    body.params = isDefined(params) && isDefined(schemas[method]) ? schemas[method].params.to.parse(params) : params;
-    return await new Promise((resolve, reject) => {
-      const id2 = body.id;
-      const handler = /* @__PURE__ */ __name((event) => {
-        if (event.origin !== globalThis.window.origin) return;
-        if (!isRpcResponse(event.data, id2)) return;
-        const data = resolvedEvent(event, id2);
-        if (data === false) return;
-        globalThis.removeEventListener("message", handler);
-        if (data.legacyEventData) {
-          if (data.legacyEventData.result.some(isRpcError)) {
-            reject(data.legacyEventData.result[0]);
-          } else {
-            resolve(data.legacyEventData.result[0]);
-          }
-          return;
-        }
-        if (data.eventData) {
-          if (isJsonRpcError(data.eventData)) {
-            reject(data.eventData);
-            return;
-          }
-          if (isJsonRpcSuccess(data.eventData)) {
-            resolve(data.eventData);
-            return;
-          }
-          reject(new Error("Unexpected response format"));
-        }
-      }, "handler");
-      globalThis.addEventListener("message", handler);
-      globalThis.postMessage({
-        data: body,
-        destination: this.destination,
-        sessionId: this.sessionId
-      }, globalThis.location.origin);
-    });
-  }
-};
-var PostMessageRpcTransport = LegacyPostMessageRpcTransport;
-
 // src/transport/post-message/SessionEnvelope.ts
 var buildSessionMessageRequest = /* @__PURE__ */ __name((data, destination) => {
   const request = {
@@ -1248,7 +1463,7 @@ import { isArrayBuffer } from "@xylabs/arraybuffer";
 import { assertEx as assertEx3 } from "@xylabs/assert";
 import { AxiosJson as AxiosJson2 } from "@xylabs/axios";
 import { exists } from "@xylabs/exists";
-import { isDefined as isDefined2 } from "@xylabs/typeof";
+import { isDefined } from "@xylabs/typeof";
 import { isAnyPayload as isAnyPayload3 } from "@xyo-network/payload-model";
 import { isHashPayload as isHashPayload2 } from "@xyo-network/xl1-protocol";
 import { Axios } from "axios";
@@ -1291,14 +1506,14 @@ var HttpXyoDataLake = class extends AbstractXyoDataLake {
         const result = await this.addPayload(item);
         if (isAnyPayload3(result)) {
           results.push(result);
-        } else if (isDefined2(result)) {
+        } else if (isDefined(result)) {
           assertEx3(false, () => "Expected result to be a Payload");
         }
       } else if (isArrayBuffer(item)) {
         const result = await this.addArrayBuffer(item);
         if (isAnyPayload3(result)) {
           results.push(result);
-        } else if (isDefined2(result)) {
+        } else if (isDefined(result)) {
           assertEx3(false, () => "Expected result to be a Payload");
         }
       }
@@ -1511,7 +1726,7 @@ var MemoryXyoSigner = class {
 };
 
 // src/provider/viewer/JsonRpcXyoViewer.ts
-import { asAttoXL1 as asAttoXL12 } from "@xyo-network/xl1-protocol";
+import { asAttoXL1 as asAttoXL12, asHydratedBlock } from "@xyo-network/xl1-protocol";
 var JsonRpcXyoViewer = class {
   static {
     __name(this, "JsonRpcXyoViewer");
@@ -1531,20 +1746,22 @@ var JsonRpcXyoViewer = class {
     ]);
   }
   async blockByHash(hash) {
-    return await this.transport.sendRequest("xyoViewer_blockByHash", [
+    return asHydratedBlock(await this.transport.sendRequest("xyoViewer_blockByHash", [
       hash
-    ]);
+    ])) ?? null;
   }
   async blockByNumber(blockNumber) {
-    return await this.transport.sendRequest("xyoViewer_blockByNumber", [
+    return asHydratedBlock(await this.transport.sendRequest("xyoViewer_blockByNumber", [
       blockNumber
-    ]);
+    ])) ?? null;
   }
   async blocksByHash(hash, limit) {
-    return await this.transport.sendRequest("xyoViewer_blocksByHash", [
+    return (await this.transport.sendRequest("xyoViewer_blocksByHash", [
       hash,
       limit
-    ]);
+    ])).map((b) => asHydratedBlock(b, {
+      required: true
+    }));
   }
   async chainId() {
     return await this.transport.sendRequest("xyoViewer_chainId");
@@ -1555,7 +1772,9 @@ var JsonRpcXyoViewer = class {
     ]);
   }
   async currentBlock() {
-    return await this.transport.sendRequest("xyoViewer_currentBlock");
+    return asHydratedBlock(await this.transport.sendRequest("xyoViewer_currentBlock"), {
+      required: true
+    });
   }
   async currentBlockHash() {
     return await this.transport.sendRequest("xyoViewer_currentBlockHash");
@@ -1563,26 +1782,110 @@ var JsonRpcXyoViewer = class {
   async currentBlockNumber() {
     return await this.transport.sendRequest("xyoViewer_currentBlockNumber");
   }
-  forkHistory() {
-    throw new Error("Method not implemented.");
+  async forkHistory() {
+    return await this.transport.sendRequest("xyoViewer_forkHistory");
   }
-  async stakeByAddress(address, slot) {
-    return await this.transport.sendRequest("xyoViewer_stakeByAddress", [
-      address,
-      slot
+  async networkStakeStepRewardAddressHistory(address) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardAddressHistory", [
+      address
     ]);
   }
-  stakeById(_id) {
-    throw new Error("Method not implemented.");
+  async networkStakeStepRewardAddressReward(context, address) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardAddressReward", [
+      context,
+      address
+    ]);
   }
-  stakedByStaker(_staker) {
-    throw new Error("Method not implemented.");
+  async networkStakeStepRewardAddressShare(context, address) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardAddressShare", [
+      context,
+      address
+    ]);
   }
-  stakesByStaked(_staked) {
-    throw new Error("Method not implemented.");
+  async networkStakeStepRewardClaimedByAddress(address) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardClaimedByAddress", [
+      address
+    ]);
   }
-  stakesByStaker(_staker) {
-    throw new Error("Method not implemented.");
+  async networkStakeStepRewardForStep(context) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardForStep", [
+      context
+    ]);
+  }
+  async networkStakeStepRewardForStepForPosition(context, position) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardForStepForPosition", [
+      context,
+      position
+    ]);
+  }
+  async networkStakeStepRewardPoolRewards(context) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPoolRewards", [
+      context
+    ]);
+  }
+  async networkStakeStepRewardPoolShares(context) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPoolShares", [
+      context
+    ]);
+  }
+  async networkStakeStepRewardPositionWeight(context, position) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPositionWeight", [
+      context,
+      position
+    ]);
+  }
+  async networkStakeStepRewardPotentialPositionLoss(context, position) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardPotentialPositionLoss", [
+      context,
+      position
+    ]);
+  }
+  async networkStakeStepRewardRandomizer(context) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardRandomizer", [
+      context
+    ]);
+  }
+  async networkStakeStepRewardStakerCount(context) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardStakerCount", [
+      context
+    ]);
+  }
+  async networkStakeStepRewardUnclaimedByAddress(address) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardUnclaimedByAddress", [
+      address
+    ]);
+  }
+  async networkStakeStepRewardWeightForAddress(context, address) {
+    return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardWeightForAddress", [
+      context,
+      address
+    ]);
+  }
+  async stakeById(id) {
+    return await this.transport.sendRequest("xyoViewer_stakeById", [
+      id
+    ]);
+  }
+  async stakeByStaker(staker, slot) {
+    return await this.transport.sendRequest("xyoViewer_stakeByStaker", [
+      staker,
+      slot
+    ]);
+  }
+  async stakedByStaker(staker) {
+    return await this.transport.sendRequest("xyoViewer_stakedByStaker", [
+      staker
+    ]);
+  }
+  async stakesByStaked(staked) {
+    return await this.transport.sendRequest("xyoViewer_stakesByStaked", [
+      staked
+    ]);
+  }
+  async stakesByStaker(staker) {
+    return await this.transport.sendRequest("xyoViewer_stakesByStaker", [
+      staker
+    ]);
   }
   async transactionByBlockHashAndIndex(blockHash, transactionIndex) {
     return await this.transport.sendRequest("xyoViewer_transactionByBlockHashAndIndex", [
@@ -1601,6 +1904,26 @@ var JsonRpcXyoViewer = class {
       transactionHash
     ]);
   }
+  async transferBalance(address) {
+    return asAttoXL12(await this.transport.sendRequest("xyoViewer_transferBalance", [
+      address
+    ]));
+  }
+  async transferBalanceHistory(address) {
+    return await this.transport.sendRequest("xyoViewer_transferBalanceHistory", [
+      address
+    ]);
+  }
+  async transferPairBalance(address) {
+    return asAttoXL12(await this.transport.sendRequest("xyoViewer_transferPairBalance", [
+      address
+    ]));
+  }
+  async transferPairBalanceHistory(address) {
+    return await this.transport.sendRequest("xyoViewer_transferPairBalanceHistory", [
+      address
+    ]);
+  }
 };
 
 // src/provider/connection/XyoBaseConnection.ts
@@ -1685,7 +2008,7 @@ var HttpRpcXyoConnection = class extends XyoBaseConnection {
   }
   constructor(params) {
     const { account, endpoint, storage: storageParam } = params;
-    const signer = isDefined3(account) ? new MemoryXyoSigner(account) : void 0;
+    const signer = isDefined2(account) ? new MemoryXyoSigner(account) : void 0;
     const transport = new HttpRpcTransport(endpoint, {
       ...XyoRunnerRpcSchemas,
       ...XyoViewerRpcSchemas
@@ -1838,6 +2161,123 @@ var MemoryXyoNetwork = class {
     }
   }
 };
+
+// src/provider/permissions/MemoryXyoPermissions.ts
+import { assertEx as assertEx7 } from "@xylabs/assert";
+var MemoryXyoPermissions = class {
+  static {
+    __name(this, "MemoryXyoPermissions");
+  }
+  invoker;
+  _store;
+  constructor(store) {
+    this._store = store;
+    this.invoker = store.invoker;
+  }
+  get store() {
+    return assertEx7(this._store, () => "Store must be defined to get permissions");
+  }
+  async getPermissions() {
+    return await this.store.getPermissions();
+  }
+  // assumed the permissions are always granted
+  async requestPermissions(permissions) {
+    await Promise.resolve();
+    const newPermissions = [];
+    const now = Date.now();
+    for (const req of permissions) {
+      for (const parentCapability in req) {
+        newPermissions.push({
+          invoker: this.invoker,
+          parentCapability,
+          caveats: Object.entries(req[parentCapability]).map(([type, value]) => ({
+            type,
+            value
+          })),
+          date: now
+        });
+      }
+    }
+    const existingPermissions = await this.getPermissions();
+    for (const perm of newPermissions) {
+      const idx = existingPermissions.findIndex((p) => p.invoker === perm.invoker && p.parentCapability === perm.parentCapability);
+      if (idx === -1) {
+        existingPermissions.push(perm);
+      } else {
+        existingPermissions[idx] = perm;
+      }
+    }
+    await this.store.setPermissions(existingPermissions);
+    return newPermissions.map(({ parentCapability, date }) => ({
+      parentCapability,
+      date
+    }));
+  }
+  // Assumes the permissions are always revoked
+  async revokePermissions(permissions) {
+    const existingPermissions = await this.getPermissions();
+    const revoked = [];
+    for (const parentCapability in permissions) {
+      const idx = existingPermissions.findIndex((p) => p.invoker === this.invoker && p.parentCapability === parentCapability);
+      if (idx !== -1) {
+        const removed = existingPermissions.splice(idx, 1)[0];
+        revoked.push({
+          parentCapability: removed.parentCapability,
+          date: removed.date
+        });
+      }
+    }
+    await this.store.setPermissions(existingPermissions);
+    return revoked;
+  }
+};
+
+// src/provider/permissions/RpcXyoPermissions.ts
+var RpcXyoPermissions = class {
+  static {
+    __name(this, "RpcXyoPermissions");
+  }
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async getPermissions() {
+    return await this.transport.sendRequest("xyoPermissions_getPermissions", []);
+  }
+  async requestPermissions(permissions) {
+    return await this.transport.sendRequest("xyoPermissions_requestPermissions", [
+      permissions
+    ]);
+  }
+  async revokePermissions(_permissions) {
+    await Promise.resolve();
+    throw new Error("Method not implemented.");
+  }
+};
+
+// src/provider/permissions/store/MemoryPermissions.ts
+import { assertEx as assertEx8 } from "@xylabs/assert";
+var MemoryPermissionsStore = class {
+  static {
+    __name(this, "MemoryPermissionsStore");
+  }
+  _invoker;
+  permissions = [];
+  constructor(invoker) {
+    this._invoker = invoker;
+  }
+  get invoker() {
+    return assertEx8(this._invoker, () => "Invoker must be defined to get permissions");
+  }
+  async getPermissions() {
+    await Promise.resolve();
+    return this.permissions;
+  }
+  async setPermissions(permissions) {
+    await Promise.resolve();
+    this.permissions = permissions;
+  }
+};
 export {
   AbstractXyoDataLake,
   AbstractXyoGateway,
@@ -1862,7 +2302,6 @@ export {
   BoundWitnessZod,
   CaveatTypesZod,
   CaveatsZod,
-  ChainConnectionZod,
   ChainZod,
   HttpRpcTransport,
   HttpRpcXyoConnection,
@@ -1879,7 +2318,6 @@ export {
   JsonToAttoZod,
   JsonToSignedHydratedTransactionZod,
   JsonToStakeZod,
-  LegacyPostMessageRpcTransport,
   LocalSequenceFromStringZod,
   LocalSequenceToStringZod,
   MemoryPermissionsStore,
@@ -1887,6 +2325,7 @@ export {
   MemoryXyoClient,
   MemoryXyoGateway,
   MemoryXyoNetwork,
+  MemoryXyoPermissions,
   MemoryXyoRunner,
   MemoryXyoSigner,
   NodeXyoRunner,
@@ -1894,11 +2333,11 @@ export {
   PayloadZod,
   PermissionRequestZod,
   PermissionZod,
-  PostMessageRpcTransport,
   QualifiedSequenceFromStringZod,
   QualifiedSequenceToStringZod,
   RequestedPermissionZod,
   RpcXyoConnection,
+  RpcXyoPermissions,
   RpcXyoSigner,
   SchemaZod,
   SequenceFromStringZod,
@@ -1915,19 +2354,22 @@ export {
   SignedTransactionBoundWitnessZod,
   StakeToJsonZod,
   StakeZod,
+  StepContextZod,
   StorageMetaZod,
   TransactionBoundWitnessZod,
   TransactionFeesBigIntToJsonZod,
   TransactionFeesBigIntZod,
   TransactionFeesHexZod,
   TransactionFeesJsonToBigIntZod,
+  TransferFieldsZod,
+  TransferZod,
   UnsignedBoundWitnessWithStorageMetaZod,
   UnsignedBoundWitnessZod,
   UnsignedHydratedTransactionZod,
   WithStorageMetaZod,
   WithTransactionFeesZod,
   XyoBaseConnection,
-  XyoGatewayRpcSchemas,
+  XyoPermissionsRpcSchemas,
   XyoProviderRpcSchemas,
   XyoRunnerRpcSchemas,
   XyoSignerRpcSchemas,
@@ -1935,9 +2377,9 @@ export {
   buildSessionMessageRequest,
   createRequestSchema,
   createResponseSchema,
-  getPermissionsStoreFromTransport,
   jsonrpc,
   requestSchemas,
-  rpcMethodHandlersFromConnection
+  rpcMethodHandlersFromConnection,
+  rpcMethodHandlersFromPermissions
 };
 //# sourceMappingURL=index.mjs.map