@xyo-network/xl1-rpc 1.7.11 → 1.7.13

package/dist/node/index-node.mjs

@@ -15,7 +15,8 @@ var rpcMethodHandlersFromRunner = /* @__PURE__ */ __name((runner) => {
 var rpcMethodHandlersFromSigner = /* @__PURE__ */ __name((signer) => {
   return {
     xyoSigner_address: /* @__PURE__ */ __name((params) => signer.address(...params ?? []), "xyoSigner_address"),
-    xyoSigner_createSignedTransaction: /* @__PURE__ */ __name((params) => signer.createSignedTransaction(...params ?? []), "xyoSigner_createSignedTransaction")
+    xyoSigner_createSignedTransaction: /* @__PURE__ */ __name((params) => signer.createSignedTransaction(...params ?? []), "xyoSigner_createSignedTransaction"),
+    xyoSigner_signTransaction: /* @__PURE__ */ __name((params) => signer.signTransaction(...params ?? []), "xyoSigner_signTransaction")
   };
 }, "rpcMethodHandlersFromSigner");
 
@@ -362,6 +363,20 @@ var XyoSignerRpcSchemas = {
       to: SignedTransactionBoundWitnessSchema,
       from: SignedTransactionBoundWitnessSchema
     }
+  },
+  xyoSigner_signTransaction: {
+    params: {
+      to: z16.tuple([
+        HydratedTransactionSchema
+      ]),
+      from: z16.tuple([
+        HydratedTransactionSchema
+      ])
+    },
+    result: {
+      to: SignedHydratedTransactionSchema,
+      from: SignedHydratedTransactionSchema
+    }
   }
 };
 
@@ -746,7 +761,7 @@ var rpcEngineFromProvider = /* @__PURE__ */ __name((provider) => {
   return engine;
 }, "rpcEngineFromProvider");
 
-// src/provider/host/JsonRpcXyoGateway.ts
+// src/provider/host/Abstract.ts
 import { assertEx } from "@xylabs/assert";
 var AbstractXyoGateway = class {
   static {
@@ -756,6 +771,8 @@ var AbstractXyoGateway = class {
     return assertEx(assertEx(await this.activeConnection(), () => "No active connection available for transaction submission").submitTransaction, () => "Active connection does not support transaction submission")(elevatedPayloads, additionalPayloads);
   }
 };
+
+// src/provider/host/JsonRpcXyoGateway.ts
 var JsonRpcXyoGateway = class extends AbstractXyoGateway {
   static {
     __name(this, "JsonRpcXyoGateway");
@@ -785,77 +802,8 @@ var JsonRpcXyoGateway = class extends AbstractXyoGateway {
   }
 };
 
-// src/provider/network/MemoryXyoNetwork.ts
-import { isUndefined } from "@xylabs/typeof";
-import { isNetworkStatus } from "@xyo-network/xl1-protocol";
-import axios from "axios";
-
-// src/provider/network/lib/FailedNetworkStatusPayloads.ts
-import { NetworkStatusSchema } from "@xyo-network/xl1-protocol";
-var unknownStatus = {
-  description: "Unknown Network Status",
-  schema: NetworkStatusSchema,
-  state: "unknown"
-};
-var errorStatus = {
-  description: "Error Fetching Network Status",
-  schema: NetworkStatusSchema,
-  state: "unknown"
-};
-
-// src/provider/network/lib/StatusNetworks.ts
-var MainNetworkStats = {
-  id: "mainnet",
-  statusUrl: "https://xyo.network/chain-network-status-mainnet.json"
-};
-var SequenceNetworkStats = {
-  id: "sequence",
-  statusUrl: "https://beta.xyo.network/chain-network-status-sequence.json"
-};
-var LocalNetworkStats = {
-  id: "local",
-  statusUrl: "http://localhost:3002/chain-network-status-local.json"
-};
-var StatusNetworks = {
-  mainnet: MainNetworkStats,
-  sequence: SequenceNetworkStats,
-  local: LocalNetworkStats
-};
-
-// src/provider/network/MemoryXyoNetwork.ts
-var MemoryXyoNetwork = class {
-  static {
-    __name(this, "MemoryXyoNetwork");
-  }
-  _networkId;
-  constructor(networkId) {
-    this._networkId = networkId;
-  }
-  async status() {
-    const statusNetwork = StatusNetworks[this._networkId];
-    if (isUndefined(statusNetwork)) {
-      throw new Error(`Unknown status network ID: ${this._networkId}`);
-    }
-    return await this.makeRequest(statusNetwork.statusUrl);
-  }
-  async makeRequest(url) {
-    try {
-      const response = await axios.get(url);
-      if (isNetworkStatus(response.data)) {
-        return response.data;
-      } else {
-        if (response.status === 200) {
-          console.error("Unknown network status response:", response.data);
-          return unknownStatus;
-        }
-        return errorStatus;
-      }
-    } catch (error) {
-      console.error("Error fetching network status:", error);
-      return errorStatus;
-    }
-  }
-};
+// src/provider/host/MemoryXyoGateway.ts
+import { isDefined } from "@xylabs/typeof";
 
 // src/provider/runner/JsonRpcXyoRunner.ts
 var JsonRpcXyoRunner = class {
@@ -940,9 +888,9 @@ var NodeXyoRunner = class {
 };
 
 // src/provider/signer/JsonRpcXyoSigner.ts
-var JsonRpcXyoSigner = class {
+var RpcXyoSigner = class {
   static {
-    __name(this, "JsonRpcXyoSigner");
+    __name(this, "RpcXyoSigner");
   }
   transport;
   constructor(transport) {
@@ -962,6 +910,14 @@ var JsonRpcXyoSigner = class {
       from
     ]);
   }
+  signTransaction(tx) {
+    throw new Error("Method not implemented.");
+  }
+};
+var JsonRpcXyoSigner = class extends RpcXyoSigner {
+  static {
+    __name(this, "JsonRpcXyoSigner");
+  }
 };
 
 // src/provider/signer/MemoryXyoSigner.ts
@@ -982,6 +938,9 @@ var MemoryXyoSigner = class {
     const transaction = await buildTransaction(chain, elevatedPayloads, additionalPayloads, this._account, nbf, exp, fromAddress, fees);
     return transaction[0];
   }
+  signTransaction(_tx) {
+    throw new Error("Method not implemented.");
+  }
 };
 
 // src/provider/viewer/JsonRpcXyoViewer.ts
@@ -1082,8 +1041,10 @@ var confirmTransaction = /* @__PURE__ */ __name(async (provider, txBW, onConfirm
 
 // src/provider/provider/XyoConnection.ts
 import { assertEx as assertEx3 } from "@xylabs/assert";
+import { HydratedTransactionWrapper } from "@xyo-network/chain-wrappers";
 import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
-import { defaultTransactionFees } from "@xyo-network/xl1-protocol";
+import { isAnyPayload } from "@xyo-network/payload-model";
+import { defaultTransactionFees, isDataLakeProvider } from "@xyo-network/xl1-protocol";
 var XyoConnection = class {
   static {
     __name(this, "XyoConnection");
@@ -1091,11 +1052,13 @@ var XyoConnection = class {
   _network;
   _runner;
   _signer;
+  _storage;
   _viewer;
   constructor(params) {
     this._network = params?.network;
     this._runner = params?.runner;
     this._signer = params?.signer;
+    this._storage = params?.storage;
     this._viewer = params?.viewer;
   }
   get network() {
@@ -1107,6 +1070,9 @@ var XyoConnection = class {
   get signer() {
     return this._signer;
   }
+  get storage() {
+    return this._storage;
+  }
   get viewer() {
     return this._viewer;
   }
@@ -1124,6 +1090,7 @@ var XyoConnection = class {
     const viewer = assertEx3(this.viewer, () => "No viewer available");
     const signer = assertEx3(this.signer, () => "No signer available");
     const runner = assertEx3(this.runner, () => "No runner available");
+    const storage = this.storage;
     const chainResolved = chain ?? await viewer.chainId();
     if (chainResolved === void 0) throw new Error("Failed to determine chain");
     const nbfResolved = Math.max(await viewer.currentBlockNumber() ?? 0, nbf ?? 0);
@@ -1136,6 +1103,10 @@ var XyoConnection = class {
       await PayloadBuilder4.addStorageMeta(signedTransaction),
       await PayloadBuilder4.addStorageMeta(elevatedPayloads)
     ];
+    if (isDataLakeProvider(storage)) {
+      const wrapper = await HydratedTransactionWrapper.parse(hydratedTransaction);
+      await storage.add(Object.values(wrapper.externalPayloads).filter(isAnyPayload));
+    }
     assertEx3(await runner.broadcastTransaction(hydratedTransaction), () => "Failed to broadcast transaction");
     return hydratedTransaction;
   }
@@ -1165,9 +1136,186 @@ var RpcXyoConnection = class extends XyoConnection {
   }
 };
 
+// src/provider/host/MemoryXyoGateway.ts
+var MemoryXyoGateway = class extends AbstractXyoGateway {
+  static {
+    __name(this, "MemoryXyoGateway");
+  }
+  _activeConnectionId;
+  _connections = /* @__PURE__ */ new Map();
+  _permissionsStore;
+  _signer;
+  constructor(signer, permissionsStore) {
+    super();
+    this._signer = signer;
+    this._permissionsStore = permissionsStore;
+  }
+  get signer() {
+    return this._signer;
+  }
+  activeConnection() {
+    return isDefined(this._activeConnectionId) ? this._connections.get(this._activeConnectionId) : void 0;
+  }
+  addConnection(configOrName, connection) {
+    if (typeof configOrName === "string" && connection !== void 0) {
+      const name = configOrName;
+      this._connections.set(name, connection);
+      this.setActiveConnectionIdIfUndefined(name);
+      return connection;
+    } else if (typeof configOrName === "object") {
+      const config = configOrName;
+      const { name, dataLakeEndpoint, networkEndpoint } = config;
+      const rpcConnection = new RpcXyoConnection({
+        endpoint: networkEndpoint
+      });
+      this._connections.set(name, rpcConnection);
+      this.setActiveConnectionIdIfUndefined(name);
+      return rpcConnection;
+    }
+    throw new Error("Invalid arguments passed to addConnection");
+  }
+  connections() {
+    const record = {};
+    for (const [id, conn] of this._connections.entries()) {
+      record[id] = conn;
+    }
+    return record;
+  }
+  getPermissions() {
+    return this._permissionsStore.getPermissions();
+  }
+  requestPermissions(permissions) {
+    return this._permissionsStore.requestPermissions(permissions);
+  }
+  revokePermissions(permissions) {
+    return this._permissionsStore.revokePermissions(permissions);
+  }
+  setActiveConnectionIdIfUndefined(id) {
+    if (!isDefined(this._activeConnectionId)) {
+      this._activeConnectionId = id;
+    }
+  }
+};
+
+// src/provider/host/PermissionsStore/getPermissionsStoreFromTransport.ts
+var getPermissionsStoreFromTransport = /* @__PURE__ */ __name((transport) => {
+  return {
+    getPermissions: /* @__PURE__ */ __name(() => transport.sendRequest("xyoGateway_getPermissions"), "getPermissions"),
+    requestPermissions: /* @__PURE__ */ __name((permissions) => transport.sendRequest("xyoGateway_requestPermissions", permissions), "requestPermissions"),
+    revokePermissions: /* @__PURE__ */ __name((permissions) => transport.sendRequest("xyoGateway_revokePermissions", permissions), "revokePermissions")
+  };
+}, "getPermissionsStoreFromTransport");
+
+// src/provider/host/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/network/MemoryXyoNetwork.ts
+import { isUndefined } from "@xylabs/typeof";
+import { isNetworkStatus } from "@xyo-network/xl1-protocol";
+import axios from "axios";
+
+// src/provider/network/lib/FailedNetworkStatusPayloads.ts
+import { NetworkStatusSchema } from "@xyo-network/xl1-protocol";
+var unknownStatus = {
+  description: "Unknown Network Status",
+  schema: NetworkStatusSchema,
+  state: "unknown"
+};
+var errorStatus = {
+  description: "Error Fetching Network Status",
+  schema: NetworkStatusSchema,
+  state: "unknown"
+};
+
+// src/provider/network/lib/StatusNetworks.ts
+var MainNetworkStats = {
+  id: "mainnet",
+  statusUrl: "https://xyo.network/chain-network-status-mainnet.json"
+};
+var SequenceNetworkStats = {
+  id: "sequence",
+  statusUrl: "https://beta.xyo.network/chain-network-status-sequence.json"
+};
+var LocalNetworkStats = {
+  id: "local",
+  statusUrl: "http://localhost:3002/chain-network-status-local.json"
+};
+var StatusNetworks = {
+  mainnet: MainNetworkStats,
+  sequence: SequenceNetworkStats,
+  local: LocalNetworkStats
+};
+
+// src/provider/network/MemoryXyoNetwork.ts
+var MemoryXyoNetwork = class {
+  static {
+    __name(this, "MemoryXyoNetwork");
+  }
+  _networkId;
+  constructor(networkId) {
+    this._networkId = networkId;
+  }
+  async status() {
+    const statusNetwork = StatusNetworks[this._networkId];
+    if (isUndefined(statusNetwork)) {
+      throw new Error(`Unknown status network ID: ${this._networkId}`);
+    }
+    return await this.makeRequest(statusNetwork.statusUrl);
+  }
+  async makeRequest(url) {
+    try {
+      const response = await axios.get(url);
+      if (isNetworkStatus(response.data)) {
+        return response.data;
+      } else {
+        if (response.status === 200) {
+          console.error("Unknown network status response:", response.data);
+          return unknownStatus;
+        }
+        return errorStatus;
+      }
+    } catch (error) {
+      console.error("Error fetching network status:", error);
+      return errorStatus;
+    }
+  }
+};
+
 // src/transport/HttpRpcTransport.ts
 import { AxiosJson } from "@xylabs/axios";
-import { isUndefinedOrNull } from "@xylabs/typeof";
+import { isError, isUndefinedOrNull } from "@xylabs/typeof";
+import { isAxiosError } from "axios";
 import { v4 } from "uuid";
 var HttpRpcTransport = class {
   static {
@@ -1183,21 +1331,29 @@ var HttpRpcTransport = class {
     return await this.callRpc(this._rpcUrl, this._schemas, method, params);
   }
   async callRpc(url, schemas, method, params) {
-    const id = v4();
-    const body = {
-      jsonrpc,
-      id,
-      method
-    };
-    if (params) {
-      body.params = schemas[method].params.to.parse(params);
-    }
-    const res = await new AxiosJson().post(url, body);
-    const json = res.data;
-    if (isUndefinedOrNull(json) || json.error) {
-      throw new Error(json.error.message);
+    try {
+      const id = v4();
+      const body = {
+        jsonrpc,
+        id,
+        method
+      };
+      if (params) {
+        body.params = schemas[method].params.to.parse(params);
+      }
+      const res = await new AxiosJson().post(url, body);
+      const json = res.data;
+      if (isUndefinedOrNull(json) || json.error) {
+        throw new Error(json.error.message);
+      }
+      return schemas[method].result.from.parse(json.result);
+    } catch (ex) {
+      let message = isError(ex) ? ex.message : String(ex);
+      if (isAxiosError(ex)) {
+        message = `Http error occurred [${ex.status}|${ex.code ?? "<unknown>"}]: ${ex.message}`;
+      }
+      throw new Error(`Error occurred while calling RPC method ${String(method)}: ${message}`);
     }
-    return schemas[method].result.from.parse(json.result);
   }
 };
 
@@ -1241,7 +1397,7 @@ var MemoryRpcTransport = class {
 };
 
 // src/transport/post-message/PostMessageRpcTransport.ts
-import { isDefined } from "@xylabs/typeof";
+import { isDefined as isDefined2 } from "@xylabs/typeof";
 import { v4 as v43 } from "uuid";
 
 // src/transport/post-message/helpers.ts
@@ -1280,7 +1436,7 @@ var PostMessageRpcTransport = class {
       id,
       method
     };
-    body.params = isDefined(params) && isDefined(schemas[method]) ? schemas[method].params.to.parse(params) : params;
+    body.params = isDefined2(params) && isDefined2(schemas[method]) ? schemas[method].params.to.parse(params) : params;
     return await new Promise((resolve, reject) => {
       const id2 = body.id;
       const handler = /* @__PURE__ */ __name((event) => {
@@ -1311,7 +1467,9 @@ export {
   JsonRpcXyoRunner,
   JsonRpcXyoSigner,
   JsonRpcXyoViewer,
+  MemoryPermissionsStore,
   MemoryRpcTransport,
+  MemoryXyoGateway,
   MemoryXyoNetwork,
   MemoryXyoRunner,
   MemoryXyoSigner,
@@ -1319,6 +1477,7 @@ export {
   PermissionSchema,
   PostMessageRpcTransport,
   RpcXyoConnection,
+  RpcXyoSigner,
   XyoConnection,
   XyoGatewayRpcSchemas,
   XyoProviderRpcSchemas,
@@ -1328,6 +1487,7 @@ export {
   buildSessionMessageRequest,
   createRequestSchema,
   createResponseSchema,
+  getPermissionsStoreFromTransport,
   jsonrpc,
   requestSchemas,
   rpcEngineFromProvider,