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

package/src/decoders.ts

@@ -0,0 +1,100 @@
+/**
+ * Minimal BCS decoders for indexer raw values.
+ *
+ * The Dubhe indexer stores scene/object field values and marketplace record
+ * data as hex-encoded BCS bytes (e.g. "0x0c00000000000000" for u64 12).
+ * These helpers decode the primitive types commonly stored in system tables.
+ */
+
+export const ZERO_ADDRESS = '0x' + '0'.repeat(64);
+
+export function hexToBytes(hex: string): Uint8Array {
+  const clean = hex.replace(/^0x/i, '');
+  const pairs = clean.match(/../g) ?? [];
+  return Uint8Array.from(pairs.map((b) => parseInt(b, 16)));
+}
+
+function readUIntLE(bytes: Uint8Array, offset: number, width: number): bigint {
+  let n = 0n;
+  for (let i = width - 1; i >= 0; i--) {
+    n = (n << 8n) | BigInt(bytes[offset + i] ?? 0);
+  }
+  return n;
+}
+
+/** Read a ULEB128-encoded length prefix. Returns [value, bytesConsumed]. */
+function readUleb(bytes: Uint8Array, offset: number): [number, number] {
+  let value = 0;
+  let shift = 0;
+  let consumed = 0;
+  for (;;) {
+    const byte = bytes[offset + consumed] ?? 0;
+    value |= (byte & 0x7f) << shift;
+    consumed++;
+    if ((byte & 0x80) === 0) break;
+    shift += 7;
+  }
+  return [value, consumed];
+}
+
+export function decodeU8(hex: string): number {
+  return Number(readUIntLE(hexToBytes(hex), 0, 1));
+}
+
+export function decodeU16(hex: string): number {
+  return Number(readUIntLE(hexToBytes(hex), 0, 2));
+}
+
+export function decodeU32(hex: string): number {
+  return Number(readUIntLE(hexToBytes(hex), 0, 4));
+}
+
+export function decodeU64(hex: string): bigint {
+  return readUIntLE(hexToBytes(hex), 0, 8);
+}
+
+export function decodeU128(hex: string): bigint {
+  return readUIntLE(hexToBytes(hex), 0, 16);
+}
+
+export function decodeBool(hex: string): boolean {
+  return (hexToBytes(hex)[0] ?? 0) !== 0;
+}
+
+export function decodeAddress(hex: string): string {
+  const bytes = hexToBytes(hex);
+  return '0x' + Array.from(bytes.slice(0, 32), (b) => b.toString(16).padStart(2, '0')).join('');
+}
+
+export function decodeVectorAddress(hex: string): string[] {
+  const bytes = hexToBytes(hex);
+  const [len, consumed] = readUleb(bytes, 0);
+  const out: string[] = [];
+  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;
+}
+
+/** Decode a BCS ascii/utf8 String (ULEB length prefix + bytes). */
+export function decodeString(hex: string): string {
+  const bytes = hexToBytes(hex);
+  const [len, consumed] = readUleb(bytes, 0);
+  return new TextDecoder().decode(bytes.slice(consumed, consumed + len));
+}
+
+/**
+ * Marketplace recordDataRaw is a JSON array of per-field hex strings
+ * (non-key fields, in schema order).
+ */
+export function parseRecordData(recordDataRaw: string): string[] {
+  try {
+    return JSON.parse(recordDataRaw) as string[];
+  } catch {
+    return [recordDataRaw];
+  }
+}

package/src/index.ts

@@ -1,3 +1,4 @@
 export { DubheGraphqlClient, createDubheGraphqlClient, QueryBuilders } from './client';
 export * from './types';
 export type * from './types';
+export * from './decoders';

package/src/types.ts

@@ -116,6 +116,105 @@ export interface StoreTableRow {
   [key: string]: any;
 }
 
+export interface MarketplaceListingRow {
+  listingId: string;
+  dappKey: string;
+  seller: string;
+  recordType: string;
+  recordDataRaw: string;
+  price: string;
+  coinType: string;
+  isFungible: boolean;
+  status: 'listed' | 'sold' | 'cancelled' | 'expired';
+  buyer?: string | null;
+  listedUntil?: string | null;
+  createdAtCheckpoint: string;
+  updatedAtCheckpoint: string;
+  lastUpdateDigest: string;
+}
+
+export interface DubheSessionRow {
+  dappKey: string;
+  canonical: string;
+  sessionWallet: string;
+  expiresAt?: string | null;
+  active: boolean;
+  updatedAtCheckpoint: string;
+  lastUpdateDigest: string;
+  lastEventSeq: string;
+}
+
+export interface DubheUserStorageRow {
+  dappKey: string;
+  canonicalOwner: string;
+  userStorageId: string;
+  createdAtCheckpoint: string;
+  updatedAtCheckpoint: string;
+  lastUpdateDigest: string;
+  lastEventSeq: string;
+}
+
+export interface SceneStorageRow {
+  sceneId: string;
+  dappKey: string;
+  sceneType: string;
+  sceneTypeRaw: string;
+  authorizationKind?: string | null;
+  authorizationKindRaw?: string | null;
+  authorizedPermitId?: string | null;
+  isDestroyed: boolean;
+  createdAtCheckpoint: string;
+  destroyedAtCheckpoint?: string | null;
+  updatedAtCheckpoint: string;
+  lastUpdateDigest: string;
+  lastEventSeq: string;
+}
+
+export interface SceneStorageFieldRow {
+  sceneId: string;
+  fieldNameRaw: string;
+  dappKey: string;
+  sceneType: string;
+  sceneTypeRaw: string;
+  fieldName: string;
+  fieldValueRaw?: string | null;
+  isDeleted: boolean;
+  deletedAtCheckpoint?: string | null;
+  updatedAtCheckpoint: string;
+  lastUpdateDigest: string;
+  lastEventSeq: string;
+}
+
+export interface ObjectStorageRow {
+  objectId: string;
+  dappKey: string;
+  objectType: string;
+  objectTypeRaw: string;
+  entityIdRaw: string;
+  isDestroyed: boolean;
+  createdAtCheckpoint: string;
+  destroyedAtCheckpoint?: string | null;
+  updatedAtCheckpoint: string;
+  lastUpdateDigest: string;
+  lastEventSeq: string;
+}
+
+export interface DubheDappRuntimeStateRow {
+  dappKey: string;
+  admin?: string | null;
+  dappStorageId?: string | null;
+  packageId?: string | null;
+  version?: string | null;
+  creditPool?: string | null;
+  paused?: boolean | null;
+  settlementMode?: string | null;
+  createdAt?: string | null;
+  createdAtCheckpoint: string;
+  updatedAtCheckpoint: string;
+  lastUpdateDigest: string;
+  lastEventSeq: string;
+}
+
 // Query builder type
 export interface QueryBuilder<_T> {
   where?: Record<string, any>;
@@ -274,6 +373,27 @@ export interface DubheClientConfig {
   fetchOptions?: RequestInit;
   retryOptions?: RetryOptions;
   dubheMetadata?: any;
+  /**
+   * When true, outgoing HTTP queries are collected within `batchInterval` ms
+   * and sent as a single batched POST request. The server must have
+   * `enableQueryBatching` / `allowBatchedHttpRequests` enabled (PostGraphile
+   * already sets this by default).
+   *
+   * Default: false
+   */
+  batchRequests?: boolean;
+  /**
+   * Time window (ms) to collect queries before flushing a batch.
+   * Only used when `batchRequests` is true.
+   * Default: 10
+   */
+  batchInterval?: number;
+  /**
+   * Maximum number of operations per batch.
+   * Only used when `batchRequests` is true.
+   * Default: 20
+   */
+  batchMax?: number;
   cacheConfig?: {
     paginatedTables?: string[];
     strategy?: PaginationCacheStrategy;