@xyo-network/xl1-rpc 2.2.0 → 2.2.1

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(