@xyo-network/xl1-rpc 1.7.17 → 1.7.19

package/dist/neutral/index.mjs

@@ -59,57 +59,215 @@ var rpcMethodHandlersFromProvider = /* @__PURE__ */ __name((provider) => {
   return result;
 }, "rpcMethodHandlersFromProvider");
 
-// 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.");
+  addConnection(config) {
+    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);
+    throw new Error("Deprecated method not implemented.");
   }
   revokePermissions(permissions) {
-    return this._transport.sendRequest("xyoGateway_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/provider/confirmTransaction.ts
+// 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";
+import { isDefined } from "@xylabs/typeof";
 import { PayloadBuilder } from "@xyo-network/payload-builder";
+var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
+var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
+var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (provider, txBW, options) => {
+  const { attempts: maxAttempts = DEFAULT_CONFIRMATION_ATTEMPTS, delay: attemptDelay = DEFAULT_DELAY_BETWEEN_ATTEMPTS } = options || {};
+  const txBWHash = await PayloadBuilder.hash(txBW);
+  options?.logger?.log("\u2705 confirming transaction:", txBWHash, "\n");
+  let attempts = 0;
+  while (true) {
+    const tx = await provider.viewer?.transactionByHash(txBWHash) ?? void 0;
+    if (isDefined(tx)) {
+      options?.logger?.log("\u{1F37B} Transaction confirmed:", txBWHash, "\n");
+      return tx;
+    } else {
+      attempts++;
+      if (attempts > maxAttempts) {
+        options?.logger?.error(`\u26A0\uFE0F Transaction not confirmed after ${maxAttempts} attempts`);
+        throw new Error(`Transaction ${txBWHash} not confirmed after ${maxAttempts} attempts`);
+      } else {
+        options?.logger?.log(`\u{1F504} Transaction not confirmed yet, attempt ${attempts}. Retrying...`, "\n");
+        await delay(attemptDelay);
+      }
+    }
+  }
+}, "confirmSubmittedTransaction");
+
+// src/provider/provider/confirmTransaction.ts
+import { delay as delay2 } from "@xylabs/delay";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
 var CONFIRMATION_ATTEMPTS = 20;
 var DELAY_BETWEEN_ATTEMPTS = 1e3;
 var confirmTransaction = /* @__PURE__ */ __name(async (provider, txBW, onConfirm, onTimeout) => {
-  const txBWHash = await PayloadBuilder.hash(txBW);
+  const txBWHash = await PayloadBuilder2.hash(txBW);
   console.log("\u2705 confirming transaction:", txBWHash, "\n");
   let confirmed = false;
   let attempts = 0;
@@ -127,7 +285,7 @@ var confirmTransaction = /* @__PURE__ */ __name(async (provider, txBW, onConfirm
         return;
       } else {
         console.log(`\u{1F504} Transaction not confirmed yet, attempt ${attempts}. Retrying...`, "\n");
-        await delay(DELAY_BETWEEN_ATTEMPTS);
+        await delay2(DELAY_BETWEEN_ATTEMPTS);
       }
     }
   }
@@ -718,74 +876,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),
@@ -883,7 +1035,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
@@ -922,7 +1074,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) => {
@@ -959,7 +1111,7 @@ var JsonRpcXyoRunner = class {
 
 // src/provider/runner/MemoryXyoRunner.ts
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
 import { flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
 var MemoryXyoRunner = class {
   static {
@@ -969,7 +1121,7 @@ var MemoryXyoRunner = class {
   async broadcastTransaction(transaction) {
     const archivist = await this.getArchivist();
     await archivist.insert(flattenHydratedTransaction(transaction));
-    return await PayloadBuilder2.hash(transaction[0]);
+    return await PayloadBuilder3.hash(transaction[0]);
   }
   async getArchivist() {
     if (!this._archivist) {
@@ -984,7 +1136,7 @@ var MemoryXyoRunner = class {
 // src/provider/runner/NodeXyoRunner.ts
 import { assertEx as assertEx2 } from "@xylabs/assert";
 import { asArchivistInstance } from "@xyo-network/archivist-model";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
 import { PayloadBundleSchema } from "@xyo-network/payload-model";
 import { flattenHydratedTransaction as flattenHydratedTransaction2 } from "@xyo-network/xl1-protocol-sdk";
 var NodeXyoRunner = class {
@@ -1001,7 +1153,7 @@ var NodeXyoRunner = class {
   async broadcastTransaction(transaction) {
     const flattened = flattenHydratedTransaction2(transaction);
     const pendingArchivist = await this.getPendingArchivist();
-    const txHash = await PayloadBuilder3.hash(transaction[0]);
+    const txHash = await PayloadBuilder4.hash(transaction[0]);
     const payloadBundle = {
       schema: PayloadBundleSchema,
       payloads: flattened,
@@ -1147,7 +1299,7 @@ var JsonRpcXyoViewer = class {
 
 // src/provider/provider/XyoConnection.ts
 import { assertEx as assertEx3 } from "@xylabs/assert";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
 import { isAnyPayload } from "@xyo-network/payload-model";
 import { defaultTransactionFees, isDataLakeProvider } from "@xyo-network/xl1-protocol";
 import { HydratedTransactionWrapper } from "@xyo-network/xl1-wrappers";
@@ -1206,8 +1358,8 @@ var XyoConnection = class {
     if (fromResolved === void 0) throw new Error("Failed to determine from address");
     const signedTransaction = assertEx3(await signer.createSignedTransaction(chainResolved, elevatedPayloads, additionalPayloads, nbfResolved, expResolved, feesResolved, fromResolved), () => "Failed to create transaction");
     const hydratedTransaction = [
-      await PayloadBuilder4.addStorageMeta(signedTransaction),
-      await PayloadBuilder4.addStorageMeta(elevatedPayloads)
+      await PayloadBuilder5.addStorageMeta(signedTransaction),
+      await PayloadBuilder5.addStorageMeta(elevatedPayloads)
     ];
     if (isDataLakeProvider(storage)) {
       const wrapper = await HydratedTransactionWrapper.parse(hydratedTransaction);
@@ -1237,185 +1389,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;
-    }
-  }
 };
 export {
   AbstractXyoGateway,
@@ -1426,12 +1399,12 @@ export {
   HttpRpcTransport,
   InvokerPermissionSchema,
   JsonRpcErrorCodes,
-  JsonRpcXyoGateway,
   JsonRpcXyoRunner,
   JsonRpcXyoSigner,
   JsonRpcXyoViewer,
   MemoryPermissionsStore,
   MemoryRpcTransport,
+  MemoryXyoClient,
   MemoryXyoGateway,
   MemoryXyoNetwork,
   MemoryXyoRunner,
@@ -1448,6 +1421,7 @@ export {
   XyoSignerRpcSchemas,
   XyoViewerRpcSchemas,
   buildSessionMessageRequest,
+  confirmSubmittedTransaction,
   confirmTransaction,
   createRequestSchema,
   createResponseSchema,