@xyo-network/xl1-rpc 1.24.28 → 1.24.30

package/dist/neutral/index.mjs

@@ -950,27 +950,29 @@ 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 { SignedHydratedTransactionWithHashMetaZod as SignedHydratedTransactionWithHashMetaZod2 } from "@xyo-network/xl1-protocol";
 import { z as z16 } from "zod";
 var TransactionViewerRpcSchemas = {
+  /** @deprecated use byBlockHashAndIndex instead */
   transactionViewer_transactionByBlockHashAndIndex: {
     params: {
       to: z16.tuple([HashZod4, z16.number()]),
       from: z16.tuple([HashZod4, z16.number()])
     },
     result: {
-      to: SignedHydratedTransactionZod2.nullable(),
-      from: SignedHydratedTransactionZod2.nullable()
+      to: SignedHydratedTransactionWithHashMetaZod2.nullable(),
+      from: SignedHydratedTransactionWithHashMetaZod2.nullable()
     }
   },
+  /** @deprecated use byBlockNumberAndIndex instead */
   transactionViewer_transactionByBlockNumberAndIndex: {
     params: {
       to: z16.tuple([z16.number(), z16.number()]),
       from: z16.tuple([z16.number(), z16.number()])
     },
     result: {
-      to: SignedHydratedTransactionZod2.nullable(),
-      from: SignedHydratedTransactionZod2.nullable()
+      to: SignedHydratedTransactionWithHashMetaZod2.nullable(),
+      from: SignedHydratedTransactionWithHashMetaZod2.nullable()
     }
   },
   transactionViewer_byHash: {
@@ -979,18 +981,19 @@ var TransactionViewerRpcSchemas = {
       from: z16.tuple([HashZod4])
     },
     result: {
-      to: SignedHydratedTransactionZod2.nullable(),
-      from: SignedHydratedTransactionZod2.nullable()
+      to: SignedHydratedTransactionWithHashMetaZod2.nullable(),
+      from: SignedHydratedTransactionWithHashMetaZod2.nullable()
     }
   },
+  /** @deprecated use byHash instead */
   transactionViewer_transactionByHash: {
     params: {
       to: z16.tuple([HashZod4]),
       from: z16.tuple([HashZod4])
     },
     result: {
-      to: SignedHydratedTransactionZod2.nullable(),
-      from: SignedHydratedTransactionZod2.nullable()
+      to: SignedHydratedTransactionWithHashMetaZod2.nullable(),
+      from: SignedHydratedTransactionWithHashMetaZod2.nullable()
     }
   }
 };
@@ -1037,13 +1040,13 @@ var XyoPermissionsRpcSchemas = {
 
 // src/types/schema/XyoRunnerRpcSchemas.ts
 import { HashToJsonZod, JsonToHashZod } from "@xylabs/sdk-js";
-import { SignedHydratedTransactionZod as SignedHydratedTransactionZod3 } from "@xyo-network/xl1-protocol";
+import { SignedHydratedTransactionZod as SignedHydratedTransactionZod2 } from "@xyo-network/xl1-protocol";
 import { z as z18 } from "zod";
 var XyoRunnerRpcSchemas = {
   xyoRunner_broadcastTransaction: {
     params: {
-      to: z18.tuple([SignedHydratedTransactionZod3]),
-      from: z18.tuple([SignedHydratedTransactionZod3])
+      to: z18.tuple([SignedHydratedTransactionZod2]),
+      from: z18.tuple([SignedHydratedTransactionZod2])
     },
     result: {
       to: HashToJsonZod,
@@ -1054,7 +1057,7 @@ 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 { SignedHydratedTransactionWithHashMetaZod as SignedHydratedTransactionWithHashMetaZod3, UnsignedHydratedTransactionZod } from "@xyo-network/xl1-protocol";
 import { z as z19 } from "zod";
 var XyoSignerRpcSchemas = {
   xyoSigner_address: {
@@ -1073,8 +1076,8 @@ var XyoSignerRpcSchemas = {
       from: z19.tuple([UnsignedHydratedTransactionZod])
     },
     result: {
-      to: SignedHydratedTransactionWithHashMetaZod2,
-      from: SignedHydratedTransactionWithHashMetaZod2
+      to: SignedHydratedTransactionWithHashMetaZod3,
+      from: SignedHydratedTransactionWithHashMetaZod3
     }
   }
 };
@@ -1093,7 +1096,7 @@ import {
   asAttoXL1 as asAttoXL16,
   JsonToStakeZod as JsonToStakeZod3,
   SignedHydratedBlockWithHashMetaZod as SignedHydratedBlockWithHashMetaZod3,
-  SignedHydratedTransactionZod as SignedHydratedTransactionZod4,
+  SignedHydratedTransactionZod as SignedHydratedTransactionZod3,
   StakeToJsonZod as StakeToJsonZod3,
   StepIdentityZod as StepIdentityZod2,
   XL1BlockNumberZod as XL1BlockNumberZod2,
@@ -1387,8 +1390,8 @@ var XyoViewerRpcSchemas = {
       from: z20.tuple([HashZod5, z20.number()])
     },
     result: {
-      to: SignedHydratedTransactionZod4.nullable(),
-      from: SignedHydratedTransactionZod4.nullable()
+      to: SignedHydratedTransactionZod3.nullable(),
+      from: SignedHydratedTransactionZod3.nullable()
     }
   },
   xyoViewer_transactionByBlockNumberAndIndex: {
@@ -1397,8 +1400,8 @@ var XyoViewerRpcSchemas = {
       from: z20.tuple([z20.number(), z20.number()])
     },
     result: {
-      to: SignedHydratedTransactionZod4.nullable(),
-      from: SignedHydratedTransactionZod4.nullable()
+      to: SignedHydratedTransactionZod3.nullable(),
+      from: SignedHydratedTransactionZod3.nullable()
     }
   },
   xyoViewer_transactionByHash: {
@@ -1407,8 +1410,8 @@ var XyoViewerRpcSchemas = {
       from: z20.tuple([HashZod5])
     },
     result: {
-      to: SignedHydratedTransactionZod4.nullable(),
-      from: SignedHydratedTransactionZod4.nullable()
+      to: SignedHydratedTransactionZod3.nullable(),
+      from: SignedHydratedTransactionZod3.nullable()
     }
   },
   xyoViewer_payloadsByHash: {
@@ -1490,8 +1493,7 @@ import { creatableProvider } from "@xyo-network/xl1-protocol-sdk";
 import { AccountBalanceViewerMoniker } from "@xyo-network/xl1-protocol";
 
 // src/provider/viewer/JsonRpcViewer.ts
-import { isDefined as isDefined2 } from "@xylabs/sdk-js";
-import { AbstractCreatableProvider } from "@xyo-network/xl1-protocol-sdk";
+import { AbstractCreatableProvider, HttpRpcRemoteConfigZod } from "@xyo-network/xl1-protocol-sdk";
 
 // src/transport/HttpRpcTransport.ts
 import {
@@ -1588,6 +1590,151 @@ var MemoryRpcTransport = class {
   }
 };
 
+// src/transport/PostMessage/bus/Abstract.ts
+import { isDefined as isDefined2 } from "@xylabs/sdk-js";
+var AbstractMessageBus = class {
+  connections = [];
+  name;
+  sessionId;
+  constructor(sessionId, name = "default") {
+    this.name = name;
+    this.sessionId = sessionId;
+    this.start();
+  }
+  addConnection(connection) {
+    this.connections.push(connection);
+  }
+  removeConnection(connection) {
+    this.connections = this.connections.filter((c) => c !== connection);
+  }
+  validateSessionId(sessionId) {
+    return isDefined2(this.sessionId) && sessionId === this.sessionId;
+  }
+};
+
+// src/transport/PostMessage/bus/implementations/PostMessage.ts
+import { isDefined as isDefined3 } from "@xylabs/sdk-js";
+
+// src/transport/PostMessage/bus/validators/hasSessionId.ts
+var hasSessionId = (message) => {
+  return typeof message === "object" && message !== null && "sessionId" in message && typeof message.sessionId === "string";
+};
+
+// src/transport/PostMessage/bus/validators/isEventWithId.ts
+var isEventWithId = (event) => {
+  return typeof event === "object" && event !== null && "data" in event && typeof event.data === "object" && event.data !== null && "data" in event.data && typeof event.data.data === "object" && event.data.data !== null && "id" in event.data.data && typeof event.data.data.id === "string";
+};
+
+// src/transport/PostMessage/bus/validators/isMessageWithId.ts
+var isMessageWithId = (message) => {
+  return typeof message === "object" && message !== null && "data" in message && typeof message.data === "object" && message.data !== null && "id" in message.data && typeof message.data.id === "string";
+};
+
+// src/transport/PostMessage/bus/implementations/PostMessage.ts
+var PostMessageBus = class extends AbstractMessageBus {
+  constructor(sessionId, name = "default") {
+    super(sessionId, name);
+  }
+  postMessage(message, origin = globalThis.location.origin) {
+    globalThis.postMessage(message, origin);
+  }
+  start() {
+    globalThis.addEventListener("message", (event) => this.handleMessage(event));
+  }
+  stop() {
+    globalThis.removeEventListener("message", this.handleMessage);
+    this.connections.length = 0;
+  }
+  handleMessage = (event) => {
+    if (event.origin !== globalThis.location.origin) return;
+    if (!this.validateSessionId(event.data?.sessionId)) return;
+    for (const connection of this.connections) {
+      const { id, listener } = connection;
+      if (isDefined3(id) && isEventWithId(event)) {
+        const eventWithId = event;
+        if (eventWithId.data.data.id === id) listener(event);
+      } else {
+        listener(event);
+      }
+    }
+  };
+};
+
+// src/transport/PostMessage/PostMessageRpcTransport.ts
+import {
+  isJsonRpcFailure,
+  isJsonRpcResponse,
+  isJsonRpcSuccess
+} from "@metamask/utils";
+import { isDefined as isDefined4 } from "@xylabs/sdk-js";
+import { v4 as v43 } from "uuid";
+var PostMessageRpcTransport = class {
+  _destination;
+  _logger;
+  _schemas;
+  _sessionId;
+  constructor(defaultDestination, schemas, sessionId, logger) {
+    this._schemas = schemas;
+    this._destination = defaultDestination;
+    this._logger = logger;
+    this._sessionId = sessionId;
+  }
+  get destination() {
+    return this._destination;
+  }
+  get logger() {
+    return this._logger;
+  }
+  get schemas() {
+    return this._schemas;
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  async sendRequest(method, params) {
+    const id = v43();
+    return await this.callRpc(this.schemas, method, id, params);
+  }
+  async callRpc(schemas, method, id, params) {
+    this.logger?.log(`PostMessageRpcTransport: callRpc method=${String(method)} id=${id}`);
+    const body = {
+      jsonrpc,
+      id,
+      method,
+      params: isDefined4(params) && isDefined4(schemas[method]) ? schemas[method].params.to.parse(params) : params
+    };
+    return await new Promise((resolve, reject) => {
+      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)) {
+              console.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
+      };
+      postMessageBus.addConnection(postMessageConnection);
+      const message = {
+        data: body,
+        destination: this.destination,
+        sessionId: this.sessionId ?? ""
+      };
+      postMessageBus.postMessage(message);
+    });
+  }
+};
+
 // src/provider/viewer/JsonRpcViewer.ts
 var AbstractJsonRpcViewer = class extends AbstractCreatableProvider {
   _transport;
@@ -1599,9 +1746,10 @@ var AbstractJsonRpcViewer = class extends AbstractCreatableProvider {
     await super.createHandler();
   }
   createTransport() {
-    const endpoint = this.config.remote.rpc?.url;
-    if (isDefined2(endpoint)) {
-      return new HttpRpcTransport(endpoint, this.schemas());
+    const httpRemoteConfig = HttpRpcRemoteConfigZod.safeParse(this.config.remote);
+    if (httpRemoteConfig.success) {
+      const { url } = httpRemoteConfig.data.rpc;
+      return new HttpRpcTransport(url, this.schemas());
     }
     throw new Error("Unable to create transport");
   }
@@ -1665,7 +1813,7 @@ import {
 } from "@xyo-network/xl1-protocol-sdk";
 
 // src/provider/viewer/JsonRpcBlockViewer/JsonRpcBlockViewerMethods.ts
-import { isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { isDefined as isDefined5 } from "@xylabs/sdk-js";
 import { BlockViewerMoniker, DataLakeViewerMoniker } from "@xyo-network/xl1-protocol";
 import { addDataLakePayloads, addDataLakePayloadsToPayloads } from "@xyo-network/xl1-protocol-sdk";
 var JsonRpcBlockViewerMethods = class extends AbstractJsonRpcViewer {
@@ -1674,14 +1822,14 @@ var JsonRpcBlockViewerMethods = class extends AbstractJsonRpcViewer {
   async blocksByHash(hash, limit) {
     const result = await this.transport.sendRequest(
       "blockViewer_blocksByHash",
-      isDefined3(limit) ? [hash, limit] : [hash]
+      isDefined5(limit) ? [hash, limit] : [hash]
     );
     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]
+      isDefined5(limit) ? [block, limit] : [block]
     );
     return await Promise.all(result.map(async (block2) => (await addDataLakePayloads(block2, this.dataLakeViewer))[0]));
   }
@@ -2407,8 +2555,7 @@ import { creatableProvider as creatableProvider13 } from "@xyo-network/xl1-proto
 import { MempoolRunnerMoniker } from "@xyo-network/xl1-protocol";
 
 // src/provider/runner/JsonRpcRunner.ts
-import { isDefined as isDefined4 } from "@xylabs/sdk-js";
-import { AbstractCreatableProvider as AbstractCreatableProvider2 } from "@xyo-network/xl1-protocol-sdk";
+import { AbstractCreatableProvider as AbstractCreatableProvider2, HttpRpcRemoteConfigZod as HttpRpcRemoteConfigZod2 } from "@xyo-network/xl1-protocol-sdk";
 var AbstractJsonRpcRunner = class extends AbstractCreatableProvider2 {
   get transport() {
     return this.params.transport;
@@ -2418,9 +2565,10 @@ var AbstractJsonRpcRunner = class extends AbstractCreatableProvider2 {
     await super.createHandler();
   }
   createTransport() {
-    const endpoint = this.config.remote.rpc?.url;
-    if (isDefined4(endpoint)) {
-      return new HttpRpcTransport(endpoint, this.schemas());
+    const httpRemoteConfig = HttpRpcRemoteConfigZod2.safeParse(this.config.remote);
+    if (httpRemoteConfig.success) {
+      const { url } = httpRemoteConfig.data.rpc;
+      return new HttpRpcTransport(url, this.schemas());
     }
     throw new Error("Unable to create transport");
   }
@@ -2584,6 +2732,7 @@ var JsonRpcXyoSigner = class extends JsonRpcXyoSignerMethods {
 export {
   AbstractJsonRpcRunner,
   AbstractJsonRpcViewer,
+  AbstractMessageBus,
   AccountBalanceViewerRpcSchemas,
   AllRpcSchemas,
   BlockViewerRpcSchemas,
@@ -2635,6 +2784,8 @@ export {
   NetworkStakingStepRewardsViewerRpcSchemas,
   NoArgsZod,
   NodeXyoRunner,
+  PostMessageBus,
+  PostMessageRpcTransport,
   RpcXyoPermissions,
   StakeTotalsViewerRpcSchemas,
   StakeViewerRpcSchemas,
@@ -2646,6 +2797,9 @@ export {
   XyoViewerRpcSchemas,
   createRequestSchema,
   createResponseSchema,
+  hasSessionId,
+  isEventWithId,
+  isMessageWithId,
   jsonrpc,
   requestSchemas,
   rpcMethodHandlersFromAccountBalanceViewer,