@xyo-network/xl1-rpc 2.2.0 → 3.0.0

package/dist/neutral/engine-node/middleware/RpcContext.d.ts

@@ -18,7 +18,7 @@ export type RpcContext = MiddlewareContext<RpcContextKeyValues>;
 /**
  * Middleware shape used throughout the RPC engine. We only handle
  * {@link JsonRpcRequest}s (no notifications), so Result is constrained to
- * {@link Json}. This matches what `createScaffoldMiddleware` and a sub-engine
+ * {@link JSON}. This matches what `createScaffoldMiddleware` and a sub-engine
  * built purely from request-handling middleware will produce.
  */
 export type RpcMiddleware = JsonRpcMiddleware<JsonRpcRequest, Json, RpcContext>;

package/dist/neutral/index.mjs

@@ -1604,14 +1604,15 @@ var HttpRpcTransport = class {
         method
       };
       const schema = schemas[method];
-      if (params) {
+      if (params !== void 0) {
         body.params = isDefined(schema) ? schema.params.to.parse(params) : this._passThrough ? z25.json().parse(params) : void 0;
         if (!isDefined(body.params)) {
           throw new Error(`[callRpc] RPC method ${String(method)} missing schema`);
         }
       }
       body.params ??= [];
-      const res = await new FetchJsonClient().post(url, body);
+      const client = new FetchJsonClient();
+      const res = await client.post(url, body);
       const json = res.data;
       if (isUndefinedOrNull(json)) {
         throw new Error(`[callRpc] empty response body (status ${res.status})`);
@@ -1718,22 +1719,33 @@ var isMessageWithId = (message) => {
 };
 
 // src/transport/PostMessage/bus/implementations/PostMessage.ts
+function browserWindow() {
+  return globalThis;
+}
+function deliverPostMessage(message, targetOrigin, transfer) {
+  const win = browserWindow();
+  if (typeof win.postMessage !== "function") {
+    throw new TypeError("postMessage is only available in browser environments");
+  }
+  const postMessageFn = win.postMessage;
+  postMessageFn.call(win, message, targetOrigin, transfer);
+}
 var PostMessageBus = class extends AbstractMessageBus {
   constructor(sessionId, name = "default") {
     super(sessionId, name);
   }
-  postMessage(message, origin = globalThis.location.origin) {
-    globalThis.postMessage(message, origin);
+  postMessage(message, origin) {
+    deliverPostMessage(message, origin ?? browserWindow().location?.origin ?? "*");
   }
   start() {
-    globalThis.addEventListener("message", (event) => this.handleMessage(event));
+    addEventListener("message", (event) => this.handleMessage(event));
   }
   stop() {
-    globalThis.removeEventListener("message", this.handleMessage);
+    removeEventListener("message", this.handleMessage);
     this.connections.length = 0;
   }
   handleMessage = (event) => {
-    if (event.origin !== globalThis.location.origin) return;
+    if (event.origin !== browserWindow().location?.origin) return;
     if (!this.validateSessionId(event.data?.sessionId)) return;
     for (const connection of this.connections) {
       const { id, listener } = connection;
@@ -1794,20 +1806,21 @@ var PostMessageRpcTransport = class {
       const postMessageBus = new PostMessageBus(this.sessionId);
       const postMessageConnection = {
         listener: (event) => {
-          if ("data" in event.data && isJsonRpcResponse(event.data.data)) {
-            const response = event.data.data;
-            if (isJsonRpcSuccess(response) && Array.isArray(response.result)) {
-              const ret = schemas[method].result.from.parse(response.result[0]);
-              resolve(ret);
-              return;
-            }
-            if (isJsonRpcFailure(response)) {
-              this.logger?.error("Error in PostMessageRpcTransport", response);
-              reject(new Error(response.error.message));
-              return;
-            }
-            throw new Error(`Invalid response from wallet extension, ${JSON.stringify(event.data)}`);
+          if (!("data" in event.data) || !isJsonRpcResponse(event.data.data)) {
+            return;
+          }
+          const response = event.data.data;
+          if (isJsonRpcSuccess(response) && Array.isArray(response.result)) {
+            const ret = schemas[method].result.from.parse(response.result[0]);
+            resolve(ret);
+            return;
+          }
+          if (isJsonRpcFailure(response)) {
+            this.logger?.error("Error in PostMessageRpcTransport", response);
+            reject(new Error(response.error.message));
+            return;
           }
+          throw new Error(`Invalid response from wallet extension, ${JSON.stringify(event.data)}`);
         },
         id
       };
@@ -2070,25 +2083,32 @@ var JsonRpcBlockViewer = class extends JsonRpcBlockViewerMethods {
     };
   }
   async blockByHash(hash) {
-    return (await this.blocksByHash(hash, 1))[0];
+    const blocks = await this.blocksByHash(hash, 1);
+    return blocks[0];
   }
   async blockByNumber(block) {
-    return (await this.blocksByNumber(block, 1))[0];
+    const blocks = await this.blocksByNumber(block, 1);
+    return blocks[0];
   }
   async chainId(blockNumber = "latest") {
     if (blockNumber === "latest") {
-      return (await this.currentBlock())[0].chain;
+      const current = await this.currentBlock();
+      return current[0].chain;
     }
-    return (await this.blocksByNumber(blockNumber, 1))[0][0].chain;
+    const blocks = await this.blocksByNumber(blockNumber, 1);
+    return blocks[0][0].chain;
   }
   async currentBlockHash() {
-    return (await this.currentBlock())[0]._hash;
+    const block = await this.currentBlock();
+    return block[0]._hash;
   }
   async currentBlockNumber() {
-    return (await this.currentBlock())[0].block;
+    const block = await this.currentBlock();
+    return block[0].block;
   }
   async payloadByHash(hash) {
-    return (await this.payloadsByHash([hash]))[0] ?? null;
+    const payloads = await this.payloadsByHash([hash]);
+    return payloads[0] ?? null;
   }
   async rate(range, timeUnit) {
     return await calculateBlockRate(this, range, timeUnit);
@@ -2140,10 +2160,11 @@ var JsonRpcBlockViewer = class extends JsonRpcBlockViewerMethods {
     }, this.headPollIntervalMs);
   }
   stopHeadPolling() {
-    if (this._headPollTimer) {
-      clearInterval(this._headPollTimer);
-      this._headPollTimer = null;
+    if (!this._headPollTimer) {
+      return;
     }
+    clearInterval(this._headPollTimer);
+    this._headPollTimer = null;
   }
 };
 __publicField(JsonRpcBlockViewer, "defaultMoniker", BlockViewerMoniker2);
@@ -2176,16 +2197,20 @@ var JsonRpcFinalizationViewerMethods = class extends AbstractJsonRpcViewer {
 // src/provider/viewer/JsonRpcFinalizationViewer/JsonRpcFinalizationViewer.ts
 var JsonRpcFinalizationViewer = class extends JsonRpcFinalizationViewerMethods {
   async chainId() {
-    return (await this.headBlock()).chain;
+    const headBlock = await this.headBlock();
+    return headBlock.chain;
   }
   async headBlock() {
-    return (await this.head())[0];
+    const head = await this.head();
+    return head[0];
   }
   async headHash() {
-    return (await this.head())[0]._hash;
+    const head = await this.head();
+    return head[0]._hash;
   }
   async headNumber() {
-    return (await this.head())[0].block;
+    const head = await this.head();
+    return head[0].block;
   }
 };
 __publicField(JsonRpcFinalizationViewer, "defaultMoniker", FinalizationViewerMoniker2);
@@ -2602,28 +2627,33 @@ var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
     return await this.account.balance.accountBalanceHistory(address, config);
   }
   async blockByHash(hash) {
-    return (await this.blocksByHash(hash, 1))[0];
+    const blocks = await this.blocksByHash(hash, 1);
+    return blocks[0];
   }
   async blockByNumber(blockNumber) {
-    return (await this.blocksByNumber(blockNumber, 1))[0];
+    const blocks = await this.blocksByNumber(blockNumber, 1);
+    return blocks[0];
   }
   async blocksByHash(hash, limit) {
-    return await Promise.all((await this.transport.sendRequest(
+    const blocks = await this.transport.sendRequest(
       "xyoViewer_blocksByHash",
       [hash, limit]
-    )).map((b) => fixSignedHydratedBlockWithHashMeta(b)));
+    );
+    return await Promise.all(blocks.map((b) => fixSignedHydratedBlockWithHashMeta(b)));
   }
   async blocksByNumber(blockNumber, limit) {
-    return await Promise.all((await this.transport.sendRequest(
+    const blocks = await this.transport.sendRequest(
       "xyoViewer_blocksByNumber",
       [blockNumber, limit]
-    )).map((b) => fixSignedHydratedBlockWithHashMeta(b)));
+    );
+    return await Promise.all(blocks.map((b) => fixSignedHydratedBlockWithHashMeta(b)));
   }
   async blocksByStep(stepLevel, stepIndex) {
-    return await Promise.all((await this.transport.sendRequest(
+    const blocks = await this.transport.sendRequest(
       "xyoViewer_blocksByStep",
       [stepLevel, stepIndex]
-    )).map((b) => fixSignedHydratedBlockWithHashMeta(b)));
+    );
+    return await Promise.all(blocks.map((b) => fixSignedHydratedBlockWithHashMeta(b)));
   }
   async chainId(blockNumber = "latest") {
     const block = blockNumber === "latest" ? await this.currentBlock() : await this.blockByNumber(blockNumber);
@@ -2656,10 +2686,12 @@ var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
     return fixSignedHydratedBlockWithHashMeta(result);
   }
   async currentBlockHash() {
-    return (await this.currentBlock())[0]._hash;
+    const block = await this.currentBlock();
+    return block[0]._hash;
   }
   async currentBlockNumber() {
-    return (await this.currentBlock())[0].block;
+    const block = await this.currentBlock();
+    return block[0].block;
   }
   async forkHistory() {
     return await this.transport.sendRequest("xyoViewer_forkHistory");
@@ -2719,7 +2751,8 @@ var JsonRpcXyoViewer = class extends AbstractJsonRpcViewer {
     return await this.transport.sendRequest("xyoViewer_networkStakeStepRewardsForStepLevel", [stepLevel, range]);
   }
   async payloadByHash(hash) {
-    return (await this.payloadsByHash([hash]))[0] ?? null;
+    const payloads = await this.payloadsByHash([hash]);
+    return payloads[0] ?? null;
   }
   async payloadsByHash(hashes) {
     return await PayloadBuilder2.addHashMeta(await this.transport.sendRequest(
@@ -2780,130 +2813,103 @@ JsonRpcXyoViewer = __decorateClass([
 
 // src/networkTier3Descriptors.ts
 var passes = () => true;
-var nodeNetworkDescriptors = [
-  {
-    id: "JsonRpcBlockViewer",
-    satisfies: [JsonRpcBlockViewer.defaultMoniker],
-    tier: 3,
-    backings: [{ backing: "network", mode: "read" }],
-    surface: "node",
-    preconditions: passes,
-    build: () => JsonRpcBlockViewer.factory(JsonRpcBlockViewer.dependencies, {})
-  },
-  {
-    id: "JsonRpcMempoolViewer",
-    satisfies: [JsonRpcMempoolViewer.defaultMoniker],
-    tier: 3,
-    backings: [{ backing: "network", mode: "read" }],
-    surface: "node",
-    preconditions: passes,
-    build: () => JsonRpcMempoolViewer.factory(JsonRpcMempoolViewer.dependencies, {})
-  },
-  {
-    id: "JsonRpcMempoolRunner",
-    satisfies: [JsonRpcMempoolRunner.defaultMoniker],
-    tier: 3,
-    backings: [{ backing: "network", mode: "read" }],
-    surface: "node",
-    preconditions: passes,
-    build: () => JsonRpcMempoolRunner.factory(JsonRpcMempoolRunner.dependencies, {})
-  },
-  {
-    id: "JsonRpcFinalizationViewer",
-    satisfies: [JsonRpcFinalizationViewer.defaultMoniker],
-    tier: 3,
-    backings: [{ backing: "network", mode: "read" }],
-    surface: "node",
-    preconditions: passes,
-    build: () => JsonRpcFinalizationViewer.factory(JsonRpcFinalizationViewer.dependencies, {})
-  },
-  {
-    id: "JsonRpcAccountBalanceViewer",
-    satisfies: [JsonRpcAccountBalanceViewer.defaultMoniker],
-    tier: 3,
-    backings: [{ backing: "network", mode: "read" }],
-    // AccountBalanceViewer is a point query (`f(address) → balance`) — node-surface,
-    // even though indexer-backed today on the producer side.
-    surface: "node",
-    preconditions: passes,
-    build: () => JsonRpcAccountBalanceViewer.factory(JsonRpcAccountBalanceViewer.dependencies, {})
-  },
-  {
-    id: "JsonRpcTransactionViewer",
-    satisfies: [JsonRpcTransactionViewer.defaultMoniker],
-    tier: 3,
-    backings: [{ backing: "network", mode: "read" }],
-    surface: "node",
-    preconditions: passes,
-    build: () => JsonRpcTransactionViewer.factory(JsonRpcTransactionViewer.dependencies, {})
-  },
-  {
-    id: "JsonRpcTimeSyncViewer",
-    satisfies: [JsonRpcTimeSyncViewer.defaultMoniker],
-    tier: 3,
-    backings: [{ backing: "network", mode: "read" }],
-    surface: "node",
-    preconditions: passes,
-    build: () => JsonRpcTimeSyncViewer.factory(JsonRpcTimeSyncViewer.dependencies, {})
-  },
-  {
-    id: "JsonRpcXyoViewer",
-    satisfies: [JsonRpcXyoViewer.defaultMoniker],
-    tier: 3,
-    backings: [{ backing: "network", mode: "read" }],
-    surface: "node",
-    preconditions: passes,
-    build: () => JsonRpcXyoViewer.factory(JsonRpcXyoViewer.dependencies, {})
-  },
-  {
-    id: "JsonRpcXyoRunner",
-    satisfies: [JsonRpcXyoRunner.defaultMoniker],
-    tier: 3,
-    backings: [{ backing: "network", mode: "read" }],
-    surface: "node",
-    preconditions: passes,
-    build: () => JsonRpcXyoRunner.factory(JsonRpcXyoRunner.dependencies, {})
-  },
-  {
-    // StakeTotalsViewer.activeByStaked(addr) is a point query keyed by address — node-surface.
-    id: "JsonRpcStakeTotalsViewer",
-    satisfies: [JsonRpcStakeTotalsViewer.defaultMoniker],
-    tier: 3,
-    backings: [{ backing: "network", mode: "read" }],
-    surface: "node",
+function rpcDescriptor(id, moniker, surface, build, planDependencies = []) {
+  return {
+    id,
+    satisfies: [moniker],
+    connectionTypes: ["rpc"],
+    dependencies: planDependencies,
+    surface,
     preconditions: passes,
-    build: () => JsonRpcStakeTotalsViewer.factory(JsonRpcStakeTotalsViewer.dependencies, {})
-  }
+    build
+  };
+}
+var nodeNetworkDescriptors = [
+  rpcDescriptor(
+    "JsonRpcBlockViewer",
+    JsonRpcBlockViewer.defaultMoniker,
+    "node",
+    () => JsonRpcBlockViewer.factory(JsonRpcBlockViewer.dependencies, {})
+  ),
+  rpcDescriptor(
+    "JsonRpcMempoolViewer",
+    JsonRpcMempoolViewer.defaultMoniker,
+    "node",
+    () => JsonRpcMempoolViewer.factory(JsonRpcMempoolViewer.dependencies, {})
+  ),
+  rpcDescriptor(
+    "JsonRpcMempoolRunner",
+    JsonRpcMempoolRunner.defaultMoniker,
+    "node",
+    () => JsonRpcMempoolRunner.factory(JsonRpcMempoolRunner.dependencies, {})
+  ),
+  rpcDescriptor(
+    "JsonRpcFinalizationViewer",
+    JsonRpcFinalizationViewer.defaultMoniker,
+    "node",
+    () => JsonRpcFinalizationViewer.factory(JsonRpcFinalizationViewer.dependencies, {})
+  ),
+  rpcDescriptor(
+    "JsonRpcAccountBalanceViewer",
+    JsonRpcAccountBalanceViewer.defaultMoniker,
+    "node",
+    () => JsonRpcAccountBalanceViewer.factory(JsonRpcAccountBalanceViewer.dependencies, {})
+  ),
+  rpcDescriptor(
+    "JsonRpcTransactionViewer",
+    JsonRpcTransactionViewer.defaultMoniker,
+    "node",
+    () => JsonRpcTransactionViewer.factory(JsonRpcTransactionViewer.dependencies, {}),
+    [...JsonRpcTransactionViewer.dependencies]
+  ),
+  rpcDescriptor(
+    "JsonRpcTimeSyncViewer",
+    JsonRpcTimeSyncViewer.defaultMoniker,
+    "node",
+    () => JsonRpcTimeSyncViewer.factory(JsonRpcTimeSyncViewer.dependencies, {})
+  ),
+  rpcDescriptor(
+    "JsonRpcXyoViewer",
+    JsonRpcXyoViewer.defaultMoniker,
+    "node",
+    () => JsonRpcXyoViewer.factory(JsonRpcXyoViewer.dependencies, {})
+  ),
+  rpcDescriptor(
+    "JsonRpcXyoRunner",
+    JsonRpcXyoRunner.defaultMoniker,
+    "node",
+    () => JsonRpcXyoRunner.factory(JsonRpcXyoRunner.dependencies, {}),
+    [...JsonRpcXyoRunner.dependencies]
+  ),
+  rpcDescriptor(
+    "JsonRpcStakeTotalsViewer",
+    JsonRpcStakeTotalsViewer.defaultMoniker,
+    "node",
+    () => JsonRpcStakeTotalsViewer.factory(JsonRpcStakeTotalsViewer.dependencies, {})
+  )
 ];
 var indexedNetworkDescriptors = [
-  {
-    id: "JsonRpcStakeViewer",
-    satisfies: [JsonRpcStakeViewer.defaultMoniker],
-    tier: 3,
-    backings: [{ backing: "network", mode: "read" }],
-    // StakeViewer.stakesByStaker(addr) / stakesByStaked() are cross-key reverse indexes — indexed.
-    surface: "indexed",
-    preconditions: passes,
-    build: () => JsonRpcStakeViewer.factory(JsonRpcStakeViewer.dependencies, {})
-  },
-  {
-    id: "JsonRpcNetworkStakeViewer",
-    satisfies: [JsonRpcNetworkStakeViewer.defaultMoniker],
-    tier: 3,
-    backings: [{ backing: "network", mode: "read" }],
-    surface: "indexed",
-    preconditions: passes,
-    build: () => JsonRpcNetworkStakeViewer.factory(JsonRpcNetworkStakeViewer.dependencies, {})
-  },
-  {
-    id: "JsonRpcNetworkStakeStepRewardsViewer",
-    satisfies: [JsonRpcNetworkStakeStepRewardsViewer.defaultMoniker],
-    tier: 3,
-    backings: [{ backing: "network", mode: "read" }],
-    surface: "indexed",
-    preconditions: passes,
-    build: () => JsonRpcNetworkStakeStepRewardsViewer.factory(JsonRpcNetworkStakeStepRewardsViewer.dependencies, {})
-  }
+  rpcDescriptor(
+    "JsonRpcStakeViewer",
+    JsonRpcStakeViewer.defaultMoniker,
+    "indexed",
+    () => JsonRpcStakeViewer.factory(JsonRpcStakeViewer.dependencies, {})
+  ),
+  rpcDescriptor(
+    "JsonRpcNetworkStakeViewer",
+    JsonRpcNetworkStakeViewer.defaultMoniker,
+    "indexed",
+    () => JsonRpcNetworkStakeViewer.factory(JsonRpcNetworkStakeViewer.dependencies, {})
+  ),
+  rpcDescriptor(
+    "JsonRpcNetworkStakeStepRewardsViewer",
+    JsonRpcNetworkStakeStepRewardsViewer.defaultMoniker,
+    "indexed",
+    () => JsonRpcNetworkStakeStepRewardsViewer.factory(
+      JsonRpcNetworkStakeStepRewardsViewer.dependencies,
+      {}
+    )
+  )
 ];
 var networkTier3Descriptors = [
   ...nodeNetworkDescriptors,