@secondlayer/sdk 6.19.0 → 6.21.0

package/dist/index.js

@@ -281,6 +281,19 @@ class Subgraphs extends BaseClient {
     const qs = options?.force ? "?force=true" : "";
     return this.request("DELETE", `/api/subgraphs/${name}${qs}`);
   }
+  async publish(name) {
+    return this.request("POST", `/api/subgraphs/${name}/publish`);
+  }
+  async unpublish(name) {
+    return this.request("POST", `/api/subgraphs/${name}/unpublish`);
+  }
+  async rows(name, table, params = {}) {
+    const { cursor, ...rest } = params;
+    const qs = buildSubgraphQueryString(rest);
+    const sep = qs ? "&" : "?";
+    const cursorQs = cursor ? `${sep}cursor=${encodeURIComponent(cursor)}` : "";
+    return this.request("GET", `/v1/subgraphs/${name}/${table}${qs}${cursorQs}`);
+  }
   async operations(name) {
     return this.request("GET", `/api/subgraphs/${name}/operations`);
   }
@@ -429,164 +442,6 @@ class Contracts extends BaseClient {
   }
 }
 
-// src/datasets/client.ts
-var PARAM_KEYS = {
-  fromBlock: "from_block",
-  toBlock: "to_block",
-  functionName: "function_name",
-  delegateTo: "delegate_to",
-  signerKey: "signer_key",
-  rewardCycle: "reward_cycle",
-  eventType: "event_type",
-  bnsId: "bns_id"
-};
-var CURSOR_SLUGS = {
-  "stx-transfers": { path: "stx-transfers", rowKey: "events" },
-  "sbtc-events": { path: "sbtc/events", rowKey: "events" },
-  "sbtc-token-events": { path: "sbtc/token-events", rowKey: "events" },
-  "pox-4-calls": { path: "pox-4/calls", rowKey: "calls" },
-  "burnchain-rewards": { path: "burnchain/rewards", rowKey: "rewards" },
-  "burnchain-reward-slots": {
-    path: "burnchain/reward-slots",
-    rowKey: "slots"
-  },
-  "bns-events": { path: "bns/events", rowKey: "events" },
-  "bns-namespace-events": { path: "bns/namespace-events", rowKey: "events" },
-  "bns-marketplace-events": {
-    path: "bns/marketplace-events",
-    rowKey: "events"
-  }
-};
-function catalogPathTail(path) {
-  return path.replace(/^\/?v1\/datasets\//, "").replace(/^\/+/, "");
-}
-
-class Datasets extends BaseClient {
-  catalogPromise;
-  constructor(options = {}) {
-    super(options);
-  }
-  listDatasets() {
-    return this.request("GET", "/v1/datasets");
-  }
-  async get(slug, params = {}) {
-    const { path, rowKey } = await this.resolveDataset(slug);
-    const env = await this.requestPath(path, this.paramsToQuery(params));
-    const value = env[rowKey];
-    const rows = Array.isArray(value) ? value : value == null ? [] : [value];
-    return {
-      rows,
-      next_cursor: env.next_cursor ?? null,
-      tip: env.tip
-    };
-  }
-  async query(slug, params = {}) {
-    const d = CURSOR_SLUGS[slug];
-    if (!d) {
-      throw new Error(`unknown cursor dataset "${slug}" (use one of: ${Object.keys(CURSOR_SLUGS).join(", ")})`);
-    }
-    const env = await this.requestPath(d.path, this.paramsToQuery(params));
-    return {
-      rows: env[d.rowKey] ?? [],
-      next_cursor: env.next_cursor ?? null,
-      tip: env.tip
-    };
-  }
-  stxTransfers = this.cursorDataset("stx-transfers", "events");
-  sbtcEvents = this.cursorDataset("sbtc/events", "events");
-  sbtcTokenEvents = this.cursorDataset("sbtc/token-events", "events");
-  pox4Calls = this.cursorDataset("pox-4/calls", "calls");
-  burnchainRewards = this.cursorDataset("burnchain/rewards", "rewards");
-  burnchainRewardSlots = this.cursorDataset("burnchain/reward-slots", "slots");
-  bnsEvents = this.cursorDataset("bns/events", "events");
-  bnsNamespaceEvents = this.cursorDataset("bns/namespace-events", "events");
-  bnsMarketplaceEvents = this.cursorDataset("bns/marketplace-events", "events");
-  bnsNames(params = {}) {
-    return this.requestPath("bns/names", buildQuery({
-      namespace: params.namespace,
-      owner: params.owner,
-      limit: params.limit,
-      offset: params.offset
-    }));
-  }
-  bnsNamespaces() {
-    return this.requestPath("bns/namespaces", "");
-  }
-  bnsResolve(fqn) {
-    return this.requestPath("bns/resolve", buildQuery({ fqn }));
-  }
-  networkHealth() {
-    return this.requestPath("network-health/summary", "");
-  }
-  requestPath(path, query) {
-    return this.request("GET", `/v1/datasets/${path}${query}`);
-  }
-  async resolveDataset(slug) {
-    const cursor = CURSOR_SLUGS[slug];
-    if (cursor)
-      return { path: cursor.path, rowKey: cursor.rowKey };
-    const families = await this.loadCatalog();
-    const tail = catalogPathTail(slug);
-    const match = families.find((f) => f.family === slug || catalogPathTail(f.path) === tail);
-    if (!match) {
-      throw new Error(`unknown dataset "${slug}" (available: ${families.map((f) => f.family).join(", ")})`);
-    }
-    return { path: catalogPathTail(match.path), rowKey: match.row_key };
-  }
-  loadCatalog() {
-    this.catalogPromise ??= (async () => {
-      const raw = await this.listDatasets();
-      const families = raw.families;
-      if (!Array.isArray(families)) {
-        throw new Error("dataset catalog response missing families[]");
-      }
-      return families;
-    })();
-    return this.catalogPromise;
-  }
-  paramsToQuery(params) {
-    const mapped = {};
-    for (const [k, v] of Object.entries(params)) {
-      if (v === undefined || v === null || k === "batchSize" || k === "signal")
-        continue;
-      mapped[PARAM_KEYS[k] ?? k] = v;
-    }
-    return buildQuery(mapped);
-  }
-  cursorDataset(path, rowKey) {
-    const list = async (params = {}) => {
-      const envelope = await this.requestPath(path, this.paramsToQuery(params));
-      return {
-        rows: envelope[rowKey] ?? [],
-        next_cursor: envelope.next_cursor ?? null,
-        tip: envelope.tip
-      };
-    };
-    const walk = async function* (params = {}) {
-      const batchSize = params.batchSize ?? 200;
-      let cursor = params.cursor ?? null;
-      let first = true;
-      while (!params.signal?.aborted) {
-        const env = await list({
-          ...params,
-          limit: batchSize,
-          cursor: first ? params.cursor : cursor ?? undefined
-        });
-        for (const row of env.rows) {
-          if (params.signal?.aborted)
-            return;
-          yield row;
-        }
-        if (!env.next_cursor || env.next_cursor === cursor || env.rows.length < batchSize)
-          return;
-        cursor = env.next_cursor;
-        first = false;
-      }
-    }.bind(this);
-    return { list, walk };
-  }
-}
-
 // src/index-api/client.ts
 function firstWalkFromHeight(params) {
   if (params.fromHeight !== undefined)
@@ -606,18 +461,18 @@ class Index extends BaseClient {
   discover() {
     return this.request("GET", "/v1/index");
   }
-  ftTransfers = {
+  ftTransfers = Object.assign((params = {}) => this.listFtTransfers(params), {
     list: (params = {}) => this.listFtTransfers(params),
     walk: (params = {}) => this.walkFtTransfers(params)
-  };
-  nftTransfers = {
+  });
+  nftTransfers = Object.assign((params = {}) => this.listNftTransfers(params), {
     list: (params = {}) => this.listNftTransfers(params),
     walk: (params = {}) => this.walkNftTransfers(params)
-  };
-  events = {
+  });
+  events = Object.assign((params) => this.listEvents(params), {
     list: (params) => this.listEvents(params),
     walk: (params) => this.walkEvents(params)
-  };
+  });
   contractCalls = {
     list: (params = {}) => this.listContractCalls(params),
     walk: (params = {}) => this.walkContractCalls(params)
@@ -1182,6 +1037,38 @@ async function consumeStreamsEvents(opts) {
   }
   return { cursor, pages, emptyPolls };
 }
+async function* iterateStreamsBatches(opts) {
+  const sleep = opts.sleep ?? defaultSleep;
+  let cursor = opts.fromCursor ?? null;
+  while (!opts.signal?.aborted) {
+    const envelope = await opts.fetchEvents({
+      cursor,
+      limit: opts.batchSize,
+      types: opts.types,
+      notTypes: opts.notTypes,
+      contractId: opts.contractId,
+      sender: opts.sender,
+      recipient: opts.recipient,
+      assetIdentifier: opts.assetIdentifier
+    });
+    const checkpoint = envelope.next_cursor ?? cursor;
+    if (envelope.events.length > 0 || envelope.reorgs.length > 0) {
+      yield {
+        events: envelope.events,
+        cursor: checkpoint,
+        tip: envelope.tip,
+        reorgs: envelope.reorgs
+      };
+    }
+    const advanced = checkpoint !== null && checkpoint !== cursor;
+    cursor = checkpoint;
+    if (!advanced && envelope.events.length === 0) {
+      if (opts.signal?.aborted)
+        return;
+      await sleep(opts.intervalMs, opts.signal);
+    }
+  }
+}
 async function* streamStreamsEvents(opts) {
   const sleep = opts.sleep ?? defaultSleep;
   const emptyBackoffMs = opts.emptyBackoffMs ?? 500;
@@ -1559,6 +1446,21 @@ function createStreamsClient(options) {
     })}`);
   }
   return {
+    consume(params = {}) {
+      return iterateStreamsBatches({
+        fromCursor: params.cursor,
+        batchSize: params.batchSize ?? 100,
+        intervalMs: params.intervalMs ?? 2000,
+        types: params.types,
+        notTypes: params.notTypes,
+        contractId: params.contractId,
+        sender: params.sender,
+        recipient: params.recipient,
+        assetIdentifier: params.assetIdentifier,
+        signal: params.signal,
+        fetchEvents
+      });
+    },
     events: {
       list: listEvents,
       byTxId(txId) {
@@ -1711,7 +1613,6 @@ class Subscriptions extends BaseClient {
 class SecondLayer extends BaseClient {
   streams;
   index;
-  datasets;
   contracts;
   subgraphs;
   subscriptions;
@@ -1726,13 +1627,15 @@ class SecondLayer extends BaseClient {
       dumpsBaseUrl: options.dumpsBaseUrl
     });
     this.index = new Index(options);
-    this.datasets = new Datasets(options);
     this.contracts = new Contracts(options);
     this.subgraphs = new Subgraphs(options);
     this.subscriptions = new Subscriptions(options);
     this.apiKeys = new ApiKeys(options);
     this.projects = new Projects(options);
   }
+  async batch(requests) {
+    return this.request("POST", "/v1/batch", { requests });
+  }
   async context() {
     const safe = (p) => p.then((v) => v).catch(() => null);
     const [
@@ -2093,6 +1996,220 @@ function decodePrint(event) {
 import {
   STREAMS_EVENT_TYPES
 } from "@secondlayer/shared";
+// src/x402.ts
+import {
+  X402_TOKENS,
+  findX402TokenByAsset
+} from "@secondlayer/shared/x402";
+import {
+  serializeTransactionHex,
+  signTransactionWithAccount
+} from "@secondlayer/stacks/transactions";
+import { buildExactTransfer } from "@secondlayer/stacks/x402";
+var DEFAULT_PREFER_ASSETS = [
+  "sBTC",
+  "USDCx",
+  "STX"
+];
+var DEFAULT_NONCE_NODE_URL = "https://api.hiro.so";
+
+class X402SpendGuardError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "X402SpendGuardError";
+  }
+}
+function b64encode(value) {
+  return Buffer.from(JSON.stringify(value), "utf8").toString("base64");
+}
+function b64decodeJson(value) {
+  try {
+    return JSON.parse(Buffer.from(value, "base64").toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+async function readX402Challenge(res) {
+  const header = res.headers.get("PAYMENT-REQUIRED");
+  if (header) {
+    const decoded = b64decodeJson(header);
+    if (decoded)
+      return decoded;
+  }
+  try {
+    return await res.clone().json();
+  } catch {
+    return null;
+  }
+}
+function readX402Receipt(res) {
+  const header = res.headers.get("PAYMENT-RESPONSE");
+  return header ? b64decodeJson(header) : null;
+}
+function selectOffer(challenge, opts = {}) {
+  const prefer = opts.preferAssets ?? DEFAULT_PREFER_ASSETS;
+  for (const symbol of prefer) {
+    const token = X402_TOKENS[symbol];
+    const accept = challenge.accepts.find((a) => a.asset === token.asset);
+    if (!accept)
+      continue;
+    const cap = opts.maxAmountPerCall?.[symbol];
+    if (cap !== undefined && BigInt(accept.amount) > cap)
+      continue;
+    return { accept, symbol };
+  }
+  throw new X402SpendGuardError("no x402 offer matched preferAssets within maxAmountPerCall");
+}
+async function resolveAccountNonce(address, nodeUrl = DEFAULT_NONCE_NODE_URL) {
+  const res = await fetch(`${nodeUrl.replace(/\/$/, "")}/v2/accounts/${address}?proof=0`);
+  if (!res.ok)
+    throw new Error(`x402 nonce lookup failed: ${res.status}`);
+  const json = await res.json();
+  return json.nonce;
+}
+async function buildSignedX402Payment(opts) {
+  const accept = opts.asset ? opts.challenge.accepts.find((a) => a.asset === opts.asset) : opts.challenge.accepts[0];
+  if (!accept) {
+    throw new Error(`No x402 offer${opts.asset ? ` for asset ${opts.asset}` : ""}`);
+  }
+  const token = findX402TokenByAsset(accept.asset);
+  if (!token)
+    throw new Error(`Unknown x402 asset: ${accept.asset}`);
+  const asset = token.contractId && token.assetName ? {
+    kind: "sip010",
+    contractId: token.contractId,
+    assetName: token.assetName
+  } : { kind: "stx" };
+  const tx = buildExactTransfer({
+    asset,
+    amount: BigInt(accept.amount),
+    payTo: accept.payTo,
+    payer: opts.account.address,
+    payerPublicKey: opts.account.publicKey,
+    accountNonce: opts.accountNonce,
+    nonce: accept.extra.nonce,
+    chain: opts.chain
+  });
+  const signed = await signTransactionWithAccount(tx, opts.account);
+  const header = b64encode({
+    x402Version: opts.challenge.x402Version ?? 2,
+    scheme: "exact",
+    network: accept.network,
+    asset: accept.asset,
+    payload: { transaction: serializeTransactionHex(signed) },
+    extra: { nonce: accept.extra.nonce }
+  });
+  return { header, accept };
+}
+function withX402(baseFetch, opts) {
+  const sessions = new Map;
+  let balanceToken = opts.balanceToken ?? null;
+  let toppingUp = false;
+  const originOf = (input) => {
+    try {
+      return new URL(String(input)).origin;
+    } catch {
+      return "";
+    }
+  };
+  const wrapped = async (input, init) => {
+    const origin = originOf(input);
+    const run = (extra, signal2) => baseFetch(input, {
+      ...init,
+      headers: { ...init?.headers, ...extra },
+      ...signal2 ? { signal: signal2 } : {}
+    });
+    const maybeTopUp = (res) => {
+      const policy = opts.topUp;
+      if (!policy || toppingUp || !origin)
+        return;
+      const remaining = res.headers.get("X-BALANCE-REMAINING-USD");
+      if (remaining === null || Number(remaining) >= policy.whenBelow)
+        return;
+      toppingUp = true;
+      (async () => {
+        try {
+          const dep = await wrapped(`${origin}/v1/x402/deposit?usd=${policy.usd}`, { method: "POST" });
+          if (dep.ok) {
+            const body = await dep.json();
+            if (body.balance_token)
+              balanceToken = body.balance_token;
+          }
+        } catch {} finally {
+          toppingUp = false;
+        }
+      })();
+    };
+    const remember = (res) => {
+      const voucher = res.headers.get("PAYMENT-SESSION");
+      if (voucher && origin)
+        sessions.set(origin, voucher);
+      maybeTopUp(res);
+      return res;
+    };
+    const cached = origin ? sessions.get(origin) : undefined;
+    const first = await run({
+      ...cached ? { "PAYMENT-SESSION": cached } : {},
+      ...balanceToken ? { "PAYMENT-BALANCE": balanceToken } : {}
+    });
+    if (first.status !== 402)
+      return remember(first);
+    if (cached && origin)
+      sessions.delete(origin);
+    const challenge = await readX402Challenge(first);
+    if (!challenge)
+      return first;
+    const { accept } = selectOffer(challenge, opts);
+    const accountNonce = opts.accountNonce ?? await resolveAccountNonce(opts.account.address, opts.nodeUrl);
+    const { header } = await buildSignedX402Payment({
+      challenge,
+      account: opts.account,
+      accountNonce,
+      asset: accept.asset,
+      chain: opts.chain
+    });
+    opts.onSettling?.({ asset: accept.asset, amount: accept.amount });
+    const signal = opts.timeoutMs ? AbortSignal.timeout(opts.timeoutMs) : undefined;
+    return remember(await run({ "PAYMENT-SIGNATURE": header }, signal));
+  };
+  return wrapped;
+}
+function createX402Client(opts) {
+  const f = withX402(opts.fetch ?? fetch, opts);
+  const base = opts.baseUrl.replace(/\/$/, "");
+  async function request(method, path, o = {}) {
+    const qs = o.query ? `?${new URLSearchParams(o.query).toString()}` : "";
+    const init = { method };
+    if (o.body !== undefined) {
+      init.body = JSON.stringify(o.body);
+      init.headers = { "content-type": "application/json" };
+    }
+    const response = await f(`${base}${path}${qs}`, init);
+    const data = await response.json().catch(() => null);
+    return { data, payment: readX402Receipt(response), response };
+  }
+  return {
+    get: (path, o) => request("GET", path, o),
+    post: (path, o) => request("POST", path, o)
+  };
+}
+async function payAndRetry(doFetch, opts) {
+  const first = await doFetch({});
+  if (first.status !== 402)
+    return first;
+  const challenge = await readX402Challenge(first);
+  if (!challenge)
+    return first;
+  const { accept } = selectOffer(challenge, opts);
+  const { header } = await buildSignedX402Payment({
+    challenge,
+    account: opts.account,
+    accountNonce: opts.accountNonce,
+    asset: accept.asset,
+    chain: opts.chain
+  });
+  return doFetch({ "PAYMENT-SIGNATURE": header });
+}
 // src/webhooks.ts
 import { verifySecondlayerSignatureValues } from "@secondlayer/shared/crypto/secondlayer-webhook";
 import {
@@ -2218,11 +2335,17 @@ function verifyTransactionProof(proof, opts) {
   };
 }
 export {
+  withX402,
   verifyWebhookSignature,
   verifyTransactionProof,
   verifySecondlayerSignature,
   trigger,
   toJsonSafe,
+  selectOffer,
+  resolveAccountNonce,
+  readX402Receipt,
+  readX402Challenge,
+  payAndRetry,
   isStxTransfer,
   isStxMint,
   isStxLock,
@@ -2248,7 +2371,10 @@ export {
   decodeFtMint,
   decodeFtBurn,
   decodeClarityValue,
+  createX402Client,
   createStreamsClient,
+  buildSignedX402Payment,
+  X402SpendGuardError,
   VersionConflictError,
   ValidationError,
   Subscriptions,
@@ -2259,15 +2385,14 @@ export {
   RateLimitError,
   Projects,
   Index,
-  Datasets,
+  DEFAULT_PREFER_ASSETS,
   Cursor,
   Contracts,
-  CURSOR_SLUGS,
   ByoBreakingChangeError,
   AuthError,
   ApiKeys,
   ApiError
 };
 
-//# debugId=AD881ECDD1B046B864756E2164756E21
+//# debugId=EAC231197163FBBB64756E2164756E21
 //# sourceMappingURL=index.js.map