@xyo-network/xl1-rpc 1.7.18 → 1.7.20

package/dist/node/index-node.mjs

@@ -97,12 +97,12 @@ var AddressToStringSchema = z.string().toLowerCase().regex(CompiledAddressRegEx)
 var AddressFromStringSchema = z.string().toLowerCase().regex(CompiledAddressRegEx).transform((v) => toAddress(v));
 
 // src/types/schema/common/BigIntSchema.ts
-import { hexToBigInt, toHex } from "@xylabs/hex";
+import { asHex, hexToBigInt, toHex } from "@xylabs/hex";
 import { HexRegEx } from "@xyo-network/payload-wrapper";
 import { z as z2 } from "zod";
 var CompiledHexRegEx = new RegExp(HexRegEx);
-var BigIntToStringSchema = z2.bigint().nonnegative().transform((x) => toHex(x));
-var BigIntFromStringSchema = z2.string().regex(CompiledHexRegEx).transform((x) => hexToBigInt(toHex(x)));
+var BigIntToStringSchema = z2.bigint().nonnegative().transform((x) => asHex(toHex(x)));
+var BigIntFromStringSchema = z2.string().regex(CompiledHexRegEx).transform((x) => hexToBigInt(asHex(toHex(x), true)));
 
 // src/types/schema/common/BlockBoundWitnessSchema.ts
 import { z as z9 } from "zod";
@@ -112,18 +112,18 @@ import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
 import { z as z8 } from "zod";
 
 // src/types/schema/common/HashSchema.ts
-import { toHex as toHex2 } from "@xylabs/hex";
+import { asHash } from "@xylabs/hex";
 import { HashRegEx } from "@xyo-network/payload-wrapper";
 import { z as z3 } from "zod";
 var HashToStringSchema = z3.string().toLowerCase().regex(new RegExp(HashRegEx));
-var HashFromStringSchema = z3.string().toLowerCase().regex(new RegExp(HashRegEx)).transform((v) => toHex2(v));
+var HashFromStringSchema = z3.string().toLowerCase().regex(new RegExp(HashRegEx)).transform((v) => asHash(v, true));
 
 // src/types/schema/common/HexSchema.ts
-import { toHex as toHex3 } from "@xylabs/hex";
+import { toHex as toHex2 } from "@xylabs/hex";
 import { HexRegEx as HexRegEx2 } from "@xyo-network/payload-wrapper";
 import { z as z4 } from "zod";
 var HexToStringSchema = z4.string().toLowerCase().regex(new RegExp(HexRegEx2));
-var HexFromStringSchema = z4.string().toLowerCase().regex(new RegExp(HexRegEx2)).transform((v) => toHex3(v));
+var HexFromStringSchema = z4.string().toLowerCase().regex(new RegExp(HexRegEx2)).transform((v) => toHex2(v));
 
 // src/types/schema/common/PayloadSchema.ts
 import { z as z7 } from "zod";
@@ -132,16 +132,16 @@ import { z as z7 } from "zod";
 import { z as z6 } from "zod";
 
 // src/types/schema/common/SequenceSchema.ts
-import { toHex as toHex4 } from "@xylabs/hex";
+import { toHex as toHex3 } from "@xylabs/hex";
 import { SequenceConstants } from "@xyo-network/payload-model";
 import { HexRegExMinMax } from "@xyo-network/payload-wrapper";
 import { z as z5 } from "zod";
 var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
 var LocalSequenceToStringSchema = z5.string().regex(LocalSequenceRegex);
-var LocalSequenceFromStringSchema = z5.string().regex(LocalSequenceRegex).transform((v) => toHex4(v));
+var LocalSequenceFromStringSchema = z5.string().regex(LocalSequenceRegex).transform((v) => toHex3(v));
 var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
 var QualifiedSequenceToStringSchema = z5.string().regex(QualifiedSequenceRegex);
-var QualifiedSequenceFromStringSchema = z5.string().regex(QualifiedSequenceRegex).transform((v) => toHex4(v));
+var QualifiedSequenceFromStringSchema = z5.string().regex(QualifiedSequenceRegex).transform((v) => toHex3(v));
 var SequenceToStringSchema = z5.union([
   LocalSequenceToStringSchema,
   QualifiedSequenceToStringSchema
@@ -647,74 +647,68 @@ var InvokerPermissionSchema = PermissionSchema.extend({
   date: z20.number().optional()
 });
 var XyoGatewayRpcSchemas = {
+  /*
   xyoGateway_addConnection: {
     params: {
-      to: z20.tuple([
-        ChainConnectionSchema
-      ]),
-      from: z20.tuple([
-        ChainConnectionSchema
-      ])
+      to: z.tuple([ChainConnectionSchema]),
+      from: z.tuple([ChainConnectionSchema]),
     },
     result: {
-      to: z20.tuple([
-        z20.boolean()
-      ]),
-      from: z20.tuple([
-        z20.boolean()
-      ])
-    }
+      to: z.tuple([z.boolean()]),
+      from: z.tuple([z.boolean()]),
+    },
   },
   xyoGateway_connections: {
     params: {
-      to: z20.array(z20.any()).length(0).optional(),
-      from: z20.array(z20.any()).length(0).optional()
+      to: z.array(z.any()).length(0).optional(),
+      from: z.array(z.any()).length(0).optional(),
     },
     result: {
-      to: z20.array(ChainConnectionSchema),
-      from: z20.array(ChainConnectionSchema)
-    }
+      to: z.array(ChainConnectionSchema),
+      from: z.array(ChainConnectionSchema),
+    },
   },
   xyoGateway_getPermissions: {
     params: {
-      to: z20.array(z20.any()).length(0).optional(),
-      from: z20.array(z20.any()).length(0).optional()
+      to: z.array(z.any()).length(0).optional(),
+      from: z.array(z.any()).length(0).optional(),
     },
     result: {
-      to: z20.array(InvokerPermissionSchema),
-      from: z20.array(InvokerPermissionSchema)
-    }
+      to: z.array(InvokerPermissionSchema),
+      from: z.array(InvokerPermissionSchema),
+    },
   },
   xyoGateway_requestPermissions: {
     params: {
-      to: z20.array(PermissionSchema),
-      from: z20.array(PermissionSchema)
+      to: z.array(PermissionSchema),
+      from: z.array(PermissionSchema),
     },
     result: {
-      to: z20.boolean(),
-      from: z20.boolean()
-    }
+      to: z.boolean(),
+      from: z.boolean(),
+    },
   },
   xyoGateway_revokePermissions: {
     params: {
-      to: z20.array(PermissionSchema),
-      from: z20.array(PermissionSchema)
+      to: z.array(PermissionSchema),
+      from: z.array(PermissionSchema),
     },
     result: {
-      to: z20.boolean(),
-      from: z20.boolean()
-    }
+      to: z.boolean(),
+      from: z.boolean(),
+    },
   },
   xyoGateway_activeConnection: {
     params: {
-      from: z20.never(),
-      to: z20.never()
+      from: z.never(),
+      to: z.never(),
     },
     result: {
-      from: z20.string().optional(),
-      to: z20.string().optional()
-    }
+      from: z.string().optional(),
+      to: z.string().optional(),
+    },
   },
+  */
   xyoGateway_submitTransaction: {
     params: {
       from: z20.array(HydratedTransactionSchema),
@@ -761,49 +755,178 @@ var rpcEngineFromProvider = /* @__PURE__ */ __name((provider) => {
   return engine;
 }, "rpcEngineFromProvider");
 
-// src/provider/host/Abstract.ts
-import { assertEx } from "@xylabs/assert";
-var AbstractXyoGateway = class {
+// src/provider/client/MemoryXyoClient.ts
+var MemoryXyoClient = class {
   static {
-    __name(this, "AbstractXyoGateway");
+    __name(this, "MemoryXyoClient");
   }
-  async submitTransaction(elevatedPayloads, additionalPayloads) {
-    return assertEx(assertEx(await this.activeConnection(), () => "No active connection available for transaction submission").submitTransaction, () => "Active connection does not support transaction submission")(elevatedPayloads, additionalPayloads);
+  gateways;
+  permissionsProvider;
+  constructor(gateways, permissionsProvider) {
+    this.gateways = gateways;
+    this.permissionsProvider = permissionsProvider;
   }
 };
 
-// src/provider/host/JsonRpcXyoGateway.ts
-var JsonRpcXyoGateway = class extends AbstractXyoGateway {
+// 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, "JsonRpcXyoGateway");
+    __name(this, "MemoryPermissionsStore");
   }
-  _transport;
-  constructor(transport) {
-    super();
-    this._transport = transport;
+  _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/host/Abstract.ts
+import { assertEx } from "@xylabs/assert";
+var AbstractXyoGateway = class {
+  static {
+    __name(this, "AbstractXyoGateway");
   }
   activeConnection() {
-    throw new Error("Method not implemented.");
+    throw new Error("Deprecated method not implemented.");
   }
   addConnection(_config) {
-    throw new Error("Method not implemented.");
+    throw new Error("Deprecated method not implemented.");
   }
   connections() {
-    throw new Error("Method not implemented.");
+    throw new Error("Deprecated method not implemented.");
   }
   getPermissions() {
-    return this._transport.sendRequest("xyoGateway_getPermissions");
+    throw new Error("Deprecated method not implemented.");
   }
-  requestPermissions(permissions) {
-    return this._transport.sendRequest("xyoGateway_requestPermissions", permissions);
+  requestPermissions(_permissions) {
+    throw new Error("Deprecated method not implemented.");
   }
-  revokePermissions(permissions) {
-    return this._transport.sendRequest("xyoGateway_revokePermissions", permissions);
+  revokePermissions(_permissions) {
+    throw new Error("Deprecated method not implemented.");
+  }
+  async submitTransaction(elevatedPayloads, additionalPayloads) {
+    return assertEx(assertEx(await this.connection(), () => "No active connection available for transaction submission").submitTransaction, () => "Active connection does not support transaction submission")(elevatedPayloads, additionalPayloads);
   }
 };
 
 // src/provider/host/MemoryXyoGateway.ts
-import { isDefined as isDefined2 } from "@xylabs/typeof";
+var MemoryXyoGateway = class extends AbstractXyoGateway {
+  static {
+    __name(this, "MemoryXyoGateway");
+  }
+  _connection;
+  _signer;
+  constructor(signer, connection) {
+    super();
+    this._signer = signer;
+    this._connection = connection;
+  }
+  connection() {
+    return this._connection;
+  }
+  signer() {
+    return this._signer;
+  }
+};
+
+// 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/provider/confirmSubmittedTransaction.ts
 import { delay } from "@xylabs/delay";
@@ -969,7 +1092,7 @@ var RpcXyoSigner = class {
       from
     ]);
   }
-  signTransaction(tx) {
+  signTransaction(_tx) {
     throw new Error("Method not implemented.");
   }
 };
@@ -1160,185 +1283,6 @@ var RpcXyoConnection = class extends XyoConnection {
       viewer
     });
   }
-  async confirm(tx, onConfirm, onTimeout) {
-    return await confirmTransaction(this, tx, onConfirm, onTimeout);
-  }
-};
-
-// 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 isDefined2(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 (!isDefined2(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
@@ -1426,7 +1370,7 @@ var MemoryRpcTransport = class {
 };
 
 // src/transport/post-message/PostMessageRpcTransport.ts
-import { isDefined as isDefined3 } from "@xylabs/typeof";
+import { isDefined as isDefined2 } from "@xylabs/typeof";
 import { v4 as v43 } from "uuid";
 
 // src/transport/post-message/helpers.ts
@@ -1465,7 +1409,7 @@ var PostMessageRpcTransport = class {
       id,
       method
     };
-    body.params = isDefined3(params) && isDefined3(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) => {
@@ -1492,12 +1436,12 @@ export {
   HttpRpcTransport,
   InvokerPermissionSchema,
   JsonRpcErrorCodes,
-  JsonRpcXyoGateway,
   JsonRpcXyoRunner,
   JsonRpcXyoSigner,
   JsonRpcXyoViewer,
   MemoryPermissionsStore,
   MemoryRpcTransport,
+  MemoryXyoClient,
   MemoryXyoGateway,
   MemoryXyoNetwork,
   MemoryXyoRunner,