@0xobelisk/graphql-client 1.2.0-pre.99 → 2.0.0

package/dist/index.mjs

@@ -22,6 +22,7 @@ import {
   Observable,
   from
 } from "@apollo/client";
+import { BatchHttpLink } from "@apollo/client/link/batch-http";
 import { RetryLink } from "@apollo/client/link/retry";
 import { GraphQLWsLink } from "@apollo/client/link/subscriptions";
 import { getMainDefinition } from "@apollo/client/utilities";
@@ -736,6 +737,77 @@ import "graphql";
 
 // src/client.ts
 import pluralize from "pluralize";
+var SYSTEM_TABLE_FIELDS = {
+  dubheDappMarketplaceFees: [
+    "dappKey",
+    "listingId",
+    "coinType",
+    "totalFee",
+    "treasuryAmount",
+    "dappAmount",
+    "updatedAtCheckpoint",
+    "lastUpdateDigest"
+  ],
+  dubheDappRuntimeState: [
+    "dappKey",
+    "admin",
+    "paused",
+    "settlementMode",
+    "creditPool",
+    "writeFeeShareBps",
+    "lastRuntimeEvent",
+    "lastRuntimeActor",
+    "lastRuntimeAmount",
+    "updatedAtCheckpoint",
+    "lastUpdateDigest"
+  ],
+  dubheDappFeeState: [
+    "entityId",
+    "baseFeePerWrite",
+    "bytesFeePerByte",
+    "freeCredit",
+    "creditPool",
+    "totalSettled",
+    "updatedAtTimestampMs",
+    "lastUpdateDigest"
+  ],
+  dubheDappRevenueState: [
+    "entityId",
+    "dappRevenue",
+    "coinType",
+    "updatedAtTimestampMs",
+    "lastUpdateDigest"
+  ],
+  dubheMarketplaceListings: [
+    "dappKey",
+    "listingId",
+    "seller",
+    "recordType",
+    "price",
+    "coinType",
+    "isFungible",
+    "listedUntil",
+    "status",
+    "updatedAtCheckpoint",
+    "lastUpdateDigest"
+  ],
+  dubheSessions: [
+    "dappKey",
+    "canonical",
+    "sessionWallet",
+    "expiresAt",
+    "active",
+    "updatedAtCheckpoint",
+    "lastUpdateDigest"
+  ],
+  dubheUserStorages: [
+    "dappKey",
+    "canonicalOwner",
+    "userStorageId",
+    "updatedAtCheckpoint",
+    "lastUpdateDigest"
+  ]
+};
 function mapCachePolicyToFetchPolicy(cachePolicy) {
   switch (cachePolicy) {
     case "cache-first":
@@ -752,6 +824,23 @@ function mapCachePolicyToFetchPolicy(cachePolicy) {
       return "cache-first";
   }
 }
+function buildHttpLink(config) {
+  const fetchFn = (input, init) => fetch(input, { ...config.fetchOptions, ...init ?? {} });
+  if (config.batchRequests) {
+    return new BatchHttpLink({
+      uri: config.endpoint,
+      headers: config.headers,
+      fetch: fetchFn,
+      batchInterval: config.batchInterval ?? 10,
+      batchMax: config.batchMax ?? 20
+    });
+  }
+  return createHttpLink({
+    uri: config.endpoint,
+    headers: config.headers,
+    fetch: fetchFn
+  });
+}
 var DubheGraphqlClient = class {
   // Store current configuration for updates
   constructor(config) {
@@ -762,11 +851,7 @@ var DubheGraphqlClient = class {
     if (this.dubheMetadata) {
       this.parseTableInfoFromConfig();
     }
-    const httpLink = createHttpLink({
-      uri: config.endpoint,
-      headers: config.headers,
-      fetch: (input, init) => fetch(input, { ...config.fetchOptions, ...init })
-    });
+    const httpLink = buildHttpLink(config);
     const retryLink = new RetryLink({
       delay: {
         // Initial retry delay time (milliseconds)
@@ -887,11 +972,7 @@ var DubheGraphqlClient = class {
         }
         this.subscriptionClient = void 0;
       }
-      const httpLink = createHttpLink({
-        uri: this.currentConfig.endpoint,
-        headers: this.currentConfig.headers,
-        fetch: (input, init) => fetch(input, { ...this.currentConfig.fetchOptions, ...init })
-      });
+      const httpLink = buildHttpLink(this.currentConfig);
       const retryLink = new RetryLink({
         delay: {
           initial: this.currentConfig.retryOptions?.delay?.initial || 300,
@@ -1343,6 +1424,430 @@ var DubheGraphqlClient = class {
       return () => subscription.subscribe().unsubscribe();
     });
   }
+  /**
+   * Query marketplace listings indexed by the Dubhe indexer.
+   * Uses the marketplace_listings PostgreSQL table (exposed as dubheMarketplaceListings in GraphQL).
+   * The record_type field is pre-decoded text ("wheat", "corn", …) and status tracks
+   * active/sold/cancelled directly — no extra RPC calls needed.
+   */
+  async getMarketplaceListings(options) {
+    const filter = {};
+    if (options?.dappKey)
+      filter.dappKey = { equalTo: options.dappKey };
+    if (options?.status !== void 0)
+      filter.status = { equalTo: options.status };
+    if (options?.recordType)
+      filter.recordType = { equalTo: options.recordType };
+    if (options?.seller)
+      filter.seller = { equalTo: options.seller };
+    const query = gql`
+      query GetMarketplaceListings(
+        $first: Int
+        $after: Cursor
+        $filter: StoreDubheMarketplaceListingFilter
+        $orderBy: [StoreDubheMarketplaceListingsOrderBy!]
+      ) {
+        dubheMarketplaceListings(first: $first, after: $after, filter: $filter, orderBy: $orderBy) {
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              listingId
+              dappKey
+              seller
+              recordType
+              recordDataRaw
+              price
+              coinType
+              isFungible
+              status
+              buyer
+              listedUntil
+              createdAtCheckpoint
+              updatedAtCheckpoint
+              lastUpdateDigest
+            }
+          }
+        }
+      }
+    `;
+    const result = await this.apolloClient.query({
+      query,
+      variables: {
+        first: options?.first ?? 100,
+        after: options?.after,
+        filter: Object.keys(filter).length > 0 ? filter : void 0,
+        orderBy: ["CREATED_AT_CHECKPOINT_DESC"]
+      },
+      fetchPolicy: "network-only"
+    });
+    if (result.error)
+      throw result.error;
+    return result.data?.dubheMarketplaceListings ?? {
+      edges: [],
+      pageInfo: { hasNextPage: false, hasPreviousPage: false },
+      totalCount: 0
+    };
+  }
+  /**
+   * Query session keys indexed by the Dubhe indexer (dubheSessions in GraphQL).
+   */
+  async getDubheSessions(options) {
+    const filter = {};
+    if (options?.dappKey)
+      filter.dappKey = { equalTo: options.dappKey };
+    if (options?.canonical)
+      filter.canonical = { equalTo: options.canonical };
+    if (options?.active !== void 0)
+      filter.active = { equalTo: options.active };
+    const query = gql`
+      query GetDubheSessions(
+        $first: Int
+        $after: Cursor
+        $filter: StoreDubheSessionFilter
+        $orderBy: [StoreDubheSessionsOrderBy!]
+      ) {
+        dubheSessions(first: $first, after: $after, filter: $filter, orderBy: $orderBy) {
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              dappKey
+              canonical
+              sessionWallet
+              expiresAt
+              active
+              updatedAtCheckpoint
+              lastUpdateDigest
+              lastEventSeq
+            }
+          }
+        }
+      }
+    `;
+    const result = await this.apolloClient.query({
+      query,
+      variables: {
+        first: options?.first ?? 100,
+        after: options?.after,
+        filter: Object.keys(filter).length > 0 ? filter : void 0,
+        orderBy: ["UPDATED_AT_CHECKPOINT_DESC"]
+      },
+      fetchPolicy: "network-only"
+    });
+    if (result.error)
+      throw result.error;
+    return result.data?.dubheSessions ?? {
+      edges: [],
+      pageInfo: { hasNextPage: false, hasPreviousPage: false },
+      totalCount: 0
+    };
+  }
+  /**
+   * Query user storage registrations indexed by the Dubhe indexer (dubheUserStorages in GraphQL).
+   */
+  async getDubheUserStorages(options) {
+    const filter = {};
+    if (options?.dappKey)
+      filter.dappKey = { equalTo: options.dappKey };
+    if (options?.canonicalOwner)
+      filter.canonicalOwner = { equalTo: options.canonicalOwner };
+    const query = gql`
+      query GetDubheUserStorages(
+        $first: Int
+        $after: Cursor
+        $filter: StoreDubheUserStorageFilter
+        $orderBy: [StoreDubheUserStoragesOrderBy!]
+      ) {
+        dubheUserStorages(first: $first, after: $after, filter: $filter, orderBy: $orderBy) {
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              dappKey
+              canonicalOwner
+              userStorageId
+              createdAtCheckpoint
+              updatedAtCheckpoint
+              lastUpdateDigest
+              lastEventSeq
+            }
+          }
+        }
+      }
+    `;
+    const result = await this.apolloClient.query({
+      query,
+      variables: {
+        first: options?.first ?? 100,
+        after: options?.after,
+        filter: Object.keys(filter).length > 0 ? filter : void 0,
+        orderBy: ["CREATED_AT_CHECKPOINT_DESC"]
+      },
+      fetchPolicy: "network-only"
+    });
+    if (result.error)
+      throw result.error;
+    return result.data?.dubheUserStorages ?? {
+      edges: [],
+      pageInfo: { hasNextPage: false, hasPreviousPage: false },
+      totalCount: 0
+    };
+  }
+  /**
+   * Query SceneStorage system rows indexed by the Dubhe indexer
+   * (scene_storages table, exposed as dubheSceneStorages in GraphQL).
+   * Field values live in the companion scene_storage_fields table —
+   * see getSceneStorageFields.
+   */
+  async getSceneStorages(options) {
+    const filter = {};
+    if (options?.dappKey)
+      filter.dappKey = { equalTo: options.dappKey };
+    if (options?.sceneType)
+      filter.sceneType = { equalTo: options.sceneType };
+    if (options?.sceneId)
+      filter.sceneId = { equalTo: options.sceneId };
+    if (options?.isDestroyed !== void 0)
+      filter.isDestroyed = { equalTo: options.isDestroyed };
+    const query = gql`
+      query GetSceneStorages(
+        $first: Int
+        $after: Cursor
+        $filter: StoreDubheSceneStorageFilter
+        $orderBy: [StoreDubheSceneStoragesOrderBy!]
+      ) {
+        dubheSceneStorages(first: $first, after: $after, filter: $filter, orderBy: $orderBy) {
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              sceneId
+              dappKey
+              sceneType
+              authorizationKind
+              authorizedPermitId
+              isDestroyed
+              createdAtCheckpoint
+              updatedAtCheckpoint
+              lastUpdateDigest
+              lastEventSeq
+            }
+          }
+        }
+      }
+    `;
+    const result = await this.apolloClient.query({
+      query,
+      variables: {
+        first: options?.first ?? 100,
+        after: options?.after,
+        filter: Object.keys(filter).length > 0 ? filter : void 0,
+        orderBy: ["UPDATED_AT_CHECKPOINT_DESC"]
+      },
+      fetchPolicy: "network-only"
+    });
+    if (result.error)
+      throw result.error;
+    return result.data?.dubheSceneStorages ?? {
+      edges: [],
+      pageInfo: { hasNextPage: false, hasPreviousPage: false },
+      totalCount: 0
+    };
+  }
+  /**
+   * Query raw field rows of SceneStorages (scene_storage_fields table,
+   * exposed as dubheSceneStorageFields in GraphQL). Values are hex-encoded
+   * BCS — decode with the decoders exported from this package.
+   */
+  async getSceneStorageFields(options) {
+    const filter = {};
+    if (options?.dappKey)
+      filter.dappKey = { equalTo: options.dappKey };
+    if (options?.sceneIds && options.sceneIds.length > 0)
+      filter.sceneId = { in: options.sceneIds };
+    if (options?.sceneId)
+      filter.sceneId = { equalTo: options.sceneId };
+    if (options?.fieldName)
+      filter.fieldName = { equalTo: options.fieldName };
+    if (options?.isDeleted !== void 0)
+      filter.isDeleted = { equalTo: options.isDeleted };
+    const query = gql`
+      query GetSceneStorageFields(
+        $first: Int
+        $after: Cursor
+        $filter: StoreDubheSceneStorageFieldFilter
+        $orderBy: [StoreDubheSceneStorageFieldsOrderBy!]
+      ) {
+        dubheSceneStorageFields(first: $first, after: $after, filter: $filter, orderBy: $orderBy) {
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              sceneId
+              dappKey
+              sceneType
+              fieldName
+              fieldValueRaw
+              isDeleted
+              updatedAtCheckpoint
+              lastUpdateDigest
+              lastEventSeq
+            }
+          }
+        }
+      }
+    `;
+    const result = await this.apolloClient.query({
+      query,
+      variables: {
+        first: options?.first ?? 1e3,
+        after: options?.after,
+        filter: Object.keys(filter).length > 0 ? filter : void 0,
+        orderBy: ["UPDATED_AT_CHECKPOINT_DESC"]
+      },
+      fetchPolicy: "network-only"
+    });
+    if (result.error)
+      throw result.error;
+    return result.data?.dubheSceneStorageFields ?? {
+      edges: [],
+      pageInfo: { hasNextPage: false, hasPreviousPage: false },
+      totalCount: 0
+    };
+  }
+  /**
+   * Query ObjectStorage system rows indexed by the Dubhe indexer
+   * (object_storages table, exposed as dubheObjectStorages in GraphQL).
+   */
+  async getObjectStorages(options) {
+    const filter = {};
+    if (options?.dappKey)
+      filter.dappKey = { equalTo: options.dappKey };
+    if (options?.objectType)
+      filter.objectType = { equalTo: options.objectType };
+    if (options?.objectId)
+      filter.objectId = { equalTo: options.objectId };
+    if (options?.isDestroyed !== void 0)
+      filter.isDestroyed = { equalTo: options.isDestroyed };
+    const query = gql`
+      query GetObjectStorages(
+        $first: Int
+        $after: Cursor
+        $filter: StoreDubheObjectStorageFilter
+        $orderBy: [StoreDubheObjectStoragesOrderBy!]
+      ) {
+        dubheObjectStorages(first: $first, after: $after, filter: $filter, orderBy: $orderBy) {
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              objectId
+              dappKey
+              objectType
+              entityIdRaw
+              isDestroyed
+              createdAtCheckpoint
+              updatedAtCheckpoint
+              lastUpdateDigest
+              lastEventSeq
+            }
+          }
+        }
+      }
+    `;
+    const result = await this.apolloClient.query({
+      query,
+      variables: {
+        first: options?.first ?? 100,
+        after: options?.after,
+        filter: Object.keys(filter).length > 0 ? filter : void 0,
+        orderBy: ["UPDATED_AT_CHECKPOINT_DESC"]
+      },
+      fetchPolicy: "network-only"
+    });
+    if (result.error)
+      throw result.error;
+    return result.data?.dubheObjectStorages ?? {
+      edges: [],
+      pageInfo: { hasNextPage: false, hasPreviousPage: false },
+      totalCount: 0
+    };
+  }
+  /**
+   * Query DApp runtime state (credit pool, admin, package version, etc.).
+   * Exposed as dubheDappRuntimeStates in GraphQL.
+   */
+  async getDubheDappRuntimeState(dappKey) {
+    const query = gql`
+      query GetDubheDappRuntimeState($filter: StoreDubheDappRuntimeStateFilter) {
+        dubheDappRuntimeStates(first: 1, filter: $filter) {
+          edges {
+            node {
+              dappKey
+              admin
+              dappStorageId
+              packageId
+              version
+              creditPool
+              paused
+              settlementMode
+              createdAt
+              createdAtCheckpoint
+              updatedAtCheckpoint
+              lastUpdateDigest
+              lastEventSeq
+            }
+          }
+        }
+      }
+    `;
+    const result = await this.apolloClient.query({
+      query,
+      variables: { filter: { dappKey: { equalTo: dappKey } } },
+      fetchPolicy: "network-only"
+    });
+    if (result.error)
+      throw result.error;
+    const edges = result.data?.dubheDappRuntimeStates?.edges ?? [];
+    return edges[0]?.node ?? null;
+  }
   // Improved table name handling methods
   getFilterTypeName(tableName) {
     const singularName = this.getSingularTableName(tableName);
@@ -1602,15 +2107,55 @@ var DubheGraphqlClient = class {
     if (customFields && customFields.length > 0) {
       fields = customFields;
     } else {
-      const autoFields = this.getTableFields(tableName);
-      if (autoFields.length > 0) {
-        fields = autoFields;
+      const systemFields = SYSTEM_TABLE_FIELDS[tableName];
+      if (systemFields) {
+        fields = systemFields;
       } else {
-        fields = ["createdAtTimestampMs", "updatedAtTimestampMs", "isDeleted", "lastUpdateDigest"];
+        const autoFields = this.getTableFields(tableName);
+        if (autoFields.length > 0) {
+          fields = autoFields;
+        } else {
+          fields = [
+            "createdAtTimestampMs",
+            "updatedAtTimestampMs",
+            "isDeleted",
+            "lastUpdateDigest"
+          ];
+        }
       }
     }
     return fields.join("\n      ");
   }
+  // ── Typed system-table query methods ─────────────────────────────────────
+  /** Latest DApp fee state snapshot (credit_pool, total_settled, fee rates). */
+  async getDappFeeState() {
+    const result = await this.getAllTables("dubheDappFeeState", { first: 1 }).catch(
+      () => null
+    );
+    return result?.edges?.[0]?.node ?? null;
+  }
+  /** Latest DApp revenue balance (USER_PAYS mode collected revenue). */
+  async getDappRevenueState() {
+    const result = await this.getAllTables("dubheDappRevenueState", { first: 1 }).catch(
+      () => null
+    );
+    return result?.edges?.[0]?.node ?? null;
+  }
+  /** Latest DApp runtime state (admin, settlement mode, last event). */
+  async getDappRuntimeState() {
+    const result = await this.getAllTables("dubheDappRuntimeState", { first: 1 }).catch(
+      () => null
+    );
+    return result?.edges?.[0]?.node ?? null;
+  }
+  /** Marketplace fee records (one row per listing sold). */
+  async getDappMarketplaceFees(options) {
+    return this.getAllTables("dubheDappMarketplaceFees", {
+      first: options?.first ?? 20,
+      after: options?.after,
+      orderBy: [{ field: "updatedAtCheckpoint", direction: "DESC" }]
+    });
+  }
 };
 function createDubheGraphqlClient(config) {
   return new DubheGraphqlClient(config);
@@ -1671,9 +2216,96 @@ function toSnakeCaseForEnum(str) {
   }
   return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "").toUpperCase();
 }
+
+// src/decoders.ts
+var ZERO_ADDRESS = "0x" + "0".repeat(64);
+function hexToBytes(hex) {
+  const clean = hex.replace(/^0x/i, "");
+  const pairs = clean.match(/../g) ?? [];
+  return Uint8Array.from(pairs.map((b) => parseInt(b, 16)));
+}
+function readUIntLE(bytes, offset, width) {
+  let n = 0n;
+  for (let i = width - 1; i >= 0; i--) {
+    n = n << 8n | BigInt(bytes[offset + i] ?? 0);
+  }
+  return n;
+}
+function readUleb(bytes, offset) {
+  let value = 0;
+  let shift = 0;
+  let consumed = 0;
+  for (; ; ) {
+    const byte = bytes[offset + consumed] ?? 0;
+    value |= (byte & 127) << shift;
+    consumed++;
+    if ((byte & 128) === 0)
+      break;
+    shift += 7;
+  }
+  return [value, consumed];
+}
+function decodeU8(hex) {
+  return Number(readUIntLE(hexToBytes(hex), 0, 1));
+}
+function decodeU16(hex) {
+  return Number(readUIntLE(hexToBytes(hex), 0, 2));
+}
+function decodeU32(hex) {
+  return Number(readUIntLE(hexToBytes(hex), 0, 4));
+}
+function decodeU64(hex) {
+  return readUIntLE(hexToBytes(hex), 0, 8);
+}
+function decodeU128(hex) {
+  return readUIntLE(hexToBytes(hex), 0, 16);
+}
+function decodeBool(hex) {
+  return (hexToBytes(hex)[0] ?? 0) !== 0;
+}
+function decodeAddress(hex) {
+  const bytes = hexToBytes(hex);
+  return "0x" + Array.from(bytes.slice(0, 32), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function decodeVectorAddress(hex) {
+  const bytes = hexToBytes(hex);
+  const [len, consumed] = readUleb(bytes, 0);
+  const out = [];
+  for (let i = 0; i < len; i++) {
+    const start = consumed + i * 32;
+    out.push(
+      "0x" + Array.from(bytes.slice(start, start + 32), (b) => b.toString(16).padStart(2, "0")).join("")
+    );
+  }
+  return out;
+}
+function decodeString(hex) {
+  const bytes = hexToBytes(hex);
+  const [len, consumed] = readUleb(bytes, 0);
+  return new TextDecoder().decode(bytes.slice(consumed, consumed + len));
+}
+function parseRecordData(recordDataRaw) {
+  try {
+    return JSON.parse(recordDataRaw);
+  } catch {
+    return [recordDataRaw];
+  }
+}
 export {
   DubheGraphqlClient,
   QueryBuilders,
-  createDubheGraphqlClient
+  ZERO_ADDRESS,
+  createDubheGraphqlClient,
+  decodeAddress,
+  decodeBool,
+  decodeString,
+  decodeU128,
+  decodeU16,
+  decodeU32,
+  decodeU64,
+  decodeU8,
+  decodeVectorAddress,
+  hexToBytes,
+  parseRecordData
 };
 //# sourceMappingURL=index.mjs.map