@xyo-network/xl1-protocol-sdk 1.16.1 → 1.16.2

package/dist/neutral/index.mjs

@@ -153,6 +153,11 @@ var LruCacheMap = class {
   set(id, data) {
     this.lruCache.set(id, data);
   }
+  setMany(entries) {
+    for (const [key, value] of entries) {
+      this.lruCache.set(key, value);
+    }
+  }
 };
 
 // src/driver/memory/MemoryMap.ts
@@ -190,6 +195,11 @@ var MemoryMap = class {
   set(id, data) {
     this.map.set(id, data);
   }
+  setMany(entries) {
+    for (const [key, value] of entries) {
+      this.map.set(key, value);
+    }
+  }
 };
 
 // src/model/ChainContext/ChainContext.ts
@@ -1380,21 +1390,126 @@ var asChainIndexingServiceState = AsObjectFactory6.create(isChainIndexingService
 var isChainIndexingServiceStateWithStorageMeta = /* @__PURE__ */ __name((value) => isChainIndexingServiceState(value) && isStorageMeta3(value), "isChainIndexingServiceStateWithStorageMeta");
 var asChainIndexingServiceStateWithStorageMeta = AsObjectFactory6.create(isChainIndexingServiceStateWithStorageMeta);
 
-// src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
-import { assertEx as assertEx7 } from "@xylabs/assert";
-import { asTimePayload, TimeSchema } from "@xyo-network/xl1-protocol";
-async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
-  const blockHash = await hashFromBlockNumber(context, xl1BlockNumber);
-  const hydratedBlock = await hydrateBlock(context.store, blockHash);
-  const timePayload = asTimePayload(hydratedBlock[1].find((p) => p.schema === TimeSchema), {
-    required: true
-  });
-  return assertEx7(timePayload.ethereum, () => "No ethereum timestamp found on block");
-}
-__name(xl1BlockNumberToEthBlockNumber, "xl1BlockNumberToEthBlockNumber");
+// src/simple/client/SimpleXyoClient.ts
+var SimpleXyoClient = class {
+  static {
+    __name(this, "SimpleXyoClient");
+  }
+  gateways;
+  permissions;
+  constructor(gateways, permissions) {
+    this.gateways = gateways;
+    this.permissions = permissions;
+  }
+};
+
+// src/simple/datalake/SimpleDataLakeViewer.ts
+import { isAnyPayload as isAnyPayload3 } from "@xyo-network/payload-model";
+var SimpleDataLakeViewer = class {
+  static {
+    __name(this, "SimpleDataLakeViewer");
+  }
+  _params;
+  constructor(params) {
+    this._params = params;
+  }
+  get allowedSchemas() {
+    return this._params.allowedSchemas;
+  }
+  get disallowedSchemas() {
+    return this._params.disallowedSchemas;
+  }
+  get map() {
+    return this._params.map;
+  }
+  get params() {
+    return this._params;
+  }
+  async get(hash) {
+    const result = await this.map.get(hash);
+    return this.isAllowed(result) ? result : void 0;
+  }
+  async getMany(hashes) {
+    const result = await this.map.getMany(hashes);
+    return result.filter((data) => this.isAllowed(data));
+  }
+  async has(hash) {
+    const value = await this.get(hash);
+    if (isAnyPayload3(value)) {
+      return this.isAllowed(value);
+    }
+    return value !== void 0;
+  }
+  isAllowed(value) {
+    if (isAnyPayload3(value)) {
+      return this.isAllowedSchema(value.schema);
+    }
+    return true;
+  }
+  isAllowedSchema(schema) {
+    if (this.allowedSchemas && !this.allowedSchemas.includes(schema)) {
+      return false;
+    }
+    if (this.disallowedSchemas && this.disallowedSchemas.includes(schema)) {
+      return false;
+    }
+    return true;
+  }
+};
+
+// src/simple/datalake/SimpleDataLakeRunner.ts
+var SimpleDataLakeRunner = class extends SimpleDataLakeViewer {
+  static {
+    __name(this, "SimpleDataLakeRunner");
+  }
+  constructor(params) {
+    super(params);
+  }
+  async clear() {
+    await this.map.clear();
+  }
+  async delete(hash) {
+    return await this.map.delete(hash);
+  }
+  async set(hash, data) {
+    if (this.isAllowed(data)) {
+      await this.map.set(hash, data);
+    }
+  }
+  async setMany(entries) {
+    const allowed = entries.filter(([_, data]) => this.isAllowed(data));
+    return await this.map.setMany(allowed);
+  }
+};
+
+// src/simple/gateway/SimpleXyoGateway.ts
+var SimpleXyoGateway = class {
+  static {
+    __name(this, "SimpleXyoGateway");
+  }
+  _connection;
+  _signer;
+  constructor(signer, connection) {
+    this._signer = signer;
+    this._connection = connection;
+  }
+  get connection() {
+    return this._connection;
+  }
+  get signer() {
+    return this._signer;
+  }
+};
+
+// src/simple/gateway/SimpleXyoGatewayRunner.ts
+import { assertEx as assertEx11 } from "@xylabs/assert";
+import { BigIntToJsonZod } from "@xylabs/hex";
+import { isDefined as isDefined9 } from "@xylabs/typeof";
+import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
+import { TransferSchema } from "@xyo-network/xl1-protocol";
 
 // src/transaction/buildTransaction.ts
-import { assertEx as assertEx8 } from "@xylabs/assert";
+import { assertEx as assertEx7 } from "@xylabs/assert";
 import { toHex as toHex2 } from "@xylabs/hex";
 import { BoundWitnessBuilder } from "@xyo-network/boundwitness-builder";
 import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
@@ -1421,7 +1536,7 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
   }
   const fields = {
     ...txBoundWitnessFields,
-    from: from ?? (Array.isArray(signer) ? assertEx8(signer.at(0)?.address) : signer.address)
+    from: from ?? (Array.isArray(signer) ? assertEx7(signer.at(0)?.address) : signer.address)
   };
   if (script.length > 0) {
     fields.script = script;
@@ -1513,7 +1628,7 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, transact
 }, "confirmSubmittedTransaction");
 
 // src/transaction/hydrateTransaction.ts
-import { assertEx as assertEx9 } from "@xylabs/assert";
+import { assertEx as assertEx8 } from "@xylabs/assert";
 import { hydrateTypedBoundWitness, tryHydrateTypedBoundWitness } from "@xyo-network/archivist-model";
 import { isAllowedBlockPayload as isAllowedBlockPayload2, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 var tryHydrateTransaction = /* @__PURE__ */ __name(async ({ chainMap }, hash) => {
@@ -1572,7 +1687,7 @@ var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async ({ chainMap },
   return void 0;
 }, "tryHydrateElevatedTransaction");
 var hydrateElevatedTransaction = /* @__PURE__ */ __name(async (context, hash) => {
-  return assertEx9(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
+  return assertEx8(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
 }, "hydrateElevatedTransaction");
 
 // src/transaction/primitives/transactionBlockByteCount.ts
@@ -1638,7 +1753,7 @@ __name(transactionRequiredGas, "transactionRequiredGas");
 
 // src/transaction/script.ts
 import { filterAs as filterAs2 } from "@xylabs/array";
-import { assertEx as assertEx10 } from "@xylabs/assert";
+import { assertEx as assertEx9 } from "@xylabs/assert";
 import { asHash as asHash4 } from "@xylabs/hex";
 import { isAllowedBlockPayloadWithHashMeta } from "@xyo-network/xl1-protocol";
 var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
@@ -1648,7 +1763,7 @@ var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
 var extractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
   const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|")[1]);
   const filtered = filterAs2(hashes, (h) => asHash4(h));
-  assertEx10(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  assertEx9(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashesFromScript");
 var tryExtractElevatedHashes = /* @__PURE__ */ __name((tx) => {
@@ -1662,17 +1777,17 @@ var extractElevatedHashes = /* @__PURE__ */ __name((tx) => {
   const { script } = bw;
   const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
   const filtered = payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashMeta);
-  assertEx10(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  assertEx9(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashes");
 
 // src/transaction/signTransaction.ts
 import { toArrayBuffer } from "@xylabs/arraybuffer";
-import { assertEx as assertEx11 } from "@xylabs/assert";
+import { assertEx as assertEx10 } from "@xylabs/assert";
 import { hexFromArrayBuffer } from "@xylabs/hex";
 import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
 async function signTransaction(tx, account) {
-  assertEx11(tx.from === account.address, () => "Signer address does not match transaction from address");
+  assertEx10(tx.from === account.address, () => "Signer address does not match transaction from address");
   const signedTx = structuredClone(tx);
   signedTx.addresses = [
     account.address
@@ -1690,6 +1805,322 @@ async function signTransaction(tx, account) {
 }
 __name(signTransaction, "signTransaction");
 
+// src/simple/gateway/SimpleXyoGatewayRunner.ts
+var SimpleXyoGatewayRunner = class {
+  static {
+    __name(this, "SimpleXyoGatewayRunner");
+  }
+  gateway;
+  _dataLakes;
+  constructor(gateway, dataLakes = []) {
+    this.gateway = gateway;
+    this._dataLakes = [
+      ...dataLakes
+    ];
+  }
+  get connection() {
+    return this.gateway.connection;
+  }
+  get dataLakes() {
+    throw new Error("Method not implemented.");
+  }
+  get signer() {
+    return this.gateway.signer;
+  }
+  addDataLake(dataLake) {
+    this._dataLakes.push(dataLake);
+    return this._dataLakes.length - 1;
+  }
+  async addPayloadsToChain(onChain, offChain, options) {
+    const viewer = assertEx11(this.connection.viewer, () => "No viewer available on connection");
+    const { nbf, exp, chain, fees } = options ?? {};
+    const resolvedChainId = isDefined9(chain) ? chain : await viewer.chainId();
+    const resolvedNbf = isDefined9(nbf) ? nbf : await viewer?.currentBlockNumber();
+    const resolvedExp = isDefined9(exp) ? exp : resolvedNbf + 10;
+    const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await this.signer.address(), fees);
+    return await this.addTransactionToChain(tx);
+  }
+  async addTransactionToChain(tx) {
+    const connection = this.gateway.connection;
+    const signer = this.gateway.signer;
+    const runner = assertEx11(connection.runner, () => "No runner available on connection");
+    const signedTx = await signer.signTransaction(tx);
+    await this.addPayloadsToDataLakes(signedTx[1]);
+    return [
+      await runner.broadcastTransaction([
+        await PayloadBuilder10.addStorageMeta(signedTx[0]),
+        await PayloadBuilder10.addStorageMeta(signedTx[1])
+      ]),
+      signedTx
+    ];
+  }
+  removeDataLake(index) {
+    this._dataLakes[index] = null;
+  }
+  async send(to, amount, options) {
+    return await this.sendMany({
+      [to]: amount
+    }, options);
+  }
+  async sendMany(transfers, options) {
+    const from = await this.signer.address();
+    const hexTransfers = Object.fromEntries(Object.entries(transfers).map(([address, amount]) => [
+      address,
+      BigIntToJsonZod.parse(amount)
+    ]));
+    const transfer = new PayloadBuilder10({
+      schema: TransferSchema
+    }).fields({
+      from,
+      transfers: hexTransfers,
+      epoch: Date.now()
+    }).build();
+    const [hash] = await this.addPayloadsToChain([
+      transfer
+    ], [], options);
+    return hash;
+  }
+  async addPayloadsToDataLakes(payloads) {
+    await Promise.all(this._dataLakes.map(async (dataLake) => {
+      await Promise.all(payloads.map(async (payload) => {
+        await dataLake?.set(payload._hash, payload);
+      }));
+    }));
+  }
+};
+
+// src/simple/network/SimpleXyoNetwork.ts
+import { isUndefined as isUndefined4 } from "@xylabs/typeof";
+import { isNetworkStatus } from "@xyo-network/xl1-protocol";
+import axios from "axios";
+
+// src/simple/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/simple/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/simple/network/SimpleXyoNetwork.ts
+var SimpleXyoNetwork = class {
+  static {
+    __name(this, "SimpleXyoNetwork");
+  }
+  _networkId;
+  constructor(networkId) {
+    this._networkId = networkId;
+  }
+  async status() {
+    const statusNetwork = StatusNetworks[this._networkId];
+    if (isUndefined4(statusNetwork)) {
+      throw new Error(`Unknown status network ID: ${this._networkId}`);
+    }
+    return await this.makeRequest(statusNetwork.statusUrl);
+  }
+  async makeRequest(url3) {
+    try {
+      const response = await axios.get(url3);
+      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/simple/permissions/SimpleXyoPermissions.ts
+import { assertEx as assertEx12 } from "@xylabs/assert";
+var SimpleXyoPermissions = class {
+  static {
+    __name(this, "SimpleXyoPermissions");
+  }
+  invoker;
+  _store;
+  constructor(store) {
+    this._store = store;
+    this.invoker = store.invoker;
+  }
+  get store() {
+    return assertEx12(this._store, () => "Store must be defined to get permissions");
+  }
+  async getPermissions() {
+    return await this.store.getPermissions();
+  }
+  // assumed the permissions are always granted
+  async requestPermissions(permissions) {
+    await Promise.resolve();
+    const newPermissions = [];
+    const now = Date.now();
+    for (const req of permissions) {
+      for (const parentCapability in req) {
+        newPermissions.push({
+          invoker: this.invoker,
+          parentCapability,
+          caveats: Object.entries(req[parentCapability]).map(([type, value]) => ({
+            type,
+            value
+          })),
+          date: now
+        });
+      }
+    }
+    const existingPermissions = await this.getPermissions();
+    for (const perm of newPermissions) {
+      const idx = existingPermissions.findIndex((p) => p.invoker === perm.invoker && p.parentCapability === perm.parentCapability);
+      if (idx === -1) {
+        existingPermissions.push(perm);
+      } else {
+        existingPermissions[idx] = perm;
+      }
+    }
+    await this.store.setPermissions(existingPermissions);
+    return newPermissions.map(({ parentCapability, date }) => ({
+      parentCapability,
+      date
+    }));
+  }
+  // Assumes the permissions are always revoked
+  async revokePermissions(permissions) {
+    const existingPermissions = await this.getPermissions();
+    const revoked = [];
+    for (const parentCapability in permissions) {
+      const idx = existingPermissions.findIndex((p) => p.invoker === this.invoker && p.parentCapability === parentCapability);
+      if (idx !== -1) {
+        const removed = existingPermissions.splice(idx, 1)[0];
+        revoked.push({
+          parentCapability: removed.parentCapability,
+          date: removed.date
+        });
+      }
+    }
+    await this.store.setPermissions(existingPermissions);
+    return revoked;
+  }
+};
+
+// src/simple/permissions/store/MemoryPermissions.ts
+import { assertEx as assertEx13 } from "@xylabs/assert";
+var MemoryPermissionsStore = class {
+  static {
+    __name(this, "MemoryPermissionsStore");
+  }
+  _invoker;
+  permissions = [];
+  constructor(invoker) {
+    this._invoker = invoker;
+  }
+  get invoker() {
+    return assertEx13(this._invoker, () => "Invoker must be defined to get permissions");
+  }
+  async getPermissions() {
+    await Promise.resolve();
+    return this.permissions;
+  }
+  async setPermissions(permissions) {
+    await Promise.resolve();
+    this.permissions = permissions;
+  }
+};
+
+// src/simple/runner/SimpleXyoRunner.ts
+import { MemoryArchivist } from "@xyo-network/archivist-memory";
+import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/payload-builder";
+var SimpleXyoRunner = class {
+  static {
+    __name(this, "SimpleXyoRunner");
+  }
+  _mempoolArchivist;
+  constructor(mempoolArchivist) {
+    this._mempoolArchivist = mempoolArchivist;
+  }
+  async broadcastTransaction(transaction) {
+    const archivist = await this.getMempoolArchivist();
+    await archivist.insert(flattenHydratedTransaction(transaction));
+    return await PayloadBuilder11.hash(transaction[0]);
+  }
+  async getMempoolArchivist() {
+    if (!this._mempoolArchivist) {
+      this._mempoolArchivist = await MemoryArchivist.create({
+        account: "random"
+      });
+    }
+    return this._mempoolArchivist;
+  }
+};
+
+// src/simple/signer/SimpleXyoSigner.ts
+import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/payload-builder";
+var SimpleXyoSigner = class {
+  static {
+    __name(this, "SimpleXyoSigner");
+  }
+  _account;
+  constructor(account) {
+    this._account = account;
+  }
+  address() {
+    return this._account.address;
+  }
+  async createSignedTransaction(chain, elevatedPayloads2, additionalPayloads, nbf, exp, fees, from) {
+    const fromAddress = from ?? this._account.address;
+    const transaction = await buildTransaction(chain, elevatedPayloads2, additionalPayloads, this._account, nbf, exp, fromAddress, fees);
+    return transaction[0];
+  }
+  async signTransaction(tx) {
+    const txBW = await signTransaction(tx[0], this._account);
+    return [
+      await PayloadBuilder12.addStorageMeta(txBW),
+      await PayloadBuilder12.addStorageMeta(tx[1])
+    ];
+  }
+};
+
+// src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
+import { assertEx as assertEx14 } from "@xylabs/assert";
+import { asTimePayload, TimeSchema } from "@xyo-network/xl1-protocol";
+async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
+  const blockHash = await hashFromBlockNumber(context, xl1BlockNumber);
+  const hydratedBlock = await hydrateBlock(context.store, blockHash);
+  const timePayload = asTimePayload(hydratedBlock[1].find((p) => p.schema === TimeSchema), {
+    required: true
+  });
+  return assertEx14(timePayload.ethereum, () => "No ethereum timestamp found on block");
+}
+__name(xl1BlockNumberToEthBlockNumber, "xl1BlockNumberToEthBlockNumber");
+
 // src/wallet/generateXyoBaseWalletFromPhrase.ts
 import { HDWallet } from "@xyo-network/wallet";
 
@@ -1738,8 +2169,18 @@ export {
   JSONSchemaMetaSchema,
   LruCacheMap,
   MemoryMap,
+  MemoryPermissionsStore,
   MnemonicStringZod,
   RewardMultipliers,
+  SimpleDataLakeRunner,
+  SimpleDataLakeViewer,
+  SimpleXyoClient,
+  SimpleXyoGateway,
+  SimpleXyoGatewayRunner,
+  SimpleXyoNetwork,
+  SimpleXyoPermissions,
+  SimpleXyoRunner,
+  SimpleXyoSigner,
   StakeEventNames,
   StepSummarySchema,
   TODO,