opacity-issuer-core 0.2.1

package/dist/subgraph.js

@@ -0,0 +1,882 @@
+import { OpacityIssuerError } from './chunk-54Q3MU62.js';
+
+// src/indexer/errors.ts
+var OpacityIndexerError = class extends OpacityIssuerError {
+  constructor(code, message, options2) {
+    super(message, options2);
+    this.code = code;
+    this.name = "OpacityIndexerError";
+  }
+  code;
+};
+
+// src/indexer/executor.ts
+function validateSubgraphUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (!["http:", "https:"].includes(parsed.protocol) || parsed.username || parsed.password)
+      throw new Error("Invalid URL");
+  } catch (cause) {
+    throw new OpacityIndexerError(
+      "INVALID_ARGUMENT",
+      "Subgraph URL must use HTTP(S) without embedded credentials.",
+      { cause }
+    );
+  }
+}
+function createGraphqlExecutor(config) {
+  const fetchImpl = config.fetch ?? globalThis.fetch?.bind(globalThis);
+  if (config.url) validateSubgraphUrl(config.url);
+  return async (query, variables = {}, options2 = {}) => {
+    if (!config.url)
+      throw new OpacityIndexerError(
+        "NOT_CONFIGURED",
+        "Configure a subgraph URL to use indexed reads."
+      );
+    if (!fetchImpl)
+      throw new OpacityIndexerError("NOT_CONFIGURED", "A fetch implementation is required.");
+    const timeoutMs = options2.timeoutMs ?? config.timeoutMs ?? 3e4;
+    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647)
+      throw new OpacityIndexerError(
+        "INVALID_ARGUMENT",
+        "timeoutMs must be a positive 32-bit integer."
+      );
+    if (options2.signal?.aborted)
+      throw new OpacityIndexerError("ABORTED", "Subgraph request cancelled before it started.");
+    const controller = new AbortController();
+    let timedOut = false;
+    const onAbort = () => controller.abort();
+    options2.signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    let cancellation;
+    const cancellationError = (cause) => new OpacityIndexerError(
+      timedOut ? "TIMEOUT" : "ABORTED",
+      timedOut ? "Subgraph request timed out." : "Subgraph request cancelled.",
+      { cause }
+    );
+    const aborted = new Promise((_, reject) => {
+      cancellation = () => reject(cancellationError());
+      controller.signal.addEventListener("abort", cancellation, { once: true });
+    });
+    try {
+      return await Promise.race([
+        (async () => {
+          const response = await fetchImpl(config.url, {
+            method: "POST",
+            headers: {
+              accept: "application/json",
+              "content-type": "application/json",
+              ...config.headers
+            },
+            credentials: "omit",
+            signal: controller.signal,
+            body: JSON.stringify({ query, variables })
+          });
+          if (!response.ok)
+            throw new OpacityIndexerError("HTTP", `Subgraph returned HTTP ${response.status}.`);
+          const payload = await response.json();
+          if (!payload || typeof payload !== "object" || Array.isArray(payload))
+            throw new OpacityIndexerError("INVALID_RESPONSE", "Malformed subgraph response.");
+          const envelope = payload;
+          if (envelope["errors"] !== void 0) {
+            if (!Array.isArray(envelope["errors"]))
+              throw new OpacityIndexerError("INVALID_RESPONSE", "Malformed subgraph errors.");
+            if (envelope["errors"].length > 0)
+              throw new OpacityIndexerError(
+                "GRAPHQL",
+                "Subgraph returned GraphQL errors; partial data was discarded.",
+                { cause: envelope["errors"] }
+              );
+          }
+          if (!envelope["data"] || typeof envelope["data"] !== "object" || Array.isArray(envelope["data"]))
+            throw new OpacityIndexerError("INVALID_RESPONSE", "Subgraph returned no data object.");
+          return envelope["data"];
+        })(),
+        aborted
+      ]);
+    } catch (cause) {
+      if (cause instanceof OpacityIndexerError) throw cause;
+      if (controller.signal.aborted) throw cancellationError(cause);
+      throw new OpacityIndexerError("TRANSPORT", "Subgraph request or response decoding failed.", {
+        cause
+      });
+    } finally {
+      clearTimeout(timer);
+      options2.signal?.removeEventListener("abort", onAbort);
+      if (cancellation) controller.signal.removeEventListener("abort", cancellation);
+      controller.abort();
+    }
+  };
+}
+
+// src/indexer/arguments.ts
+function invalid(path) {
+  throw new OpacityIndexerError("INVALID_ARGUMENT", `Invalid indexer argument at ${path}.`);
+}
+var optional = (rule) => (value, path) => {
+  if (value !== void 0) rule(value, path);
+};
+var string = (pattern, min = 0, max = Infinity) => (value, path) => {
+  if (typeof value !== "string" || value.length < min || value.length > max || !pattern.test(value))
+    invalid(path);
+};
+var address = string(/^0x[0-9a-fA-F]{40}$/);
+var bytes32 = string(/^0x[0-9a-fA-F]{64}$/);
+var uint = (max) => (value, path) => {
+  if (typeof value !== "bigint" || value < 0n || value > max) invalid(path);
+};
+var uint256 = uint((1n << 256n) - 1n);
+var blockNumber = uint(2147483647n);
+var integer = (min, max) => (value, path) => {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < min || value > max)
+    invalid(path);
+};
+var boolean = (value, path) => {
+  if (typeof value !== "boolean") invalid(path);
+};
+var object = (fields, refine) => (value, path) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) invalid(path);
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) invalid(path);
+  const input = value;
+  for (const key of Object.keys(input)) {
+    if (!Object.hasOwn(fields, key)) invalid(`${path}.${key}`);
+  }
+  for (const [key, rule] of Object.entries(fields)) rule(input[key], `${path}.${key}`);
+  refine?.(input, path);
+};
+var snapshot = {
+  blockNumber: optional(blockNumber),
+  blockHash: optional(bytes32),
+  timeoutMs: optional(integer(1, 2147483647)),
+  // Signals are local request controls. JSON objects cannot impersonate an AbortSignal.
+  signal: optional((value, path) => {
+    if (typeof AbortSignal === "undefined" || !(value instanceof AbortSignal)) invalid(path);
+  })
+};
+var page = {
+  ...snapshot,
+  pageSize: optional(integer(1, 999)),
+  cursor: optional(
+    object({
+      after: string(/^0x(?:[0-9a-fA-F]{2})*$/, 2, 1024),
+      blockNumber,
+      blockHash: (value, path) => {
+        if (value !== null) bytes32(value, path);
+      },
+      deployment: string(/[\s\S]*/, 1, 512),
+      scope: string(/[\s\S]*/, 1, 4096)
+    })
+  )
+};
+var options = optional(object(snapshot));
+var list = (fields, required = false, refine) => {
+  const params = object({ ...page, ...fields }, refine);
+  return [required ? params : optional(params)];
+};
+var vault = { token: optional(address), vault: optional(address) };
+var operationArguments = {
+  getMetadata: [options],
+  getRegistry: [options],
+  getToken: [address, options],
+  getAccount: [address, options],
+  getUser: [bytes32, options],
+  getVault: [address, options],
+  listTokens: list({ issuer: optional(address), registry: optional(address) }),
+  listTokenIds: list({ token: address }, true),
+  listTokenURIs: list({ token: address }, true),
+  listPolicies: list({ token: address, active: optional(boolean) }, true),
+  listUserAccounts: list({ userId: bytes32 }, true),
+  listGlobalTraits: list({ userId: bytes32 }, true),
+  listTokenTraits: list({ userId: bytes32, token: optional(address) }, true),
+  listBalances: list(
+    {
+      wallet: optional(address),
+      userId: optional(bytes32),
+      token: optional(address),
+      tokenId: optional(uint256),
+      positiveOnly: optional(boolean)
+    },
+    false,
+    (value, path) => {
+      const input = value;
+      if (input["wallet"] !== void 0 && input["userId"] !== void 0)
+        invalid(`${path}.wallet/userId`);
+    }
+  ),
+  listTransfers: list({
+    wallet: optional(address),
+    token: optional(address),
+    tokenId: optional(uint256)
+  }),
+  listDocumentAttestations: list({
+    wallet: optional(address),
+    userId: optional(bytes32),
+    traitId: optional(bytes32)
+  }),
+  listVaults: list({ token: optional(address) }),
+  listVaultDeposits: list({ ...vault, wallet: optional(address) }),
+  listVaultWithdrawals: list({ ...vault, wallet: optional(address) }),
+  listVaultAdminExecutions: list({ ...vault, owner: optional(address), target: optional(address) })
+};
+var INDEXER_OPERATIONS = Object.freeze(
+  Object.keys(operationArguments)
+);
+function validateIndexerOperationArgs(operation, args) {
+  if (!Object.hasOwn(operationArguments, operation) || !Array.isArray(args)) invalid("args");
+  const rules = operationArguments[operation];
+  if (args.length > rules.length) invalid("args.length");
+  rules.forEach((rule, index) => rule(args[index], `args[${index}]`));
+  return [...args];
+}
+
+// src/indexer/index.ts
+function invalid2(path) {
+  throw new OpacityIndexerError("INVALID_RESPONSE", `Malformed indexer response at ${path}.`);
+}
+function record(value, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) invalid2(path);
+  return value;
+}
+var stringField = {
+  parse: (v, p) => typeof v === "string" ? v : invalid2(p)
+};
+var bool = {
+  parse: (v, p) => typeof v === "boolean" ? v : invalid2(p)
+};
+var uint2 = {
+  parse: (v, p, domain) => domain ? typeof v === "bigint" && v >= 0n ? v : invalid2(p) : typeof v === "string" && /^(0|[1-9][0-9]*)$/.test(v) ? BigInt(v) : invalid2(p)
+};
+var graphInt = {
+  parse: (v, p, domain) => domain ? typeof v === "bigint" && v >= 0n && v <= BigInt(Number.MAX_SAFE_INTEGER) ? v : invalid2(p) : typeof v === "number" && Number.isSafeInteger(v) && v >= 0 ? BigInt(v) : invalid2(p)
+};
+function hex(bytes) {
+  return {
+    parse: (v, p) => {
+      if (typeof v !== "string" || !/^0x(?:[0-9a-fA-F]{2})*$/.test(v)) invalid2(p);
+      if (bytes !== void 0 && v.length !== 2 + bytes * 2) invalid2(p);
+      return v.toLowerCase();
+    }
+  };
+}
+var address2 = hex(20);
+var bytes322 = hex(32);
+function nullable(field) {
+  return {
+    ...field.selection === void 0 ? {} : { selection: field.selection },
+    parse: (v, p, domain) => v === null ? null : field.parse(v, p, domain)
+  };
+}
+function array(field) {
+  return {
+    parse: (v, p, domain) => {
+      if (!Array.isArray(v)) invalid2(p);
+      return v.map((item, i) => field.parse(item, `${p}[${i}]`, domain));
+    }
+  };
+}
+function enumeration(values) {
+  return {
+    parse: (v, p) => typeof v === "string" && values.includes(v) ? v : invalid2(p)
+  };
+}
+function object2(fields) {
+  return {
+    selection: Object.entries(fields).map(([key, field]) => `${key}${field.selection ? ` { ${field.selection} }` : ""}`).join(" "),
+    parse: (v, p, domain) => {
+      const input = record(v, p);
+      return Object.fromEntries(
+        Object.entries(fields).map(([key, field]) => [
+          key,
+          field.parse(input[key], `${p}.${key}`, domain)
+        ])
+      );
+    }
+  };
+}
+var addressRef = object2({ id: address2 });
+var userRef = object2({ id: bytes322 });
+var metaField = object2({
+  deployment: stringField,
+  hasIndexingErrors: bool,
+  block: object2({ number: graphInt, hash: nullable(bytes322), timestamp: nullable(graphInt) })
+});
+var tokenField = object2({
+  id: address2,
+  issuer: addressRef,
+  issuerAdmin: nullable(address2),
+  allowlistRegistry: address2,
+  name: nullable(stringField),
+  symbol: nullable(stringField),
+  paused: bool,
+  mintingPaused: bool,
+  policyEngine: nullable(address2),
+  transferOperator: nullable(address2),
+  tokenTraitRegistry: nullable(address2),
+  maxPolicies: nullable(uint2),
+  activePolicyCount: uint2,
+  activeRuleSetSnapshot: nullable(bytes322),
+  ruleSetDeploymentCount: uint2,
+  deployedAtBlock: uint2,
+  deployedAtTimestamp: uint2,
+  deployTxHash: bytes322,
+  beaconVariant: nullable(object2({ id: bytes322, beacon: address2, isActive: bool }))
+});
+var supplyField = object2({
+  id: hex(),
+  token: addressRef,
+  tokenId: uint2,
+  totalSupply: uint2,
+  maxSupply: uint2,
+  holderCount: uint2
+});
+var policyType = enumeration([
+  "TRADING_DISABLED_V1",
+  "ALLOWED_TRANSFEREE_V1",
+  "HOLDER_COUNT_CAP_V1",
+  "CEILING_BALANCE_V1",
+  "FLOOR_BALANCE_V1",
+  "DENYLIST_V1",
+  "INSIDER_FREEZE_V1",
+  "SELF_TRANSFER_ONLY_V1",
+  "UNKNOWN"
+]);
+var guardMode = enumeration([
+  "NONE",
+  "ONLY_IF_FROM_HAS",
+  "ONLY_IF_TO_HAS",
+  "ONLY_IF_EITHER_HAS"
+]);
+var policyField = object2({
+  id: hex(),
+  token: addressRef,
+  implementation: object2({
+    id: address2,
+    status: enumeration(["UNKNOWN", "PENDING", "APPROVED", "REVOKED", "CANCELLED"])
+  }),
+  policyType,
+  scopeKey: bytes322,
+  active: bool,
+  rawConfig: hex(),
+  guardTrait: bytes322,
+  guardMode,
+  guardTraitIsGlobal: bool,
+  configEnabled: nullable(bool),
+  configMaxHolders: nullable(uint2),
+  configIsPercentage: nullable(bool),
+  configCeiling: nullable(uint2),
+  configDenominatorMode: nullable(enumeration(["CURRENT_SUPPLY", "MAX_SUPPLY"])),
+  configTraitList: nullable(array(bytes322)),
+  configRequireAll: nullable(bool),
+  attachedAtBlock: uint2,
+  lastReconfiguredAtBlock: nullable(uint2)
+});
+var entryField = object2({
+  id: address2,
+  status: enumeration(["VERIFIED", "COMPLIANCE_REMOVAL", "USER_REMOVAL", "MIGRATED"]),
+  user: nullable(userRef),
+  expiresAt: nullable(uint2),
+  addedBy: nullable(address2),
+  migratedTo: nullable(address2),
+  migratedFrom: nullable(address2),
+  lastUpdatedBlock: uint2,
+  lastUpdatedTimestamp: uint2
+});
+var accountField = object2({
+  id: address2,
+  isAuthorizedIssuer: bool,
+  allowlistEntry: nullable(entryField)
+});
+var globalTraitField = object2({
+  id: hex(),
+  user: userRef,
+  traitId: bytes322,
+  enabled: bool,
+  lastUpdatedBy: address2,
+  lastUpdatedBlock: uint2,
+  lastUpdatedTimestamp: uint2,
+  traitConfig: object2({ expiryDuration: uint2, teeEnableable: bool, writerEnableable: bool })
+});
+var tokenTraitField = object2({
+  id: hex(),
+  token: addressRef,
+  user: userRef,
+  traitId: bytes322,
+  enabled: bool,
+  lastUpdatedBlock: uint2,
+  lastUpdatedTimestamp: uint2
+});
+var walletBalanceField = object2({
+  id: hex(),
+  token: addressRef,
+  account: addressRef,
+  tokenId: uint2,
+  balance: uint2,
+  frozenAmount: uint2
+});
+var userBalanceField = object2({
+  id: hex(),
+  token: addressRef,
+  user: userRef,
+  tokenId: uint2,
+  balance: uint2,
+  openIntervalId: nullable(hex())
+});
+var transferField = object2({
+  id: hex(),
+  token: addressRef,
+  operator: address2,
+  from: addressRef,
+  to: addressRef,
+  tokenId: uint2,
+  value: uint2,
+  isBatch: bool,
+  batchIndex: graphInt,
+  blockNumber: uint2,
+  blockTimestamp: uint2,
+  transactionHash: bytes322,
+  logIndex: uint2
+});
+var attestationField = object2({
+  id: bytes322,
+  attestor: addressRef,
+  document: object2({ id: bytes322 }),
+  user: userRef,
+  wallet: address2,
+  traitId: bytes322,
+  docHash: bytes322,
+  nonce: bytes322,
+  globalTrait: object2({ id: hex(), enabled: bool }),
+  blockNumber: uint2,
+  blockTimestamp: uint2,
+  transactionHash: bytes322,
+  logIndex: uint2
+});
+var registryField = object2({
+  id: stringField,
+  contractAddress: address2,
+  paused: bool,
+  defaultExpiryDuration: nullable(uint2),
+  authorizedSigner: nullable(address2),
+  teeTraitAllowlistEnforced: bool
+});
+var uriField = object2({
+  id: hex(),
+  token: addressRef,
+  tokenId: uint2,
+  uri: stringField,
+  lastUpdatedBlock: uint2
+});
+var vaultField = object2({
+  id: address2,
+  token: addressRef,
+  tokenId: uint2,
+  stablecoin: address2,
+  firstObservedAtBlock: uint2,
+  firstObservedAtTimestamp: uint2,
+  firstObservedTxHash: bytes322,
+  depositCount: uint2,
+  withdrawalCount: uint2,
+  totalDeposited: uint2,
+  totalWithdrawn: uint2,
+  adminExecutionCount: uint2
+});
+var vaultEventFields = {
+  id: hex(),
+  vault: addressRef,
+  token: addressRef,
+  blockNumber: uint2,
+  blockTimestamp: uint2,
+  transactionHash: bytes322
+};
+var vaultMovementField = object2({ ...vaultEventFields, user: addressRef, amount: uint2 });
+var vaultAdminField = object2({
+  ...vaultEventFields,
+  owner: address2,
+  target: address2,
+  selector: hex(4)
+});
+function argument(field, value, name) {
+  try {
+    return field.parse(value, name);
+  } catch (cause) {
+    throw new OpacityIndexerError("INVALID_ARGUMENT", `Invalid ${name}.`, { cause });
+  }
+}
+function bigintArgument(value, name) {
+  if (typeof value !== "bigint" || value < 0n) {
+    throw new OpacityIndexerError("INVALID_ARGUMENT", `${name} must be a nonnegative bigint.`);
+  }
+  return value.toString();
+}
+function blockVariable(value, hash) {
+  if (value !== void 0) bigintArgument(value, "blockNumber");
+  if (value !== void 0 && value > 2147483647n) {
+    throw new OpacityIndexerError("INVALID_ARGUMENT", "blockNumber exceeds the GraphQL Int range.");
+  }
+  if (hash !== void 0) return { hash: argument(bytes322, hash, "blockHash") };
+  return value === void 0 ? null : { number: Number(value) };
+}
+function validateSnapshot(meta, blockNumber2, blockHash) {
+  if (blockNumber2 !== void 0 && meta.block.number !== blockNumber2) invalid2("_meta.block.number");
+  if (blockHash !== void 0 && meta.block.hash !== null && meta.block.hash !== blockHash.toLowerCase()) {
+    throw new OpacityIndexerError(
+      "SNAPSHOT_CHANGED",
+      "Indexed block hash changed; restart the snapshot."
+    );
+  }
+}
+function requireHealthyIndex(meta) {
+  if (meta.hasIndexingErrors) {
+    throw new OpacityIndexerError(
+      "INDEXING_ERROR",
+      "Subgraph reports indexing errors; indexed entity data was discarded."
+    );
+  }
+}
+function createIndexerNamespace(config) {
+  const request = createGraphqlExecutor(config);
+  async function single(entity, id, field, options2 = {}) {
+    const data = await request(
+      `query IndexedSingle($id:ID!,$block:Block_height){item:${entity}(id:$id,block:$block){${field.selection}} _meta(block:$block){${metaField.selection}}}`,
+      { id, block: blockVariable(options2.blockNumber, options2.blockHash) },
+      options2
+    );
+    const item = nullable(field).parse(data.item, "item");
+    if (item !== null && record(item, "item").id !== id) invalid2("item.id");
+    const meta = metaField.parse(data._meta, "_meta");
+    validateSnapshot(meta, options2.blockNumber, options2.blockHash);
+    requireHealthyIndex(meta);
+    return { item, meta };
+  }
+  async function page2(entity, filterType, field, filters, options2) {
+    const size = options2.pageSize ?? 100;
+    if (!Number.isInteger(size) || size < 1 || size > 999) {
+      throw new OpacityIndexerError("INVALID_ARGUMENT", "pageSize must be an integer from 1\u2013999.");
+    }
+    const scope = `${entity}:${JSON.stringify(filters)}`;
+    const cursor = options2.cursor;
+    if (cursor) {
+      argument(hex(), cursor.after, "cursor.after");
+      bigintArgument(cursor.blockNumber, "cursor.blockNumber");
+      argument(stringField, cursor.deployment, "cursor.deployment");
+      argument(nullable(bytes322), cursor.blockHash, "cursor.blockHash");
+      if (cursor.scope !== scope || options2.blockNumber !== void 0 && options2.blockNumber !== cursor.blockNumber || options2.blockHash !== void 0 && options2.blockHash.toLowerCase() !== cursor.blockHash) {
+        throw new OpacityIndexerError(
+          "INVALID_ARGUMENT",
+          "Cursor does not match the query filters or block."
+        );
+      }
+    }
+    const after = cursor?.after ?? "0x";
+    const blockNumber2 = cursor?.blockNumber ?? options2.blockNumber;
+    const blockHash = cursor?.blockHash ?? options2.blockHash;
+    const block = blockVariable(blockNumber2, blockHash);
+    const where = Array.isArray(filters.or) ? { or: filters.or.map((branch) => ({ ...record(branch, "filter"), id_gt: after })) } : { ...filters, id_gt: after };
+    const data = await request(
+      `query IndexedPage($first:Int!,$where:${filterType}!,$block:Block_height){items:${entity}(first:$first,orderBy:id,orderDirection:asc,where:$where,block:$block){${field.selection}} _meta(block:$block){${metaField.selection}}}`,
+      { first: size + 1, where, block },
+      options2
+    );
+    const meta = metaField.parse(data._meta, "_meta");
+    requireHealthyIndex(meta);
+    if (cursor && cursor.deployment !== meta.deployment) {
+      throw new OpacityIndexerError(
+        "DEPLOYMENT_CHANGED",
+        "Subgraph deployment changed; restart pagination."
+      );
+    }
+    validateSnapshot(meta, blockNumber2, blockHash);
+    const rows = array(field).parse(data.items, "items");
+    if (rows.length > size + 1) invalid2("items.length");
+    let previous = after;
+    for (const row of rows) {
+      if (row.id <= previous) invalid2("items.id order");
+      previous = row.id;
+    }
+    const items = rows.slice(0, size);
+    return {
+      items,
+      meta,
+      nextCursor: rows.length > size ? {
+        after: items[items.length - 1].id,
+        blockNumber: meta.block.number,
+        blockHash: blockHash ?? meta.block.hash,
+        deployment: meta.deployment,
+        scope
+      } : null
+    };
+  }
+  const tokenFilters = (p) => ({ token: argument(address2, p.token, "token") });
+  const userFilters = (p) => ({ user: argument(bytes322, p.userId, "userId") });
+  const vaultFilters = (p) => ({
+    ...p.token === void 0 ? {} : tokenFilters({ token: p.token }),
+    ...p.vault === void 0 ? {} : { vault: argument(address2, p.vault, "vault") }
+  });
+  const vaultMovementFilters = (p) => ({
+    ...vaultFilters(p),
+    ...p.wallet === void 0 ? {} : { user: argument(address2, p.wallet, "wallet") }
+  });
+  const namespace = {
+    async getMetadata(options2 = {}) {
+      const data = await request(
+        `query IndexingMetadata($block:Block_height){_meta(block:$block){${metaField.selection}}}`,
+        { block: blockVariable(options2.blockNumber, options2.blockHash) },
+        options2
+      );
+      const meta = metaField.parse(data._meta, "_meta");
+      validateSnapshot(meta, options2.blockNumber, options2.blockHash);
+      return meta;
+    },
+    getRegistry: (options2) => single("allowlistRegistryState", "registry", registryField, options2),
+    getVault: (vault2, options2) => single("issuerVault", argument(address2, vault2, "vault"), vaultField, options2),
+    listVaults: (p = {}) => page2("issuerVaults", "IssuerVault_filter", vaultField, vaultFilters(p), p),
+    listVaultDeposits: (p = {}) => page2(
+      "vaultDepositEvents",
+      "VaultDepositEvent_filter",
+      vaultMovementField,
+      vaultMovementFilters(p),
+      p
+    ),
+    listVaultWithdrawals: (p = {}) => page2(
+      "vaultWithdrawalEvents",
+      "VaultWithdrawalEvent_filter",
+      vaultMovementField,
+      vaultMovementFilters(p),
+      p
+    ),
+    listVaultAdminExecutions: (p = {}) => page2(
+      "vaultAdminExecutedEvents",
+      "VaultAdminExecutedEvent_filter",
+      vaultAdminField,
+      {
+        ...vaultFilters(p),
+        ...p.owner === void 0 ? {} : { owner: argument(address2, p.owner, "owner") },
+        ...p.target === void 0 ? {} : { target: argument(address2, p.target, "target") }
+      },
+      p
+    ),
+    listTokens: (p = {}) => page2(
+      "tokens",
+      "Token_filter",
+      tokenField,
+      {
+        ...p.issuer === void 0 ? {} : { issuer: argument(address2, p.issuer, "issuer") },
+        ...p.registry === void 0 ? {} : { allowlistRegistry: argument(address2, p.registry, "registry") }
+      },
+      p
+    ),
+    getToken: (token, options2) => single("token", argument(address2, token, "token"), tokenField, options2),
+    listTokenIds: (p) => page2("tokenSupplies", "TokenSupply_filter", supplyField, tokenFilters(p), p),
+    listTokenURIs: (p) => page2("tokenURIs", "TokenURI_filter", uriField, tokenFilters(p), p),
+    listPolicies: (p) => page2(
+      "attachedPolicies",
+      "AttachedPolicy_filter",
+      policyField,
+      { ...tokenFilters(p), active: argument(bool, p.active ?? true, "active") },
+      p
+    ),
+    getAccount: (wallet, options2) => single("account", argument(address2, wallet, "wallet"), accountField, options2),
+    getUser: (userId, options2) => single("user", argument(bytes322, userId, "userId"), userRef, options2),
+    listUserAccounts: (p) => page2("allowlistEntries", "AllowlistEntry_filter", entryField, userFilters(p), p),
+    listGlobalTraits: (p) => page2("globalTraits", "GlobalTrait_filter", globalTraitField, userFilters(p), p),
+    listTokenTraits: (p) => page2(
+      "tokenTraits",
+      "TokenTrait_filter",
+      tokenTraitField,
+      { ...userFilters(p), ...p.token === void 0 ? {} : tokenFilters({ token: p.token }) },
+      p
+    ),
+    listBalances(p = {}) {
+      if (p.wallet !== void 0 && p.userId !== void 0) {
+        throw new OpacityIndexerError(
+          "INVALID_ARGUMENT",
+          "Choose wallet or userId for balances, not both."
+        );
+      }
+      const filters = {
+        ...p.token === void 0 ? {} : tokenFilters({ token: p.token }),
+        ...p.tokenId === void 0 ? {} : { tokenId: bigintArgument(p.tokenId, "tokenId") },
+        ...argument(bool, p.positiveOnly ?? true, "positiveOnly") ? { balance_gt: "0" } : {}
+      };
+      if (p.userId !== void 0) {
+        return page2(
+          "userBalances",
+          "UserBalance_filter",
+          userBalanceField,
+          { ...filters, ...userFilters({ userId: p.userId }) },
+          p
+        );
+      }
+      return page2(
+        "tokenBalances",
+        "TokenBalance_filter",
+        walletBalanceField,
+        {
+          ...filters,
+          ...p.wallet === void 0 ? {} : { account: argument(address2, p.wallet, "wallet") }
+        },
+        p
+      );
+    },
+    listTransfers(p = {}) {
+      const filters = {
+        ...p.token === void 0 ? {} : tokenFilters({ token: p.token }),
+        ...p.tokenId === void 0 ? {} : { tokenId: bigintArgument(p.tokenId, "tokenId") }
+      };
+      const where = p.wallet === void 0 ? filters : {
+        or: [
+          { ...filters, from: argument(address2, p.wallet, "wallet") },
+          { ...filters, to: argument(address2, p.wallet, "wallet") }
+        ]
+      };
+      return page2("transferEvents", "TransferEvent_filter", transferField, where, p);
+    },
+    listDocumentAttestations: (p = {}) => page2(
+      "documentAttestations",
+      "DocumentAttestation_filter",
+      attestationField,
+      {
+        ...p.wallet === void 0 ? {} : { wallet: argument(address2, p.wallet, "wallet") },
+        ...p.userId === void 0 ? {} : userFilters({ userId: p.userId }),
+        ...p.traitId === void 0 ? {} : { traitId: argument(bytes322, p.traitId, "traitId") }
+      },
+      p
+    )
+  };
+  return Object.fromEntries(
+    INDEXER_OPERATIONS.map((operation) => [
+      operation,
+      async (...args) => {
+        const validated = validateIndexerOperationArgs(operation, args);
+        const invoke = namespace[operation];
+        return invoke(...validated);
+      }
+    ])
+  );
+}
+function validateIndexerOperationResult(operation, value, args = []) {
+  const last = args.at(-1);
+  const options2 = last && typeof last === "object" && !Array.isArray(last) ? last : {};
+  const requestedBlock = options2.cursor?.blockNumber ?? options2.blockNumber;
+  const requestedHash = options2.cursor?.blockHash ?? options2.blockHash;
+  if (operation === "getMetadata") {
+    const meta2 = metaField.parse(value, "metadata", true);
+    validateSnapshot(meta2, requestedBlock, requestedHash ?? void 0);
+    return meta2;
+  }
+  const result = record(value, "result");
+  const meta = metaField.parse(result["meta"], "meta", true);
+  requireHealthyIndex(meta);
+  validateSnapshot(meta, requestedBlock, requestedHash ?? void 0);
+  if (options2.cursor && options2.cursor.deployment !== meta.deployment)
+    throw new OpacityIndexerError(
+      "DEPLOYMENT_CHANGED",
+      "Subgraph deployment changed; restart pagination."
+    );
+  const fields = {
+    getRegistry: registryField,
+    getToken: tokenField,
+    getAccount: accountField,
+    getUser: userRef,
+    getVault: vaultField,
+    listTokens: tokenField,
+    listTokenIds: supplyField,
+    listTokenURIs: uriField,
+    listPolicies: policyField,
+    listUserAccounts: entryField,
+    listGlobalTraits: globalTraitField,
+    listTokenTraits: tokenTraitField,
+    listBalances: args[0] && typeof args[0] === "object" && args[0]["userId"] !== void 0 ? userBalanceField : walletBalanceField,
+    listTransfers: transferField,
+    listDocumentAttestations: attestationField,
+    listVaults: vaultField,
+    listVaultDeposits: vaultMovementField,
+    listVaultWithdrawals: vaultMovementField,
+    listVaultAdminExecutions: vaultAdminField
+  };
+  const field = fields[operation];
+  if (operation.startsWith("get")) {
+    const item = nullable(field).parse(result["item"], "item", true);
+    const id = operation === "getRegistry" ? "registry" : typeof args[0] === "string" ? args[0].toLowerCase() : void 0;
+    if (item !== null && record(item, "item")["id"] !== id) invalid2("item.id");
+    return { item, meta };
+  }
+  const items = array(field).parse(result["items"], "items", true);
+  if (items.length > (options2.pageSize ?? 100)) invalid2("items.length");
+  const cursorField = object2({
+    after: hex(),
+    blockNumber: uint2,
+    blockHash: nullable(bytes322),
+    deployment: stringField,
+    scope: stringField
+  });
+  const nextCursor = nullable(cursorField).parse(result["nextCursor"], "nextCursor", true);
+  if (nextCursor && (nextCursor.deployment !== meta.deployment || nextCursor.blockNumber !== meta.block.number || meta.block.hash !== null && nextCursor.blockHash !== meta.block.hash))
+    invalid2("nextCursor.snapshot");
+  if (nextCursor && options2.cursor && nextCursor.scope !== options2.cursor.scope)
+    invalid2("nextCursor.scope");
+  let previous = options2.cursor?.after ?? "";
+  for (const item of items) {
+    const id = record(item, "item")["id"];
+    if (typeof id !== "string" || id <= previous) invalid2("items.id order");
+    previous = id;
+  }
+  if (nextCursor && nextCursor.after !== previous) invalid2("nextCursor.after");
+  return { items, meta, nextCursor };
+}
+
+// src/indexer/wire.ts
+function encodeWireValue(value) {
+  if (typeof value === "bigint") return { __bigint: value.toString() };
+  if (value === null || typeof value === "boolean" || typeof value === "string") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (Array.isArray(value)) return value.map(encodeWireValue);
+  if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype) {
+    if ("__bigint" in value)
+      throw new OpacityIndexerError("INVALID_ARGUMENT", "__bigint is reserved.");
+    return Object.fromEntries(
+      Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => [key, encodeWireValue(item)])
+    );
+  }
+  throw new OpacityIndexerError(
+    "INVALID_ARGUMENT",
+    "Indexer arguments must be JSON values or bigint."
+  );
+}
+function decodeWireValue(value) {
+  if (Array.isArray(value)) return value.map(decodeWireValue);
+  if (typeof value === "object" && value !== null) {
+    const record2 = value;
+    if ("__bigint" in record2) {
+      if (Object.keys(record2).length !== 1 || typeof record2["__bigint"] !== "string" || !/^-?(0|[1-9]\d*)$/.test(record2["__bigint"])) {
+        throw new OpacityIndexerError("INVALID_RESPONSE", "Malformed bigint in indexer response.");
+      }
+      return BigInt(record2["__bigint"]);
+    }
+    return Object.fromEntries(
+      Object.entries(record2).map(([key, item]) => [key, decodeWireValue(item)])
+    );
+  }
+  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value))
+    return value;
+  throw new OpacityIndexerError("INVALID_RESPONSE", "Malformed indexer wire value.");
+}
+
+// src/indexer/client.ts
+function createSubgraphClient(config) {
+  validateSubgraphUrl(config.url);
+  const request = createGraphqlExecutor(config);
+  return {
+    async query(query, variables, options2) {
+      return await request(query, variables, options2);
+    }
+  };
+}
+
+export { INDEXER_OPERATIONS, OpacityIndexerError, createIndexerNamespace, createSubgraphClient, decodeWireValue, encodeWireValue, validateIndexerOperationArgs, validateIndexerOperationResult };
+//# sourceMappingURL=subgraph.js.map
+//# sourceMappingURL=subgraph.js.map